diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindATSPI2.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindATSPI2.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b7e7ab0230ce8fddaac42189cbf6d8cf2e85c64e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindATSPI2.cmake @@ -0,0 +1,10 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +pkg_check_modules(ATSPI2 IMPORTED_TARGET "atspi-2") + +if (NOT TARGET PkgConfig::ATSPI2) + set(ATSPI2_FOUND 0) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindDB2.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindDB2.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d26627dd7f643a979c52840ad13eea9f411c8941 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindDB2.cmake @@ -0,0 +1,65 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +#.rst: +# FindDB2 +# --------- +# +# Try to locate the db2 client library. +# If found, this will define the following variables: +# +# ``DB2_FOUND`` +# True if the db2 library is available +# ``DB2_INCLUDE_DIRS`` +# The db2 include directories +# ``DB2_LIBRARIES`` +# The db2 libraries for linking +# +# If ``DB2_FOUND`` is TRUE, it will also define the following +# imported target: +# +# ``DB2::DB2`` +# The db2 client library + +if (NOT DEFINED DB2_INCLUDE_DIR) + find_path(DB2_INCLUDE_DIR + NAMES sqlcli1.h + HINTS ENV DB2_HOME + PATH_SUFFIXES include) +else() + find_path(DB2_INCLUDE_DIR + NAMES sqlcli1.h + HINTS ${DB2_INCLUDE_DIR}) +endif() + +if (NOT DEFINED DB2_LIBRARY_DIR) + find_library(DB2_LIBRARY + NAMES db2 + HINTS ENV DB2LIB) +else() + find_library(DB2_LIBRARY + NAMES db2 + HINTS ${DB2_LIBRARY_DIR}) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(DB2 DEFAULT_MSG DB2_INCLUDE_DIR DB2_LIBRARY) + +if(DB2_FOUND) + set(DB2_INCLUDE_DIRS "${DB2_INCLUDE_DIR}") + set(DB2_LIBRARIES "${DB2_LIBRARY}") + if(NOT TARGET DB2::DB2) + add_library(DB2::DB2 UNKNOWN IMPORTED) + set_target_properties(DB2::DB2 PROPERTIES + IMPORTED_LOCATION "${DB2_LIBRARIES}" + INTERFACE_INCLUDE_DIRECTORIES "${DB2_INCLUDE_DIRS}") + endif() +endif() + +mark_as_advanced(DB2_INCLUDE_DIR DB2_LIBRARY) + +include(FeatureSummary) +set_package_properties(DB2 PROPERTIES + URL "https://www.ibm.com" + DESCRIPTION "IBM DB2 client library") + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindDirectFB.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindDirectFB.cmake new file mode 100644 index 0000000000000000000000000000000000000000..02464a966299220d8f8a4bde192022e9eaa328d1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindDirectFB.cmake @@ -0,0 +1,10 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +pkg_check_modules(DirectFB IMPORTED_TARGET "directfb") + +if (NOT TARGET PkgConfig::DirectFB) + set(DirectFB_FOUND 0) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGLESv2.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGLESv2.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b00a31d7a1c5a7771d5472055524a15ec4bdf26c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGLESv2.cmake @@ -0,0 +1,90 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(CheckCXXSourceCompiles) + +# No library linkage is necessary to use GLESv2 with Emscripten. The headers are also +# system headers, so we don't need to search for them. +if(EMSCRIPTEN) + set(HAVE_GLESv2 ON) +else() + find_library(GLESv2_LIBRARY NAMES GLESv2 OpenGLES) + find_path(GLESv2_INCLUDE_DIR NAMES "GLES2/gl2.h" "OpenGLES/ES2/gl.h" DOC "The OpenGLES 2 include path") + find_package(EGL) + set(_libraries "${CMAKE_REQUIRED_LIBRARIES}") + if(GLESv2_LIBRARY) + list(APPEND CMAKE_REQUIRED_LIBRARIES "${GLESv2_LIBRARY}") + endif () + if(EGL_LIBRARY) + list(APPEND CMAKE_REQUIRED_LIBRARIES "${EGL_LIBRARY}") + endif() + set(_includes "${CMAKE_REQUIRED_INCLUDES}") + list(APPEND CMAKE_REQUIRED_INCLUDES "${GLESv2_INCLUDE_DIR}") + + find_package(PlatformGraphics) + if(TARGET PlatformGraphics::PlatformGraphics) + platform_graphics_extend_check_cxx_source_required_variables() + endif() + check_cxx_source_compiles(" +#ifdef __APPLE__ +# include +#else +# define GL_GLEXT_PROTOTYPES +# include +#endif + +int main(int, char **) { + glUniform1f(1, GLfloat(1.0)); + glClear(GL_COLOR_BUFFER_BIT); +}" HAVE_GLESv2) + + set(CMAKE_REQUIRED_LIBRARY "${_libraries}") + unset(_libraries) + set(CMAKE_REQUIRED_INCLUDES "${_includes}") + unset(_includes) + set(package_args GLESv2_INCLUDE_DIR GLESv2_LIBRARY HAVE_GLESv2) +endif() + +# Framework handling partially inspired by FindGLUT.cmake. +if(GLESv2_LIBRARY MATCHES "/([^/]+)\\.framework$") + # TODO: Might need to handle non .tbd suffixes, but didn't find an + # example like that. + # TODO: Might need to handle INTERFACE_INCLUDE_DIRECTORIES differently. + set(_library_imported_location "${GLESv2_LIBRARY}/${CMAKE_MATCH_1}.tbd") + if(NOT EXISTS "${_library_imported_location}") + set(_library_imported_location "") + endif() +else() + set(_library_imported_location "${GLESv2_LIBRARY}") +endif() +set(GLESv2_LIBRARY "${_library_imported_location}") + +list(APPEND package_args HAVE_GLESv2) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(GLESv2 DEFAULT_MSG ${package_args}) + +mark_as_advanced(${package_args}) + +if(GLESv2_FOUND AND NOT TARGET GLESv2::GLESv2) + if(EMSCRIPTEN OR IOS) + add_library(GLESv2::GLESv2 INTERFACE IMPORTED) + if(IOS) + # For simulator_and_device builds we can't specify the full library path, because + # it's specific to either the device or the simulator. Resort to passing a link + # flag instead. + target_link_libraries(GLESv2::GLESv2 INTERFACE "-framework OpenGLES") + endif() + else() + add_library(GLESv2::GLESv2 UNKNOWN IMPORTED) + set_target_properties(GLESv2::GLESv2 PROPERTIES + IMPORTED_LOCATION "${GLESv2_LIBRARY}" + INTERFACE_INCLUDE_DIRECTORIES "${GLESv2_INCLUDE_DIR}") + + if(TARGET EGL::EGL) + target_link_libraries(GLESv2::GLESv2 INTERFACE "EGL::EGL") + elseif(EGL_LIBRARY) + target_link_libraries(GLESv2::GLESv2 INTERFACE "${EGL_LIBRARY}") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGSSAPI.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGSSAPI.cmake new file mode 100644 index 0000000000000000000000000000000000000000..68e0122be5749fa2bbad1a873f9b4bf0c4b29bc3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGSSAPI.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) +pkg_check_modules(PC_GSSAPI QUIET "krb5-gssapi") +if (NOT PC_GSSAPI_FOUND) + pkg_check_modules(PC_GSSAPI QUIET "mit-krb5-gssapi") +endif() + +find_path(GSSAPI_INCLUDE_DIRS + NAMES gssapi/gssapi.h + HINTS ${PC_GSSAPI_INCLUDEDIR} +) + +# On macOS, vcpkg opts for finding frameworks LAST. This is generally fine; +# however, in the case of GSSAPI, `usr/lib/libgssapi_krb5.tbd` which is a +# symlink to `Kerberos.framework` misses a few symols, e.g., +# `___gss_c_nt_hostbased_service_oid_desc`, and it causes build failure. +# So, we need to make sure that we find `GSS.framework`. +set(gssapi_library_names + GSS # framework + gss # solaris + gssapi # FreeBSD + gssapi_krb5 +) +if(APPLE) + list(REMOVE_ITEM gssapi_library_names "gssapi_krb5") +endif() + +find_library(GSSAPI_LIBRARIES + NAMES + ${gssapi_library_names} + HINTS ${PC_GSSAPI_LIBDIR} +) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(GSSAPI DEFAULT_MSG GSSAPI_LIBRARIES GSSAPI_INCLUDE_DIRS) + +if(GSSAPI_FOUND AND NOT TARGET GSSAPI::GSSAPI) + if(GSSAPI_LIBRARIES MATCHES "/([^/]+)\\.framework$") + add_library(GSSAPI::GSSAPI INTERFACE IMPORTED) + set_target_properties(GSSAPI::GSSAPI PROPERTIES + INTERFACE_LINK_LIBRARIES "${GSSAPI_LIBRARIES}") + else() + add_library(GSSAPI::GSSAPI UNKNOWN IMPORTED) + set_target_properties(GSSAPI::GSSAPI PROPERTIES + IMPORTED_LOCATION "${GSSAPI_LIBRARIES}") + endif() + + set_target_properties(GSSAPI::GSSAPI PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${GSSAPI_INCLUDE_DIRS}") +endif() + +mark_as_advanced(GSSAPI_INCLUDE_DIRS GSSAPI_LIBRARIES) + +include(FeatureSummary) +set_package_properties(GSSAPI PROPERTIES + DESCRIPTION "Generic Security Services Application Program Interface") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGTK3.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGTK3.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5653534ea5eb2417f1f0a5c2e4af551910dbc233 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindGTK3.cmake @@ -0,0 +1,15 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +set(__gtk3_required_version "${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION}") +if(__gtk3_required_version) + set(__gtk3_required_version " >= ${__gtk3_required_version}") +endif() +pkg_check_modules(GTK3 IMPORTED_TARGET "gtk+-3.0${__gtk3_required_version}") + +if (NOT TARGET PkgConfig::GTK3) + set(GTK3_FOUND 0) +endif() +unset(__gtk3_required_version) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindInterbase.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindInterbase.cmake new file mode 100644 index 0000000000000000000000000000000000000000..32f62d42bed5d2746fc823bdd772cfd647a5b319 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindInterbase.cmake @@ -0,0 +1,61 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +#.rst: +# FindInterbase +# --------- +# +# Try to locate the Interbase client library. +# If found, this will define the following variables: +# +# ``Interbase_FOUND`` +# True if the Interbase library is available +# ``Interbase_INCLUDE_DIR`` +# The Interbase include directories +# ``Interbase_LIBRARY`` +# The Interbase libraries for linking +# +# If ``Interbase_FOUND`` is TRUE, it will also define the following +# imported target: +# +# ``Interbase::Interbase`` +# The Interbase client library + +if(NOT DEFINED Interbase_ROOT) + if(DEFINED ENV{Interbase_ROOT}) + set(Interbase_ROOT "$ENV{Interbase_ROOT}") + endif() +endif() + +find_path(Interbase_INCLUDE_DIR + NAMES ibase.h + HINTS "${Interbase_INCLUDEDIR}" "${Interbase_ROOT}/include" + PATH_SUFFIXES firebird +) + +find_library(Interbase_LIBRARY + NAMES firebase_ms fbclient_ms fbclient gds + HINTS "${Interbase_LIBDIR}" "${Interbase_ROOT}/lib" +) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Interbase DEFAULT_MSG Interbase_LIBRARY Interbase_INCLUDE_DIR) + +if(Interbase_FOUND) + set(Interbase_INCLUDE_DIRS "${Interbase_INCLUDE_DIR}") + set(Interbase_LIBRARIES "${Interbase_LIBRARY}") + if(NOT TARGET Interbase::Interbase) + add_library(Interbase::Interbase UNKNOWN IMPORTED) + set_target_properties(Interbase::Interbase PROPERTIES + IMPORTED_LOCATION "${Interbase_LIBRARIES}" + INTERFACE_INCLUDE_DIRECTORIES "${Interbase_INCLUDE_DIRS};") + endif() +endif() + +mark_as_advanced(Interbase_INCLUDE_DIR Interbase_LIBRARY) + +include(FeatureSummary) +set_package_properties(Interbase PROPERTIES + URL "https://www.embarcadero.com/products/interbase" + DESCRIPTION "Interbase client library") + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibb2.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibb2.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5877f664aba2ef1c2542fdfbb7b88a2a013de1f7 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibb2.cmake @@ -0,0 +1,40 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Blake2 contains a reference implementation, libb2 is a more efficient +# implementation of a subset of Blake2 functions and should be preferred. +# This Find module only searches for libb2 for that reason. + +if(TARGET Libb2::Libb2) + set(Libb2_FOUND TRUE) + return() +endif() + +find_package(PkgConfig QUIET) + +if(PkgConfig_FOUND) + pkg_check_modules(Libb2 IMPORTED_TARGET "libb2") + + if (TARGET PkgConfig::Libb2) + add_library(Libb2::Libb2 INTERFACE IMPORTED) + target_link_libraries(Libb2::Libb2 INTERFACE PkgConfig::Libb2) + set(Libb2_FOUND TRUE) + endif() +else() + find_path(LIBB2_INCLUDE_DIR NAMES blake2.h) + find_library(LIBB2_LIBRARY NAMES b2) + + if(LIBB2_LIBRARY AND LIBB2_INCLUDE_DIR) + add_library(Libb2::Libb2 UNKNOWN IMPORTED) + set_target_properties(Libb2::Libb2 PROPERTIES + IMPORTED_LOCATION ${LIBB2_LIBRARY} + INTERFACE_INCLUDE_DIRECTORIES ${LIBB2_INCLUDE_DIR} + ) + endif() + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(Libb2 REQUIRED_VARS + LIBB2_LIBRARY + LIBB2_INCLUDE_DIR + ) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibmng.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibmng.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ed59fd822a312c2e36358deea670c6c611c0aa51 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibmng.cmake @@ -0,0 +1,38 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(TARGET Libmng::Libmng) + set(Libmng_FOUND TRUE) + return() +endif() + +find_package(PkgConfig QUIET) + +if(PkgConfig_FOUND) + pkg_check_modules(Libmng IMPORTED_TARGET libmng) + + if(TARGET PkgConfig::Libmng) + add_library(Libmng::Libmng INTERFACE IMPORTED) + target_link_libraries(Libmng::Libmng INTERFACE PkgConfig::Libmng) + set(Libmng_FOUND TRUE) + endif() +endif() + +if(NOT TARGET Libmng::Libmng) + find_library(LIBMNG_LIBRARY NAMES mng) + find_path(LIBMNG_INCLUDE_DIR libmng.h) + + if(LIBMNG_LIBRARY AND LIBMNG_INCLUDE_DIR) + add_library(Libmng::Libmng UNKNOWN IMPORTED) + set_target_properties(Libmng::Libmng PROPERTIES + IMPORTED_LOCATION ${LIBMNG_LIBRARY} + INTERFACE_INCLUDE_DIRECTORIES ${LIBMNG_INCLUDE_DIR} + ) + endif() + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(Libmng REQUIRED_VARS + LIBMNG_LIBRARY + LIBMNG_INCLUDE_DIR + ) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibproxy.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibproxy.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8670d651662e9d1f429e9f88dd51d184ee40b432 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibproxy.cmake @@ -0,0 +1,10 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +pkg_check_modules(Libproxy IMPORTED_TARGET "libproxy-1.0") + +if (NOT TARGET PkgConfig::Libproxy) + set(Libproxy_FOUND 0) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibsystemd.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibsystemd.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f488f8ac267ad7e46887b28547dd18a92dd51c16 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibsystemd.cmake @@ -0,0 +1,10 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +pkg_check_modules(Libsystemd IMPORTED_TARGET "libsystemd") + +if (NOT TARGET PkgConfig::Libsystemd) + set(Libsystemd_FOUND 0) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibudev.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibudev.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6ce4de1d05e36ae32950f8dbe55fc394f74868b3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindLibudev.cmake @@ -0,0 +1,10 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +pkg_check_modules(Libudev IMPORTED_TARGET "libudev") + +if (NOT TARGET PkgConfig::Libudev) + set(Libudev_FOUND 0) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMimer.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMimer.cmake new file mode 100644 index 0000000000000000000000000000000000000000..98d9851617f2b2ce455fb76832f28cd54323099b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMimer.cmake @@ -0,0 +1,98 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# Copyright (C) 2022 Mimer Information Technology +# SPDX-License-Identifier: BSD-3-Clause + +# FindMimer +# --------- +# Try to locate the Mimer SQL client library +if(NOT DEFINED MimerSQL_ROOT) + if(DEFINED ENV{MIMERSQL_DEV_ROOT}) + set(MimerSQL_ROOT "$ENV{MIMERSQL_DEV_ROOT}") + endif() +endif() + +if(NOT DEFINED MimerSQL_ROOT) + find_package(PkgConfig QUIET) +endif() +if(PkgConfig_FOUND AND NOT DEFINED MimerSQL_ROOT) + pkg_check_modules(PC_Mimer QUIET mimcontrol) + set(MimerSQL_include_dir_hints "${PC_MimerSQL_INCLUDEDIR}") + set(MimerSQL_library_hints "${PC_MimerSQL_LIBDIR}") +else() + if(DEFINED MimerSQL_ROOT) + if(WIN32) + set(MimerSQL_include_dir_hints "${MimerSQL_ROOT}\\include") + if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$") + set(MimerSQL_library_hints "${MimerSQL_ROOT}\\lib\\x86") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$") + set(MimerSQL_library_hints "${MimerSQL_ROOT}\\lib\\amd64") + else() + set(MimerSQL_library_hints "") + endif() + else() + set(MimerSQL_include_dir_hints "${MimerSQL_ROOT}/include") + set(MimerSQL_library_hints "${MimerSQL_ROOT}/lib") + endif() + else() + if(WIN32) + set(MimerSQL_include_dir_hints "C:\\MimerSQLDev\\include") + if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$") + set(MimerSQL_library_hints "C:\\MimerSQLDev\\lib\\x86") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$") + set(MimerSQL_library_hints "C:\\MimerSQLDev\\lib\\amd64") + else() + set(MimerSQL_library_hints "") + endif() + elseif(APPLE AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin") + set(MimerSQL_library_hints "/usr/local/lib") + set(MimerSQL_include_dir_hints "/usr/local/include") + else() + set(MimerSQL_include_dir_hints "") + set(MimerSQL_library_hints "") + endif() + endif() +endif() + +find_path(Mimer_INCLUDE_DIR + NAMES mimerapi.h + HINTS ${MimerSQL_include_dir_hints}) + +if(WIN32) + if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$") + set(MIMER_LIBS_NAMES mimapi32) + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$") + set(MIMER_LIBS_NAMES mimapi64) + endif() +else() + set(MIMER_LIBS_NAMES mimerapi) +endif() + +find_library(Mimer_LIBRARIES + NAMES ${MIMER_LIBS_NAMES} + HINTS ${MimerSQL_library_hints}) + +include(FindPackageHandleStandardArgs) + +find_package_handle_standard_args(Mimer + REQUIRED_VARS Mimer_LIBRARIES Mimer_INCLUDE_DIR) + + + +# Now try to get the include and library path. +if(Mimer_FOUND) + set(Mimer_INCLUDE_DIRS ${Mimer_INCLUDE_DIR}) + set(Mimer_LIBRARY_DIRS ${Mimer_LIBRARIES}) + if (NOT TARGET MimerSQL::MimerSQL) + add_library(MimerSQL::MimerSQL UNKNOWN IMPORTED) + set_target_properties(MimerSQL::MimerSQL PROPERTIES + IMPORTED_LOCATION "${Mimer_LIBRARY_DIRS}" + INTERFACE_INCLUDE_DIRECTORIES "${Mimer_INCLUDE_DIRS}") + endif () +endif() + +mark_as_advanced(Mimer_INCLUDE_DIR Mimer_LIBRARIES) + +include(FeatureSummary) +set_package_properties(MimerSQL PROPERTIES + URL "https://www.mimer.com" + DESCRIPTION "Mimer client library") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMtdev.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMtdev.cmake new file mode 100644 index 0000000000000000000000000000000000000000..934496a37fb54a1030bae527dad9d486186db77b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMtdev.cmake @@ -0,0 +1,10 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +pkg_check_modules(Mtdev IMPORTED_TARGET "mtdev") + +if (NOT TARGET PkgConfig::Mtdev) + set(Mtdev_FOUND 0) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMySQL.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMySQL.cmake new file mode 100644 index 0000000000000000000000000000000000000000..670e7fc239fd7a7e58fd3f553011db6173c3c4f9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindMySQL.cmake @@ -0,0 +1,104 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +#.rst: +# FindMySQL +# --------- +# +# Try to locate the mysql client library. +# +# By default, pkg-config is used, if available. +# If pkg-config is not available or if you want to disable it, set the ``MySQL_ROOT`` variable. +# The following variables can be set to control the behavior of this find module. +# +# ``MySQL_ROOT`` +# The root directory of the mysql client library's installation. +# ``MySQL_INCLUDE_DIR`` +# The directory containing the include files of the mysql client library. +# If not set, the directory is detected within ``MySQL_ROOT`` using find_path. +# ``MySQL_LIBRARY_DIR`` +# The directory containing the binaries of the mysql client library. +# This is used to detect ``MySQL_LIBRARY`` and passed as HINT to find_library. +# ``MySQL_LIBRARY`` +# The file path to the mysql client library. +# ``MySQL_LIBRARY_DEBUG`` +# The file path to the mysql client library for the DEBUG configuration. +# +# If the mysql client library is found, this will define the following variables: +# +# ``MySQL_FOUND`` +# True if the mysql library is available +# ``MySQL_INCLUDE_DIRS`` +# The mysql include directories +# ``MySQL_LIBRARIES`` +# The mysql libraries for linking +# +# If ``MySQL_FOUND`` is TRUE, it will also define the following +# imported target: +# +# ``MySQL::MySQL`` +# The mysql client library + +if(NOT DEFINED MySQL_ROOT) + if(DEFINED ENV{MySQL_ROOT}) + set(MySQL_ROOT "$ENV{MySQL_ROOT}") + else() + find_package(PkgConfig QUIET) + endif() +endif() +if(PkgConfig_FOUND AND NOT DEFINED MySQL_ROOT) + pkg_check_modules(PC_MySQL QUIET "mysqlclient") + set(MySQL_include_dir_hints ${PC_MySQL_INCLUDEDIR}) + set(MySQL_library_hints ${PC_MySQL_LIBDIR}) + set(MySQL_library_hints_debug "") +else() + set(MySQL_include_dir_hints "${MySQL_ROOT}" "${MySQL_ROOT}/include") + if(NOT DEFINED MySQL_LIBRARY_DIR) + set(MySQL_LIBRARY_DIR "${MySQL_ROOT}/lib") + endif() + set(MySQL_library_hints "${MySQL_LIBRARY_DIR}") + set(MySQL_library_hints_debug "${MySQL_LIBRARY_DIR}/debug") +endif() + +find_path(MySQL_INCLUDE_DIR + NAMES mysql.h + HINTS "${MySQL_include_dir_hints}" + PATH_SUFFIXES mysql mariadb) + +find_library(MySQL_LIBRARY + NO_PACKAGE_ROOT_PATH + NAMES libmysql mysql mysqlclient libmariadb mariadb + HINTS ${MySQL_library_hints}) + +if(MySQL_library_hints_debug) + find_library(MySQL_LIBRARY_DEBUG + NO_PACKAGE_ROOT_PATH + NAMES libmysql mysql mysqlclient libmariadb mariadb + HINTS ${MySQL_library_hints_debug}) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(MySQL DEFAULT_MSG MySQL_LIBRARY MySQL_INCLUDE_DIR) + +if(MySQL_FOUND) + set(MySQL_INCLUDE_DIRS "${MySQL_INCLUDE_DIR}") + set(MySQL_LIBRARIES "${MySQL_LIBRARY}") + if(NOT TARGET MySQL::MySQL) + add_library(MySQL::MySQL UNKNOWN IMPORTED) + set_target_properties(MySQL::MySQL PROPERTIES + IMPORTED_LOCATION "${MySQL_LIBRARIES}" + INTERFACE_INCLUDE_DIRECTORIES "${MySQL_INCLUDE_DIRS}") + if(MySQL_LIBRARY_DEBUG) + set_target_properties(MySQL::MySQL PROPERTIES + IMPORTED_LOCATION_DEBUG "${MySQL_LIBRARY_DEBUG}") + endif() + endif() +endif() + +mark_as_advanced(MySQL_INCLUDE_DIR MySQL_LIBRARY) + +include(FeatureSummary) +set_package_properties(MySQL PROPERTIES + URL "https://www.mysql.com" + DESCRIPTION "MySQL client library") + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindOracle.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindOracle.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8df8a9b9f2934505859149e1e8845fac943e82b0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindOracle.cmake @@ -0,0 +1,62 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +#.rst: +# FindOracle +# --------- +# +# Try to locate the oracle client library. +# If found, this will define the following variables: +# +# ``Oracle_FOUND`` +# True if the oracle library is available +# ``Oracle_INCLUDE_DIRS`` +# The oracle include directories +# ``Oracle_LIBRARIES`` +# The oracle libraries for linking +# +# If ``Oracle_FOUND`` is TRUE, it will also define the following +# imported target: +# +# ``Oracle::Oracle`` +# The oracle instant client library + +if(NOT DEFINED Oracle_ROOT) + if(DEFINED ENV{Oracle_ROOT}) + set(Oracle_ROOT "$ENV{Oracle_ROOT}") + endif() +endif() + +find_path(Oracle_INCLUDE_DIR + NAMES oci.h + HINTS ${Oracle_INCLUDE_DIR} "${Oracle_ROOT}" "${Oracle_ROOT}/include" "${Oracle_ROOT}/sdk/include" +) + +set(ORACLE_OCI_NAMES clntsh ociei oraociei12 oci) + +find_library(Oracle_LIBRARY + NAMES ${ORACLE_OCI_NAMES} + HINTS ${Oracle_LIBRARY_DIR} "${Oracle_ROOT}" "${Oracle_ROOT}/lib" "${Oracle_ROOT}/sdk/lib" + PATH_SUFFIXES msvc +) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Oracle DEFAULT_MSG Oracle_LIBRARY Oracle_INCLUDE_DIR) + +if(Oracle_FOUND) + set(Oracle_INCLUDE_DIRS "${Oracle_INCLUDE_DIR}") + set(Oracle_LIBRARIES "${Oracle_LIBRARY}") + if(NOT TARGET Oracle::OCI) + add_library(Oracle::OCI UNKNOWN IMPORTED) + set_target_properties(Oracle::OCI PROPERTIES + IMPORTED_LOCATION "${Oracle_LIBRARIES}" + INTERFACE_INCLUDE_DIRECTORIES "${Oracle_INCLUDE_DIRS}") + endif() +endif() + +mark_as_advanced(Oracle_INCLUDE_DIR Oracle_LIBRARY) + +include(FeatureSummary) +set_package_properties(Oracle PROPERTIES + URL "https://www.oracle.com" + DESCRIPTION "Oracle client library") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindPPS.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindPPS.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c01cfe1d39cf5d8bce4dc38581b02b211d05c802 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindPPS.cmake @@ -0,0 +1,24 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Find the PPS library + +# Will make the target PPS::PPS available when found. +if(TARGET PPS::PPS) + set(PPS_FOUND TRUE) + return() +endif() + +find_library(PPS_LIBRARY NAMES "pps") +find_path(PPS_INCLUDE_DIR NAMES "sys/pps.h" DOC "The PPS Include path") + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(PPS DEFAULT_MSG PPS_INCLUDE_DIR PPS_LIBRARY) + +mark_as_advanced(PPS_INCLUDE_DIR PPS_LIBRARY) + +if(PPS_FOUND) + add_library(PPS::PPS INTERFACE IMPORTED) + target_link_libraries(PPS::PPS INTERFACE "${PPS_LIBRARY}") + target_include_directories(PPS::PPS INTERFACE "${PPS_INCLUDE_DIR}") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindPostgreSQL.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindPostgreSQL.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2f607875579870fefd7e771337478c7a4552e1fb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindPostgreSQL.cmake @@ -0,0 +1,321 @@ +# Copyright (C) 2000-2022 Kitware, Inc. and Contributors. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +#[=======================================================================[.rst: +FindPostgreSQL +-------------- + +Find the PostgreSQL installation. + +IMPORTED Targets +^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.14 + +This module defines :prop_tgt:`IMPORTED` target ``PostgreSQL::PostgreSQL`` +if PostgreSQL has been found. + +Result Variables +^^^^^^^^^^^^^^^^ + +This module will set the following variables in your project: + +``PostgreSQL_FOUND`` + True if PostgreSQL is found. +``PostgreSQL_LIBRARIES`` + the PostgreSQL libraries needed for linking +``PostgreSQL_INCLUDE_DIRS`` + the directories of the PostgreSQL headers +``PostgreSQL_LIBRARY_DIRS`` + the link directories for PostgreSQL libraries +``PostgreSQL_VERSION_STRING`` + the version of PostgreSQL found +``PostgreSQL_TYPE_INCLUDE_DIR`` + the directories of the PostgreSQL server headers + +Components +^^^^^^^^^^ + +This module contains additional ``Server`` component, that forcibly checks +for the presence of server headers. Note that ``PostgreSQL_TYPE_INCLUDE_DIR`` +is set regardless of the presence of the ``Server`` component in find_package call. + +#]=======================================================================] + +# ---------------------------------------------------------------------------- +# History: +# This module is derived from the module originally found in the VTK source tree. +# +# ---------------------------------------------------------------------------- +# Note: +# PostgreSQL_ADDITIONAL_VERSIONS is a variable that can be used to set the +# version number of the implementation of PostgreSQL. +# In Windows the default installation of PostgreSQL uses that as part of the path. +# E.g C:\Program Files\PostgreSQL\8.4. +# Currently, the following version numbers are known to this module: +# "11" "10" "9.6" "9.5" "9.4" "9.3" "9.2" "9.1" "9.0" "8.4" "8.3" "8.2" "8.1" "8.0" +# +# To use this variable just do something like this: +# set(PostgreSQL_ADDITIONAL_VERSIONS "9.2" "8.4.4") +# before calling find_package(PostgreSQL) in your CMakeLists.txt file. +# This will mean that the versions you set here will be found first in the order +# specified before the default ones are searched. +# +# ---------------------------------------------------------------------------- +# You may need to manually set: +# PostgreSQL_INCLUDE_DIR - the path to where the PostgreSQL include files are. +# PostgreSQL_LIBRARY_DIR - The path to where the PostgreSQL library files are. +# If FindPostgreSQL.cmake cannot find the include files or the library files. +# +# ---------------------------------------------------------------------------- +# The following variables are set if PostgreSQL is found: +# PostgreSQL_FOUND - Set to true when PostgreSQL is found. +# PostgreSQL_INCLUDE_DIRS - Include directories for PostgreSQL +# PostgreSQL_LIBRARY_DIRS - Link directories for PostgreSQL libraries +# PostgreSQL_LIBRARIES - The PostgreSQL libraries. +# +# The ``PostgreSQL::PostgreSQL`` imported target is also created. +# +# ---------------------------------------------------------------------------- +# If you have installed PostgreSQL in a non-standard location. +# (Please note that in the following comments, it is assumed that +# points to the root directory of the include directory of PostgreSQL.) +# Then you have three options. +# 1) After CMake runs, set PostgreSQL_INCLUDE_DIR to /include and +# PostgreSQL_LIBRARY_DIR to wherever the library pq (or libpq in windows) is +# 2) Use CMAKE_INCLUDE_PATH to set a path to /PostgreSQL<-version>. This will allow find_path() +# to locate PostgreSQL_INCLUDE_DIR by utilizing the PATH_SUFFIXES option. e.g. In your CMakeLists.txt file +# set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "/include") +# 3) Set an environment variable called ${PostgreSQL_ROOT} that points to the root of where you have +# installed PostgreSQL, e.g. . +# +# ---------------------------------------------------------------------------- + +if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") + include("${CMAKE_ROOT}/Modules/FindPostgreSQL.cmake") + return() +endif() + +cmake_policy(PUSH) +cmake_policy(SET CMP0057 NEW) # if IN_LIST +if(POLICY CMP0159) + cmake_policy(SET CMP0159 NEW) +endif() + +set(PostgreSQL_INCLUDE_PATH_DESCRIPTION "top-level directory containing the PostgreSQL include directories. E.g /usr/local/include/PostgreSQL/8.4 or C:/Program Files/PostgreSQL/8.4/include") +set(PostgreSQL_INCLUDE_DIR_MESSAGE "Set the PostgreSQL_INCLUDE_DIR cmake cache entry to the ${PostgreSQL_INCLUDE_PATH_DESCRIPTION}") +set(PostgreSQL_LIBRARY_PATH_DESCRIPTION "top-level directory containing the PostgreSQL libraries.") +set(PostgreSQL_LIBRARY_DIR_MESSAGE "Set the PostgreSQL_LIBRARY_DIR cmake cache entry to the ${PostgreSQL_LIBRARY_PATH_DESCRIPTION}") +set(PostgreSQL_ROOT_DIR_MESSAGE "Set the PostgreSQL_ROOT system variable to where PostgreSQL is found on the machine E.g C:/Program Files/PostgreSQL/8.4") + + +set(PostgreSQL_KNOWN_VERSIONS ${PostgreSQL_ADDITIONAL_VERSIONS} + "13" "12" "11" "10" "9.6" "9.5" "9.4" "9.3" "9.2" "9.1" "9.0" "8.4" "8.3" "8.2" "8.1" "8.0") + +# Define additional search paths for root directories. +set( PostgreSQL_ROOT_DIRECTORIES + ENV PostgreSQL_ROOT + ${PostgreSQL_ROOT} +) +foreach(suffix ${PostgreSQL_KNOWN_VERSIONS}) + if(WIN32) + list(APPEND PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES + "PostgreSQL/${suffix}/lib") + list(APPEND PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES + "PostgreSQL/${suffix}/include") + list(APPEND PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES + "PostgreSQL/${suffix}/include/server") + endif() + if(UNIX) + list(APPEND PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES + "postgresql${suffix}" + "pgsql-${suffix}/lib") + list(APPEND PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES + "postgresql${suffix}" + "postgresql/${suffix}" + "pgsql-${suffix}/include") + list(APPEND PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES + "postgresql${suffix}/server" + "postgresql/${suffix}/server" + "pgsql-${suffix}/include/server") + endif() +endforeach() + +# +# Look for an installation. +# +find_path(PostgreSQL_INCLUDE_DIR + NAMES libpq-fe.h + PATHS + # Look in other places. + ${PostgreSQL_ROOT_DIRECTORIES} + PATH_SUFFIXES + pgsql + postgresql + include + ${PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES} + # Help the user find it if we cannot. + DOC "The ${PostgreSQL_INCLUDE_DIR_MESSAGE}" +) + +find_path(PostgreSQL_TYPE_INCLUDE_DIR + NAMES catalog/pg_type.h + PATHS + # Look in other places. + ${PostgreSQL_ROOT_DIRECTORIES} + PATH_SUFFIXES + postgresql + pgsql/server + postgresql/server + include/server + ${PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES} + # Help the user find it if we cannot. + DOC "The ${PostgreSQL_INCLUDE_DIR_MESSAGE}" +) + +# The PostgreSQL library. +set (PostgreSQL_LIBRARY_TO_FIND pq) +# Setting some more prefixes for the library +set (PostgreSQL_LIB_PREFIX "") +if ( WIN32 ) + set (PostgreSQL_LIB_PREFIX ${PostgreSQL_LIB_PREFIX} "lib") + set (PostgreSQL_LIBRARY_TO_FIND ${PostgreSQL_LIB_PREFIX}${PostgreSQL_LIBRARY_TO_FIND}) +endif() + +function(__postgresql_find_library _name) + find_library(${_name} + NAMES ${ARGN} + PATHS + ${PostgreSQL_ROOT_DIRECTORIES} + PATH_SUFFIXES + lib + ${PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES} + # Help the user find it if we cannot. + DOC "The ${PostgreSQL_LIBRARY_DIR_MESSAGE}" + ) +endfunction() + +# For compatibility with versions prior to this multi-config search, honor +# any PostgreSQL_LIBRARY that is already specified and skip the search. +if(PostgreSQL_LIBRARY) + set(PostgreSQL_LIBRARIES "${PostgreSQL_LIBRARY}") + get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY}" PATH) +else() + __postgresql_find_library(PostgreSQL_LIBRARY_RELEASE ${PostgreSQL_LIBRARY_TO_FIND}) + __postgresql_find_library(PostgreSQL_LIBRARY_DEBUG ${PostgreSQL_LIBRARY_TO_FIND}d) + include(SelectLibraryConfigurations) + select_library_configurations(PostgreSQL) + mark_as_advanced(PostgreSQL_LIBRARY_RELEASE PostgreSQL_LIBRARY_DEBUG) + if(PostgreSQL_LIBRARY_RELEASE) + get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY_RELEASE}" PATH) + elseif(PostgreSQL_LIBRARY_DEBUG) + get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY_DEBUG}" PATH) + else() + set(PostgreSQL_LIBRARY_DIR "") + endif() +endif() + +if (PostgreSQL_INCLUDE_DIR) + # Some platforms include multiple pg_config.hs for multi-lib configurations + # This is a temporary workaround. A better solution would be to compile + # a dummy c file and extract the value of the symbol. + file(GLOB _PG_CONFIG_HEADERS "${PostgreSQL_INCLUDE_DIR}/pg_config*.h") + foreach(_PG_CONFIG_HEADER ${_PG_CONFIG_HEADERS}) + if(EXISTS "${_PG_CONFIG_HEADER}") + file(STRINGS "${_PG_CONFIG_HEADER}" pgsql_version_str + REGEX "^#define[\t ]+PG_VERSION_NUM[\t ]+.*") + if(pgsql_version_str) + string(REGEX REPLACE "^#define[\t ]+PG_VERSION_NUM[\t ]+([0-9]*).*" + "\\1" _PostgreSQL_VERSION_NUM "${pgsql_version_str}") + break() + endif() + endif() + endforeach() + if (_PostgreSQL_VERSION_NUM) + # 9.x and older encoding + if (_PostgreSQL_VERSION_NUM LESS 100000) + math(EXPR _PostgreSQL_major_version "${_PostgreSQL_VERSION_NUM} / 10000") + math(EXPR _PostgreSQL_minor_version "${_PostgreSQL_VERSION_NUM} % 10000 / 100") + math(EXPR _PostgreSQL_patch_version "${_PostgreSQL_VERSION_NUM} % 100") + set(PostgreSQL_VERSION_STRING "${_PostgreSQL_major_version}.${_PostgreSQL_minor_version}.${_PostgreSQL_patch_version}") + unset(_PostgreSQL_major_version) + unset(_PostgreSQL_minor_version) + unset(_PostgreSQL_patch_version) + else () + math(EXPR _PostgreSQL_major_version "${_PostgreSQL_VERSION_NUM} / 10000") + math(EXPR _PostgreSQL_minor_version "${_PostgreSQL_VERSION_NUM} % 10000") + set(PostgreSQL_VERSION_STRING "${_PostgreSQL_major_version}.${_PostgreSQL_minor_version}") + unset(_PostgreSQL_major_version) + unset(_PostgreSQL_minor_version) + endif () + else () + foreach(_PG_CONFIG_HEADER ${_PG_CONFIG_HEADERS}) + if(EXISTS "${_PG_CONFIG_HEADER}") + file(STRINGS "${_PG_CONFIG_HEADER}" pgsql_version_str + REGEX "^#define[\t ]+PG_VERSION[\t ]+\".*\"") + if(pgsql_version_str) + string(REGEX REPLACE "^#define[\t ]+PG_VERSION[\t ]+\"([^\"]*)\".*" + "\\1" PostgreSQL_VERSION_STRING "${pgsql_version_str}") + break() + endif() + endif() + endforeach() + endif () + unset(_PostgreSQL_VERSION_NUM) + unset(pgsql_version_str) +endif() + +if("Server" IN_LIST PostgreSQL_FIND_COMPONENTS) + set(PostgreSQL_Server_FOUND TRUE) + if(NOT PostgreSQL_TYPE_INCLUDE_DIR) + set(PostgreSQL_Server_FOUND FALSE) + endif() +endif() + +# Did we find anything? +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(PostgreSQL + REQUIRED_VARS PostgreSQL_LIBRARY PostgreSQL_INCLUDE_DIR + HANDLE_COMPONENTS + VERSION_VAR PostgreSQL_VERSION_STRING) +set(PostgreSQL_FOUND ${POSTGRESQL_FOUND}) + +function(__postgresql_import_library _target _var _config) + if(_config) + set(_config_suffix "_${_config}") + else() + set(_config_suffix "") + endif() + + set(_lib "${${_var}${_config_suffix}}") + if(EXISTS "${_lib}") + if(_config) + set_property(TARGET ${_target} APPEND PROPERTY + IMPORTED_CONFIGURATIONS ${_config}) + endif() + set_target_properties(${_target} PROPERTIES + IMPORTED_LOCATION${_config_suffix} "${_lib}") + endif() +endfunction() + +# Now try to get the include and library path. +if(PostgreSQL_FOUND) + set(PostgreSQL_INCLUDE_DIRS ${PostgreSQL_INCLUDE_DIR}) + if(PostgreSQL_TYPE_INCLUDE_DIR) + list(APPEND PostgreSQL_INCLUDE_DIRS ${PostgreSQL_TYPE_INCLUDE_DIR}) + endif() + set(PostgreSQL_LIBRARY_DIRS ${PostgreSQL_LIBRARY_DIR}) + if (NOT TARGET PostgreSQL::PostgreSQL) + add_library(PostgreSQL::PostgreSQL UNKNOWN IMPORTED) + set_target_properties(PostgreSQL::PostgreSQL PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${PostgreSQL_INCLUDE_DIRS}") + __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "") + __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "RELEASE") + __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "DEBUG") + endif () +endif() + +mark_as_advanced(PostgreSQL_INCLUDE_DIR PostgreSQL_TYPE_INCLUDE_DIR) + +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindRenderDoc.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindRenderDoc.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5fb1e3d179cdb76117a9e4d8eb18fa44576a190d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindRenderDoc.cmake @@ -0,0 +1,20 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(WIN32 OR UNIX) + find_path(RenderDoc_INCLUDE_DIR + NAMES renderdoc_app.h) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(RenderDoc + DEFAULT_MSG + RenderDoc_INCLUDE_DIR) + +mark_as_advanced(RenderDoc_INCLUDE_DIR) + +if(RenderDoc_FOUND AND NOT TARGET RenderDoc::RenderDoc) + add_library(RenderDoc::RenderDoc INTERFACE IMPORTED) + set_target_properties(RenderDoc::RenderDoc PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${RenderDoc_INCLUDE_DIR}") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindSlog2.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindSlog2.cmake new file mode 100644 index 0000000000000000000000000000000000000000..05723e9f7d3f6f49589a6dd4637bfeb533b33b26 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindSlog2.cmake @@ -0,0 +1,24 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Find the Slog2 library + +# Will make the target Slog2::Slog2 available when found. +if(TARGET Slog2::Slog2) + set(Slog2_FOUND TRUE) + return() +endif() + +find_library(Slog2_LIBRARY NAMES "slog2") +find_path(Slog2_INCLUDE_DIR NAMES "sys/slog2.h" DOC "The Slog2 Include path") + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Slog2 DEFAULT_MSG Slog2_INCLUDE_DIR Slog2_LIBRARY) + +mark_as_advanced(Slog2_INCLUDE_DIR Slog2_LIBRARY) + +if(Slog2_FOUND) + add_library(Slog2::Slog2 INTERFACE IMPORTED) + target_link_libraries(Slog2::Slog2 INTERFACE ${Slog2_LIBRARY}) + target_include_directories(Slog2::Slog2 INTERFACE ${Slog2_INCLUDE_DIR}) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindTslib.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindTslib.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dbc57db34af5ae778ce8424562ca5c67307b533f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindTslib.cmake @@ -0,0 +1,10 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +pkg_check_modules(Tslib IMPORTED_TARGET "tslib") + +if (NOT TARGET PkgConfig::Tslib) + set(Tslib_FOUND 0) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapAtomic.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapAtomic.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8fccc954ceb00e0635e6988223151d9239ce270f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapAtomic.cmake @@ -0,0 +1,54 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapAtomic::WrapAtomic) + set(WrapAtomic_FOUND ON) + return() +endif() + +include(CheckCXXSourceCompiles) + +set (atomic_test_sources "#include +#include + +int main(int, char **) +{ + volatile std::atomic size_1; + volatile std::atomic size_2; + volatile std::atomic size_4; + volatile std::atomic size_8; + + ++size_1; + ++size_2; + ++size_4; + ++size_8; + + (void)size_1.load(std::memory_order_relaxed); + (void)size_2.load(std::memory_order_relaxed); + (void)size_4.load(std::memory_order_relaxed); + (void)size_8.load(std::memory_order_relaxed); + + return 0; +}") + +check_cxx_source_compiles("${atomic_test_sources}" HAVE_STDATOMIC) +if(NOT HAVE_STDATOMIC) + set(_req_libraries "${CMAKE_REQUIRED_LIBRARIES}") + set(atomic_LIB "-latomic") + set(CMAKE_REQUIRED_LIBRARIES ${atomic_LIB}) + check_cxx_source_compiles("${atomic_test_sources}" HAVE_STDATOMIC_WITH_LIB) + set(CMAKE_REQUIRED_LIBRARIES "${_req_libraries}") +endif() + +add_library(WrapAtomic::WrapAtomic INTERFACE IMPORTED) +if(HAVE_STDATOMIC_WITH_LIB) + # atomic_LIB is already found above. + target_link_libraries(WrapAtomic::WrapAtomic INTERFACE ${atomic_LIB}) +endif() + +set(WrapAtomic_FOUND 1) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapAtomic DEFAULT_MSG WrapAtomic_FOUND) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBacktrace.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBacktrace.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c481a05bc9ad777f3167a42f49002d505c3ddf62 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBacktrace.cmake @@ -0,0 +1,20 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(TARGET WrapBacktrace::WrapBacktrace) + set(WrapBacktrace_FOUND ON) + return() +endif() + +find_package(Backtrace) + +if(Backtrace_FOUND) + add_library(WrapBacktrace::WrapBacktrace INTERFACE IMPORTED) + target_link_libraries(WrapBacktrace::WrapBacktrace + INTERFACE ${Backtrace_LIBRARY}) + target_include_directories(WrapBacktrace::WrapBacktrace + INTERFACE ${Backtrace_INCLUDE_DIR}) + set(WrapBacktrace_FOUND ON) +else() + set(WrapBacktrace_FOUND OFF) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBrotli.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBrotli.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0b417ad1736a761e12bb31318c8d0f33169cb058 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBrotli.cmake @@ -0,0 +1,107 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(TARGET WrapBrotli::WrapBrotliDec) + set(WrapBrotli_FOUND ON) + return() +endif() + +# From VCPKG +find_package(unofficial-brotli CONFIG QUIET) +if (unofficial-brotli_FOUND) + add_library(WrapBrotli::WrapBrotliDec INTERFACE IMPORTED) + target_link_libraries(WrapBrotli::WrapBrotliDec INTERFACE unofficial::brotli::brotlidec) + + add_library(WrapBrotli::WrapBrotliEnc INTERFACE IMPORTED) + target_link_libraries(WrapBrotli::WrapBrotliEnc INTERFACE unofficial::brotli::brotlienc) + + add_library(WrapBrotli::WrapBrotliCommon INTERFACE IMPORTED) + target_link_libraries(WrapBrotli::WrapBrotliCommon INTERFACE unofficial::brotli::brotlicommon) + + set(WrapBrotli_FOUND ON) +else() + get_cmake_property(__packages_not_found PACKAGES_NOT_FOUND) + if(__packages_not_found) + list(REMOVE_ITEM __packages_not_found unofficial-brotli) + set_property(GLOBAL PROPERTY PACKAGES_NOT_FOUND "${__packages_not_found}") + endif() + unset(__packages_not_found) + + find_package(PkgConfig QUIET) + if (PKG_CONFIG_FOUND) + pkg_check_modules(libbrotlidec QUIET IMPORTED_TARGET "libbrotlidec") + if (libbrotlidec_FOUND) + add_library(WrapBrotli::WrapBrotliDec INTERFACE IMPORTED) + target_link_libraries(WrapBrotli::WrapBrotliDec INTERFACE PkgConfig::libbrotlidec) + set(WrapBrotli_FOUND ON) + endif() + + pkg_check_modules(libbrotlienc QUIET IMPORTED_TARGET "libbrotlienc") + if (libbrotlienc_FOUND) + add_library(WrapBrotli::WrapBrotliEnc INTERFACE IMPORTED) + target_link_libraries(WrapBrotli::WrapBrotliEnc INTERFACE PkgConfig::libbrotlienc) + set(WrapBrotli_FOUND ON) + endif() + + pkg_check_modules(libbrotlicommon QUIET IMPORTED_TARGET "libbrotlicommon") + if (libbrotlicommon_FOUND) + add_library(WrapBrotli::WrapBrotliCommon INTERFACE IMPORTED) + target_link_libraries(WrapBrotli::WrapBrotliCommon INTERFACE PkgConfig::libbrotlicommon) + set(WrapBrotli_FOUND ON) + endif() + else() + find_path(BROTLI_INCLUDE_DIR NAMES "brotli/decode.h") + + foreach(lib_name BrotliDec BrotliEnc BrotliCommon) + string(TOLOWER ${lib_name} lower_lib_name) + + find_library(${lib_name}_LIBRARY_RELEASE + NAMES ${lower_lib_name} ${lower_lib_name}-static) + + find_library(${lib_name}_LIBRARY_DEBUG + NAMES ${lower_lib_name}d ${lower_lib_name}-staticd + ${lower_lib_name} ${lower_lib_name}-static) + + include(SelectLibraryConfigurations) + select_library_configurations(${lib_name}) + + if (BROTLI_INCLUDE_DIR AND ${lib_name}_LIBRARY) + set(${lib_name}_FOUND TRUE) + endif() + + if (${lib_name}_FOUND AND NOT TARGET WrapBrotli::Wrap${lib_name}) + add_library(WrapBrotli::Wrap${lib_name} UNKNOWN IMPORTED) + set_target_properties(WrapBrotli::Wrap${lib_name} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${BROTLI_INCLUDE_DIR}" + IMPORTED_LOCATION "${${lib_name}_LIBRARY}") + + if(${lib_name}_LIBRARY_RELEASE) + foreach(config_name RELEASE RELWITHDEBINFO MINSIZEREL) + set_property(TARGET WrapBrotli::Wrap${lib_name} APPEND PROPERTY + IMPORTED_CONFIGURATIONS ${config_name}) + set_target_properties(WrapBrotli::Wrap${lib_name} PROPERTIES + IMPORTED_LOCATION_${config_name} "${${lib_name}_LIBRARY_RELEASE}") + endforeach() + endif() + + if(${lib_name}_LIBRARY_DEBUG) + set_property(TARGET WrapBrotli::Wrap${lib_name} APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(WrapBrotli::Wrap${lib_name} PROPERTIES + IMPORTED_LOCATION_DEBUG "${${lib_name}_LIBRARY_DEBUG}") + endif() + endif() + endforeach() + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(WrapBrotli REQUIRED_VARS + BrotliDec_FOUND BrotliEnc_FOUND BrotliCommon_FOUND) + + if (WrapBrotli_FOUND) + set_property(TARGET WrapBrotli::WrapBrotliDec APPEND PROPERTY + INTERFACE_LINK_LIBRARIES WrapBrotli::WrapBrotliCommon) + set_property(TARGET WrapBrotli::WrapBrotliEnc APPEND PROPERTY + INTERFACE_LINK_LIBRARIES WrapBrotli::WrapBrotliCommon) + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledFreetypeConfigExtra.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledFreetypeConfigExtra.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6204500ea35e17d98823f864bddfd143ad89d096 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledFreetypeConfigExtra.cmake @@ -0,0 +1,4 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(QT_USE_BUNDLED_BundledFreetype ON CACHE INTERNAL "") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledHarfbuzzConfigExtra.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledHarfbuzzConfigExtra.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5c0df76de090d593a4786185537b275529cec061 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledHarfbuzzConfigExtra.cmake @@ -0,0 +1,4 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(QT_USE_BUNDLED_BundledHarfbuzz ON CACHE INTERNAL "") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledLibjpegConfigExtra.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledLibjpegConfigExtra.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2d33cc1ec9937b5adf4230430b36a00aec443d6c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledLibjpegConfigExtra.cmake @@ -0,0 +1,4 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(QT_USE_BUNDLED_BundledLibjpeg ON CACHE INTERNAL "") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledLibpngConfigExtra.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledLibpngConfigExtra.cmake new file mode 100644 index 0000000000000000000000000000000000000000..84f9abedb0c2c92d58ebb02ece75101ad4cf940f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledLibpngConfigExtra.cmake @@ -0,0 +1,4 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(QT_USE_BUNDLED_BundledLibpng ON CACHE INTERNAL "") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledPcre2ConfigExtra.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledPcre2ConfigExtra.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1635075c3a3a15183ed48fe26a3f8bb9e632446c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledPcre2ConfigExtra.cmake @@ -0,0 +1,4 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(QT_USE_BUNDLED_BundledPcre2 ON CACHE INTERNAL "") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledZLIBConfigExtra.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledZLIBConfigExtra.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d91bc39f723018aa4125a25afbc3562c5f4b7a93 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapBundledZLIBConfigExtra.cmake @@ -0,0 +1,4 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(QT_USE_BUNDLED_BundledZLIB ON CACHE INTERNAL "") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapDBus1.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapDBus1.cmake new file mode 100644 index 0000000000000000000000000000000000000000..74a4e5f53782a68e757f413a42f96d37f8812732 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapDBus1.cmake @@ -0,0 +1,50 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# DBus1 is buggy and breaks PKG_CONFIG environment. +# Work around that:-/ +# See https://gitlab.freedesktop.org/dbus/dbus/issues/267 for more information + +# When doing top-level static Qt builds, we need to protect against double creation of the dbus +# target. +if(DBus1_FOUND OR WrapDBus1_FOUND OR TARGET dbus-1) + set(WrapDBus1_FOUND 1) + return() +endif() + +if(DEFINED ENV{PKG_CONFIG_DIR}) + set(__qt_dbus_pcd "$ENV{PKG_CONFIG_DIR}") +endif() +if(DEFINED ENV{PKG_CONFIG_PATH}) + set(__qt_dbus_pcp "$ENV{PKG_CONFIG_PATH}") +endif() +if(DEFINED ENV{PKG_CONFIG_LIBDIR}) + set(__qt_dbus_pcl "$ENV{PKG_CONFIG_LIBDIR}") +endif() + +find_package(DBus1 ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET) + +if(DEFINED __qt_dbus_pcd) + set(ENV{PKG_CONFIG_DIR} "${__qt_dbus_pcd}") +else() + unset(ENV{PKG_CONFIG_DIR}) +endif() +if(DEFINED __qt_dbus_pcp) + set(ENV{PKG_CONFIG_PATH} "${__qt_dbus_pcp}") +else() + unset(ENV{PKG_CONFIG_PATH}) +endif() +if(DEFINED __qt_dbus_pcl) + set(ENV{PKG_CONFIG_LIBDIR} "${__qt_dbus_pcl}") +else() + unset(ENV{PKG_CONFIG_LIBDIR}) +endif() + +if(DBus1_FOUND) + set(WrapDBus1_FOUND 1) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapDBus1 REQUIRED_VARS + DBus1_LIBRARY DBus1_INCLUDE_DIR WrapDBus1_FOUND + VERSION_VAR DBus1_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapFreetype.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapFreetype.cmake new file mode 100644 index 0000000000000000000000000000000000000000..649dea9f6cbf6a0e435cbe414ee122fd11ae92dc --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapFreetype.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(QtFindWrapHelper NO_POLICY_SCOPE) + +qt_find_package_system_or_bundled(wrap_freetype + FRIENDLY_PACKAGE_NAME "Freetype" + WRAP_PACKAGE_TARGET "WrapFreetype::WrapFreetype" + WRAP_PACKAGE_FOUND_VAR_NAME "WrapFreetype_FOUND" + BUNDLED_PACKAGE_NAME "BundledFreetype" + BUNDLED_PACKAGE_TARGET "BundledFreetype" + SYSTEM_PACKAGE_NAME "WrapSystemFreetype" + SYSTEM_PACKAGE_TARGET "WrapSystemFreetype::WrapSystemFreetype" +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapHarfbuzz.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapHarfbuzz.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a4557018ca1ee36e2e5ac0dd6734c959b05fb4ce --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapHarfbuzz.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(QtFindWrapHelper NO_POLICY_SCOPE) + +qt_find_package_system_or_bundled(wrap_harfbuzz + FRIENDLY_PACKAGE_NAME "Harfbuzz" + WRAP_PACKAGE_TARGET "WrapHarfbuzz::WrapHarfbuzz" + WRAP_PACKAGE_FOUND_VAR_NAME "WrapHarfbuzz_FOUND" + BUNDLED_PACKAGE_NAME "BundledHarfbuzz" + BUNDLED_PACKAGE_TARGET "BundledHarfbuzz" + SYSTEM_PACKAGE_NAME "WrapSystemHarfbuzz" + SYSTEM_PACKAGE_TARGET "WrapSystemHarfbuzz::WrapSystemHarfbuzz" +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapJasper.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapJasper.cmake new file mode 100644 index 0000000000000000000000000000000000000000..193c83c97c57af6a3a049edc8562681f1c86d925 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapJasper.cmake @@ -0,0 +1,21 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapJasper::WrapJasper) + set(WrapJasper_FOUND TRUE) + return() +endif() + +set(WrapJasper_FOUND OFF) +find_package(Jasper) + +if(Jasper_FOUND) + set(WrapJasper_FOUND ON) + + # Upstream package does not provide targets, only variables. So define a target. + add_library(WrapJasper::WrapJasper INTERFACE IMPORTED) + target_link_libraries(WrapJasper::WrapJasper INTERFACE ${JASPER_LIBRARIES}) + target_include_directories(WrapJasper::WrapJasper INTERFACE ${JASPER_INCLUDE_DIR}) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapJpeg.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapJpeg.cmake new file mode 100644 index 0000000000000000000000000000000000000000..895ac79613ba0c8c54d6c0b35957cb7e15f97e25 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapJpeg.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(QtFindWrapHelper NO_POLICY_SCOPE) + +qt_find_package_system_or_bundled(wrap_jpeg + FRIENDLY_PACKAGE_NAME "Jpeg" + WRAP_PACKAGE_TARGET "WrapJpeg::WrapJpeg" + WRAP_PACKAGE_FOUND_VAR_NAME "WrapJpeg_FOUND" + BUNDLED_PACKAGE_NAME "BundledLibjpeg" + BUNDLED_PACKAGE_TARGET "BundledLibjpeg" + SYSTEM_PACKAGE_NAME "WrapSystemJpeg" + SYSTEM_PACKAGE_TARGET "WrapSystemJpeg::WrapSystemJpeg" +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapLibClang.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapLibClang.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6d129283489e51ef7a2742bbac236a462e778264 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapLibClang.cmake @@ -0,0 +1,95 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(TARGET WrapLibClang::WrapLibClang) + set(WrapLibClang_FOUND TRUE) + return() +endif() + +if(DEFINED ENV{LLVM_INSTALL_DIR}) + set(__qt_wrap_clang_backup_prefix "${CMAKE_PREFIX_PATH}") + list(PREPEND CMAKE_PREFIX_PATH "$ENV{LLVM_INSTALL_DIR}") +elseif(DEFINED CACHE{LLVM_INSTALL_DIR}) + set(__qt_wrap_clang_backup_prefix "${CMAKE_PREFIX_PATH}") + list(PREPEND CMAKE_PREFIX_PATH "${LLVM_INSTALL_DIR}") +endif() + +find_package(Clang CONFIG) +# LLVM versions >= 16 come with Findzstd.cmake that creates a target for libzstd. +# Disable its global promotion to prevent interference with FindWrapZSTD.cmake. +if(TARGET zstd::libzstd) + qt_internal_disable_find_package_global_promotion(zstd::libzstd) +endif() +if(TARGET zstd::libzstd_shared) + qt_internal_disable_find_package_global_promotion(zstd::libzstd_shared) +endif() +if(TARGET zstd::libzstd_static) + qt_internal_disable_find_package_global_promotion(zstd::libzstd_static) +endif() + +if(__qt_wrap_clang_backup_prefix) + set(CMAKE_PREFIX_PATH "${__qt_wrap_clang_backup_prefix}") + unset(__qt_wrap_clang_backup_prefix) +endif() + +set(WrapLibClang_FOUND FALSE) +set(__wrap_lib_clang_requested_version_found FALSE) + +# Need to explicitly handle the version check, because the Clang package doesn't. +if(WrapLibClang_FIND_VERSION AND LLVM_PACKAGE_VERSION + AND LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL "${WrapLibClang_FIND_VERSION}") + set(__wrap_lib_clang_requested_version_found TRUE) +endif() + +if(TARGET libclang AND ((TARGET clang-cpp AND TARGET LLVM) OR TARGET clangHandleCXX) AND __wrap_lib_clang_requested_version_found) + set(WrapLibClang_FOUND TRUE) + + get_target_property(type libclang TYPE) + if (MSVC AND type STREQUAL "STATIC_LIBRARY") + get_property(__wrap_lib_clang_multi_config + GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(__wrap_lib_clang_multi_config) + set(__wrap_lib_clang_configs ${CMAKE_CONFIGURATION_TYPES}) + else() + set(__wrap_lib_clang_configs ${CMAKE_BUILD_TYPE}) + endif() + set(__wrap_lib_clang_non_release_configs ${configs}) + list(REMOVE_ITEM __wrap_lib_clang_non_release_configs + Release MinSizeRel RelWithDebInfo) + if(__wrap_lib_clang_non_release_configs STREQUAL __wrap_lib_clang_configs) + message(STATUS "Static linkage against libclang with MSVC was requested, but the build is not a release build, therefore libclang cannot be used.") + set(WrapLibClang_FOUND FALSE) + endif() + endif() + + if(WrapLibClang_FOUND) + add_library(WrapLibClang::WrapLibClang IMPORTED INTERFACE) + + target_include_directories(WrapLibClang::WrapLibClang INTERFACE ${CLANG_INCLUDE_DIRS}) + if (NOT TARGET Threads::Threads) + find_package(Threads) + endif() + qt_internal_disable_find_package_global_promotion(Threads::Threads) + # lupdate must also link to LLVM when using clang-cpp + set(__qt_clang_genex_condition "$,$>") + set(__qt_clang_genex "$") + target_link_libraries(WrapLibClang::WrapLibClang + INTERFACE libclang + "${__qt_clang_genex}" + Threads::Threads + ) + + foreach(version MAJOR MINOR PATCH) + set(QT_LIB_CLANG_VERSION_${version} ${LLVM_VERSION_${version}} CACHE STRING "" FORCE) + endforeach() + set(QT_LIB_CLANG_VERSION ${LLVM_PACKAGE_VERSION} CACHE STRING "" FORCE) + set(QT_LIB_CLANG_LIBDIR "${LLVM_LIBRARY_DIRS}" CACHE STRING "" FORCE) + set(QT_LIBCLANG_RESOURCE_DIR + "\"${QT_LIB_CLANG_LIBDIR}/clang/${QT_LIB_CLANG_VERSION}/include\"" CACHE STRING "" FORCE) + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapLibClang + REQUIRED_VARS WrapLibClang_FOUND + VERSION_VAR LLVM_PACKAGE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenGL.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenGL.cmake new file mode 100644 index 0000000000000000000000000000000000000000..eaf34692faa306875bcbd27f7b36e9ee1a0e0a45 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenGL.cmake @@ -0,0 +1,66 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapOpenGL::WrapOpenGL) + set(WrapOpenGL_FOUND ON) + return() +endif() + +set(WrapOpenGL_FOUND OFF) + +find_package(OpenGL ${WrapOpenGL_FIND_VERSION}) + +if (OpenGL_FOUND) + set(WrapOpenGL_FOUND ON) + + add_library(WrapOpenGL::WrapOpenGL INTERFACE IMPORTED) + if(APPLE) + # CMake 3.27 and older: + # On Darwin platforms FindOpenGL sets IMPORTED_LOCATION to the absolute path of the library + # within the framework. This ends up as an absolute path link flag, which we don't want, + # because that makes our .prl files un-relocatable. + # Extract the framework path instead, and use that in INTERFACE_LINK_LIBRARIES, + # which CMake ends up transforming into a relocatable -framework flag. + # See https://gitlab.kitware.com/cmake/cmake/-/issues/20871 for details. + # + # CMake 3.28 and above: + # IMPORTED_LOCATION is the absolute path the the OpenGL.framework folder. + get_target_property(__opengl_fw_lib_path OpenGL::GL IMPORTED_LOCATION) + if(__opengl_fw_lib_path AND NOT __opengl_fw_lib_path MATCHES "/([^/]+)\\.framework$") + get_filename_component(__opengl_fw_path "${__opengl_fw_lib_path}" DIRECTORY) + endif() + + if(NOT __opengl_fw_path) + # Just a safety measure in case if no OpenGL::GL target exists. + set(__opengl_fw_path "-framework OpenGL") + endif() + + find_library(WrapOpenGL_AGL NAMES AGL) + if(WrapOpenGL_AGL) + set(__opengl_agl_fw_path "${WrapOpenGL_AGL}") + endif() + if(NOT __opengl_agl_fw_path) + set(__opengl_agl_fw_path "-framework AGL") + endif() + + target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE ${__opengl_fw_path}) + target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE ${__opengl_agl_fw_path}) + else() + target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE OpenGL::GL) + endif() +elseif(UNIX AND NOT APPLE AND NOT CMAKE_SYSTEM_NAME STREQUAL "Integrity") + # Requesting only the OpenGL component ensures CMake does not mark the package as + # not found if neither GLX nor libGL are available. This allows finding OpenGL + # on an X11-less Linux system. + find_package(OpenGL ${WrapOpenGL_FIND_VERSION} COMPONENTS OpenGL) + if (OpenGL_FOUND) + set(WrapOpenGL_FOUND ON) + add_library(WrapOpenGL::WrapOpenGL INTERFACE IMPORTED) + target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE OpenGL::OpenGL) + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapOpenGL DEFAULT_MSG WrapOpenGL_FOUND) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenSSL.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenSSL.cmake new file mode 100644 index 0000000000000000000000000000000000000000..24088c4c02a88b5456012c052afa98decb2c75e8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenSSL.cmake @@ -0,0 +1,42 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapOpenSSL::WrapOpenSSL) + set(WrapOpenSSL_FOUND ON) + return() +endif() + +set(WrapOpenSSL_FOUND OFF) + +# Reuse logic from the headers find script. +find_package(WrapOpenSSLHeaders ${WrapOpenSSL_FIND_VERSION}) + +if(TARGET OpenSSL::SSL) + if(WIN32) + get_target_property(libType OpenSSL::Crypto TYPE) + if(libType STREQUAL "ALIAS") + get_target_property(writableLib OpenSSL::Crypto ALIASED_TARGET) + else() + set(writableLib OpenSSL::Crypto) + endif() + set_property(TARGET ${writableLib} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ws2_32 crypt32) + unset(libType) + unset(writableLib) + endif() + + set(WrapOpenSSL_FOUND ON) + + add_library(WrapOpenSSL::WrapOpenSSL INTERFACE IMPORTED) + target_link_libraries(WrapOpenSSL::WrapOpenSSL INTERFACE OpenSSL::SSL) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapOpenSSL + REQUIRED_VARS + OPENSSL_CRYPTO_LIBRARY + OPENSSL_INCLUDE_DIR + VERSION_VAR + OPENSSL_VERSION +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenSSLHeaders.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenSSLHeaders.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7a660e83a6a2026551a902c8631bbe41ed1c7421 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapOpenSSLHeaders.cmake @@ -0,0 +1,45 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapOpenSSLHeaders::WrapOpenSSLHeaders) + set(WrapOpenSSLHeaders_FOUND ON) + return() +endif() + +set(WrapOpenSSLHeaders_FOUND OFF) + +# When cross-compiling (to Android for example), we need to add the OPENSSL_ROOT_DIR as a root path, +# otherwise the value would just be appended to the sysroot, which is wrong. +if(OPENSSL_ROOT_DIR) + set(__find_wrap_openssl_headers_backup_root_dir "${CMAKE_FIND_ROOT_PATH}") + list(APPEND CMAKE_FIND_ROOT_PATH "${OPENSSL_ROOT_DIR}") +endif() + +find_package(OpenSSL ${WrapOpenSSLHeaders_FIND_VERSION}) + +if(OPENSSL_ROOT_DIR) + set(CMAKE_FIND_ROOT_PATH "${__find_wrap_openssl_headers_backup_root_dir}") +endif() + +# We are interested only in include headers. The libraries might be missing, so we can't check the +# _FOUND variable. +if(OPENSSL_INCLUDE_DIR) + set(WrapOpenSSLHeaders_FOUND ON) + + add_library(WrapOpenSSLHeaders::WrapOpenSSLHeaders INTERFACE IMPORTED) + target_include_directories(WrapOpenSSLHeaders::WrapOpenSSLHeaders INTERFACE + ${OPENSSL_INCLUDE_DIR}) + + set_target_properties(WrapOpenSSLHeaders::WrapOpenSSLHeaders PROPERTIES + _qt_is_nolink_target TRUE) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapOpenSSLHeaders + REQUIRED_VARS + OPENSSL_INCLUDE_DIR + VERSION_VAR + OPENSSL_VERSION +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapPCRE2.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapPCRE2.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1e358078c1c1d095edc0a251d2aa64d8809ec8a1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapPCRE2.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(QtFindWrapHelper NO_POLICY_SCOPE) + +qt_find_package_system_or_bundled(wrap_pcre2 + FRIENDLY_PACKAGE_NAME "PCRE2" + WRAP_PACKAGE_TARGET "WrapPCRE2::WrapPCRE2" + WRAP_PACKAGE_FOUND_VAR_NAME "WrapPCRE2_FOUND" + BUNDLED_PACKAGE_NAME "BundledPcre2" + BUNDLED_PACKAGE_TARGET "BundledPcre2" + SYSTEM_PACKAGE_NAME "WrapSystemPCRE2" + SYSTEM_PACKAGE_TARGET "WrapSystemPCRE2::WrapSystemPCRE2" +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapPNG.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapPNG.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bc224715b96bdf0943c49b49ca645baff900ff58 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapPNG.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(QtFindWrapHelper NO_POLICY_SCOPE) + +qt_find_package_system_or_bundled(wrap_png + FRIENDLY_PACKAGE_NAME "PNG" + WRAP_PACKAGE_TARGET "WrapPNG::WrapPNG" + WRAP_PACKAGE_FOUND_VAR_NAME "WrapPNG_FOUND" + BUNDLED_PACKAGE_NAME "BundledLibpng" + BUNDLED_PACKAGE_TARGET "BundledLibpng" + SYSTEM_PACKAGE_NAME "WrapSystemPNG" + SYSTEM_PACKAGE_TARGET "WrapSystemPNG::WrapSystemPNG" +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapResolv.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapResolv.cmake new file mode 100644 index 0000000000000000000000000000000000000000..24cf799dbfb589f70b8507894e598fb1de7e1a8d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapResolv.cmake @@ -0,0 +1,53 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# Copyright (C) 2023 Intel Corpotation. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapResolv::WrapResolv) + set(WrapResolv_FOUND ON) + return() +endif() + +set(WrapResolv_FOUND OFF) + +include(CheckCXXSourceCompiles) +include(CMakePushCheckState) + +if(QNX) + find_library(LIBRESOLV socket) +else() + find_library(LIBRESOLV resolv) +endif() + +cmake_push_check_state() +if(LIBRESOLV) + list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBRESOLV}") +endif() + +check_cxx_source_compiles(" +#include +#include + +int main(int, char **argv) +{ + res_state statep = 0; + int n = res_nmkquery(statep, 0, argv[1], 0, 0, NULL, 0, NULL, NULL, 0); + n = res_nsend(statep, NULL, 0, NULL, 0); + n = dn_expand(NULL, NULL, NULL, NULL, 0); + return n; +} +" HAVE_LIBRESOLV_FUNCTIONS) + +cmake_pop_check_state() + +if(HAVE_LIBRESOLV_FUNCTIONS) + set(WrapResolv_FOUND ON) + add_library(WrapResolv::WrapResolv INTERFACE IMPORTED) + if(LIBRESOLV) + target_link_libraries(WrapResolv::WrapResolv INTERFACE "${LIBRESOLV}") + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapResolv DEFAULT_MSG WrapResolv_FOUND) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapRt.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapRt.cmake new file mode 100644 index 0000000000000000000000000000000000000000..899ac8ba7c381af4ecb2382268962c7d5a93d5a4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapRt.cmake @@ -0,0 +1,57 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapRt::WrapRt) + set(WrapRt_FOUND ON) + return() +endif() + +set(WrapRt_FOUND OFF) + +include(CheckCXXSourceCompiles) +include(CMakePushCheckState) + +find_library(LIBRT rt) + +cmake_push_check_state() +if(LIBRT) + list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBRT}") +endif() + +check_cxx_source_compiles(" +#include +#include + +int main(int, char **) { + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + return 0; +} +" HAVE_GETTIME) + +check_cxx_source_compiles(" +#include +#include +#include + +int main(int, char **) { + shm_open(\"test\", O_RDWR | O_CREAT | O_EXCL, 0666); + shm_unlink(\"test\"); + return 0; +} +" HAVE_SHM_OPEN_SHM_UNLINK) + +cmake_pop_check_state() + +if(HAVE_GETTIME OR HAVE_SHM_OPEN_SHM_UNLINK) + set(WrapRt_FOUND ON) + add_library(WrapRt::WrapRt INTERFACE IMPORTED) + if (LIBRT) + target_link_libraries(WrapRt::WrapRt INTERFACE "${LIBRT}") + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapRt DEFAULT_MSG WrapRt_FOUND) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemDoubleConversion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemDoubleConversion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..801a87977198197e8344479874aafbb50d6fdddf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemDoubleConversion.cmake @@ -0,0 +1,85 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapSystemDoubleConversion::WrapSystemDoubleConversion) + set(WrapSystemDoubleConversion_FOUND ON) + return() +endif() + +set(WrapSystemDoubleConversion_REQUIRED_VARS "__double_conversion_found") + +# Find either Config package or Find module. +# Upstream can be built either with CMake and then provides a Config file, or with Scons in which +# case there's no Config file. +# A Find module might be provided by a 3rd party, for example Conan might generate a Find module. +find_package(double-conversion ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET) +set(__double_conversion_target_name "double-conversion::double-conversion") +if(double-conversion_FOUND AND TARGET "${__double_conversion_target_name}") + set(__double_conversion_found TRUE) + # This ensures the Config file is shown in the fphsa message. + if(double-conversion_CONFIG) + list(PREPEND WrapSystemDoubleConversion_REQUIRED_VARS + double-conversion_CONFIG) + endif() +endif() + +if(NOT __double_conversion_found) + list(PREPEND WrapSystemDoubleConversion_REQUIRED_VARS + DOUBLE_CONVERSION_LIBRARY DOUBLE_CONVERSION_INCLUDE_DIR) + + find_path(DOUBLE_CONVERSION_INCLUDE_DIR + NAMES + double-conversion/double-conversion.h + ) + + find_library(DOUBLE_CONVERSION_LIBRARY_RELEASE NAMES double-conversion) + + # We assume a possible debug build of this library to be named with a d suffix. + # Adjust accordingly if a different naming scheme is established. + find_library(DOUBLE_CONVERSION_LIBRARY_DEBUG NAMES double-conversiond) + + include(SelectLibraryConfigurations) + select_library_configurations(DOUBLE_CONVERSION) + mark_as_advanced(DOUBLE_CONVERSION_INCLUDE_DIR DOUBLE_CONVERSION_LIBRARY) + set(DOUBLE_CONVERSION_INCLUDE_DIRS "${DOUBLE_CONVERSION_INCLUDE_DIR}") + + if(DOUBLE_CONVERSION_LIBRARIES AND DOUBLE_CONVERSION_INCLUDE_DIRS) + set(__double_conversion_found TRUE) + endif() +endif() + +include(FindPackageHandleStandardArgs) + +set(__double_conversion_fphsa_args "") +if(double-conversion_VERSION) + set(WrapSystemDoubleConversion_VERSION "${double-conversion_VERSION}") + list(APPEND __double_conversion_fphsa_args VERSION_VAR WrapSystemDoubleConversion_VERSION) +endif() + +find_package_handle_standard_args(WrapSystemDoubleConversion + REQUIRED_VARS ${WrapSystemDoubleConversion_REQUIRED_VARS} + ${__double_conversion_fphsa_args}) + +if(WrapSystemDoubleConversion_FOUND) + add_library(WrapSystemDoubleConversion::WrapSystemDoubleConversion INTERFACE IMPORTED) + if(TARGET "${__double_conversion_target_name}") + target_link_libraries(WrapSystemDoubleConversion::WrapSystemDoubleConversion + INTERFACE "${__double_conversion_target_name}") + else() + target_link_libraries(WrapSystemDoubleConversion::WrapSystemDoubleConversion + INTERFACE ${DOUBLE_CONVERSION_LIBRARIES}) + target_include_directories(WrapSystemDoubleConversion::WrapSystemDoubleConversion + INTERFACE ${DOUBLE_CONVERSION_INCLUDE_DIRS}) + endif() +endif() +unset(__double_conversion_target_name) +unset(__double_conversion_found) +unset(__double_conversion_fphsa_args) + +include(FeatureSummary) +set_package_properties(WrapSystemDoubleConversion PROPERTIES + URL "https://github.com/google/double-conversion" + DESCRIPTION "double-conversion library") + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemFreetype.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemFreetype.cmake new file mode 100644 index 0000000000000000000000000000000000000000..99954b6707d3ee17b824419c430d87e2c86922a2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemFreetype.cmake @@ -0,0 +1,53 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapSystemFreetype::WrapSystemFreetype) + set(WrapSystemFreetype_FOUND TRUE) + return() +endif() +set(WrapSystemFreetype_REQUIRED_VARS __freetype_found) + +# Hunter has the package named freetype, but exports the Freetype::Freetype target as upstream +# First try the CONFIG package, and afterwards the MODULE if not found +find_package(Freetype ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} + CONFIG NAMES Freetype freetype QUIET) +if(NOT Freetype_FOUND) + find_package(Freetype ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET MODULE) +endif() + +if(Freetype_FOUND) + # vcpkg defines a lower case target name, while upstream Find module defines a prefixed + # upper case name. + set(__freetype_potential_target_names Freetype::Freetype freetype) + foreach(__freetype_potential_target_name ${__freetype_potential_target_names}) + if(TARGET "${__freetype_potential_target_name}") + set(__freetype_target_name "${__freetype_potential_target_name}") + set(__freetype_found TRUE) + break() + endif() + endforeach() +endif() + +if(FREETYPE_LIBRARIES) + list(PREPEND WrapSystemFreetype_REQUIRED_VARS FREETYPE_LIBRARIES) +endif() +if(Freetype_VERSION) + set(WrapSystemFreetype_VERSION "${Freetype_VERSION}") +elseif(FREETYPE_VERSION_STRING) + set(WrapSystemFreetype_VERSION "${FREETYPE_VERSION_STRING}") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapSystemFreetype + REQUIRED_VARS ${WrapSystemFreetype_REQUIRED_VARS} + VERSION_VAR WrapSystemFreetype_VERSION) + +if(WrapSystemFreetype_FOUND) + add_library(WrapSystemFreetype::WrapSystemFreetype INTERFACE IMPORTED) + target_link_libraries(WrapSystemFreetype::WrapSystemFreetype + INTERFACE "${__freetype_target_name}") +endif() +unset(__freetype_target_name) +unset(__freetype_found) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemHarfbuzz.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemHarfbuzz.cmake new file mode 100644 index 0000000000000000000000000000000000000000..068c2ef42ac48953494b3fd2bbdd6f3838dda5dd --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemHarfbuzz.cmake @@ -0,0 +1,90 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapSystemHarfbuzz::WrapSystemHarfbuzz) + set(WrapSystemHarfbuzz_FOUND TRUE) + return() +endif() +set(WrapSystemHarfbuzz_REQUIRED_VARS __harfbuzz_found) + +find_package(harfbuzz ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET) + +# Gentoo has some buggy version of a harfbuzz Config file. Check if include paths are valid. +set(__harfbuzz_target_name "harfbuzz::harfbuzz") +if(harfbuzz_FOUND AND TARGET "${__harfbuzz_target_name}") + get_property(__harfbuzz_include_paths TARGET "${__harfbuzz_target_name}" + PROPERTY INTERFACE_INCLUDE_DIRECTORIES) + foreach(__harfbuzz_include_dir ${__harfbuzz_include_paths}) + if(NOT EXISTS "${__harfbuzz_include_dir}") + # Must be the broken Gentoo harfbuzzConfig.cmake file. Try to use pkg-config instead. + set(__harfbuzz_broken_config_file TRUE) + break() + endif() + endforeach() + + set(__harfbuzz_found TRUE) + if(harfbuzz_VERSION) + set(WrapSystemHarfbuzz_VERSION "${harfbuzz_VERSION}") + endif() +else() + get_cmake_property(__packages_not_found PACKAGES_NOT_FOUND) + if(__packages_not_found) + list(REMOVE_ITEM __packages_not_found harfbuzz) + set_property(GLOBAL PROPERTY PACKAGES_NOT_FOUND "${__packages_not_found}") + endif() + unset(__packages_not_found) +endif() + +if(__harfbuzz_broken_config_file OR NOT __harfbuzz_found) + find_package(PkgConfig QUIET) + pkg_check_modules(PC_HARFBUZZ IMPORTED_TARGET "harfbuzz") + if(PC_HARFBUZZ_FOUND) + set(__harfbuzz_target_name "PkgConfig::PC_HARFBUZZ") + set(__harfbuzz_find_include_dirs_hints + HINTS ${PC_HARFBUZZ_INCLUDEDIR}) + set(__harfbuzz_find_library_hints + HINTS ${PC_HARFBUZZ_LIBDIR}) + if(PC_HARFBUZZ_VERSION) + set(WrapSystemHarfbuzz_VERSION "${PC_HARFBUZZ_VERSION}") + endif() + else() + set(__harfbuzz_target_name "Harfbuzz::Harfbuzz") + endif() + + find_path(HARFBUZZ_INCLUDE_DIRS + NAMES harfbuzz/hb.h + ${__harfbuzz_find_include_dirs_hints}) + find_library(HARFBUZZ_LIBRARIES + NAMES harfbuzz + ${__harfbuzz_find_library_hints}) + + if(HARFBUZZ_INCLUDE_DIRS AND HARFBUZZ_LIBRARIES) + set(__harfbuzz_found TRUE) + if(NOT PC_HARFBUZZ_FOUND) + add_library(${__harfbuzz_target_name} UNKNOWN IMPORTED) + list(TRANSFORM HARFBUZZ_INCLUDE_DIRS APPEND "/harfbuzz") + set_target_properties(${__harfbuzz_target_name} PROPERTIES + IMPORTED_LOCATION "${HARFBUZZ_LIBRARIES}" + INTERFACE_INCLUDE_DIRECTORIES "${HARFBUZZ_INCLUDE_DIRS}" + ) + endif() + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapSystemHarfbuzz + REQUIRED_VARS ${WrapSystemHarfbuzz_REQUIRED_VARS} + VERSION_VAR WrapSystemHarfbuzz_VERSION) +if(WrapSystemHarfbuzz_FOUND) + add_library(WrapSystemHarfbuzz::WrapSystemHarfbuzz INTERFACE IMPORTED) + target_link_libraries(WrapSystemHarfbuzz::WrapSystemHarfbuzz + INTERFACE "${__harfbuzz_target_name}") +endif() +unset(__harfbuzz_target_name) +unset(__harfbuzz_find_include_dirs_hints) +unset(__harfbuzz_find_library_hints) +unset(__harfbuzz_found) +unset(__harfbuzz_include_dir) +unset(__harfbuzz_broken_config_file) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemJpeg.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemJpeg.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ae883401b9d52e5c00fcfafb45d9ac0d5c0301e7 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemJpeg.cmake @@ -0,0 +1,35 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(TARGET WrapSystemJpeg::WrapSystemJpeg) + set(WrapSystemJpeg_FOUND TRUE) + return() +endif() +set(WrapSystemJpeg_REQUIRED_VARS __jpeg_found) + +find_package(JPEG ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET) + +set(__jpeg_target_name "JPEG::JPEG") +if(JPEG_FOUND AND TARGET "${__jpeg_target_name}") + set(__jpeg_found TRUE) +endif() + +if(JPEG_LIBRARIES) + list(PREPEND WrapSystemJpeg_REQUIRED_VARS JPEG_LIBRARIES) +endif() +if(JPEG_VERSION) + set(WrapSystemJpeg_VERSION "${JPEG_VERSION}") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapSystemJpeg + REQUIRED_VARS ${WrapSystemJpeg_REQUIRED_VARS} + VERSION_VAR WrapSystemJpeg_VERSION) + +if(WrapSystemJpeg_FOUND) + add_library(WrapSystemJpeg::WrapSystemJpeg INTERFACE IMPORTED) + target_link_libraries(WrapSystemJpeg::WrapSystemJpeg + INTERFACE "${__jpeg_target_name}") +endif() +unset(__jpeg_target_name) +unset(__jpeg_found) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemMd4c.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemMd4c.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9f6365a75d1f090455e0f8694bb387281547ca5a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemMd4c.cmake @@ -0,0 +1,43 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(TARGET WrapSystemMd4c::WrapSystemMd4c) + set(WrapSystemMd4c_FOUND TRUE) + return() +endif() +set(WrapSystemMd4c_REQUIRED_VARS __md4c_found) + +find_package(md4c ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET) + +set(__md4c_target_name "md4c::md4c") + +if(md4c_FOUND) + set(__md4c_found TRUE) + + # md4c provides a md4c::md4c target but + # older versions create a md4c target without + # namespace. If we find the old variant create + # a namespaced target out of the md4c target. + if(TARGET md4c AND NOT TARGET ${__md4c_target_name}) + add_library(${__md4c_target_name} INTERFACE IMPORTED) + target_link_libraries(${__md4c_target_name} INTERFACE md4c) + endif() + + if(md4c_VERSION) + set(WrapSystemMd4c_VERSION "${md4c_VERSION}") + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapSystemMd4c + REQUIRED_VARS ${WrapSystemMd4c_REQUIRED_VARS} + VERSION_VAR WrapSystemMd4c_VERSION) + +if(WrapSystemMd4c_FOUND) + add_library(WrapSystemMd4c::WrapSystemMd4c INTERFACE IMPORTED) + target_link_libraries(WrapSystemMd4c::WrapSystemMd4c + INTERFACE "${__md4c_target_name}") +endif() + +unset(__md4c_found) +unset(__md4c_target_name) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemPCRE2.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemPCRE2.cmake new file mode 100644 index 0000000000000000000000000000000000000000..03d4982e732f8ea5078280de1bbf221bcf2c9722 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemPCRE2.cmake @@ -0,0 +1,69 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(TARGET WrapSystemPCRE2::WrapSystemPCRE2) + set(WrapSystemPCRE2_FOUND TRUE) + return() +endif() +set(WrapSystemPCRE2_REQUIRED_VARS __pcre2_found) + +find_package(PCRE2 ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} COMPONENTS 16BIT QUIET) + +set(__pcre2_target_name "PCRE2::16BIT") +if(PCRE2_FOUND AND TARGET "${__pcre2_target_name}") + # Hunter case. + set(__pcre2_found TRUE) + if(PCRE2_VERSION) + set(WrapSystemPCRE2_VERSION "${PCRE2_VERSION}") + endif() +else() + get_cmake_property(__packages_not_found PACKAGES_NOT_FOUND) + if(__packages_not_found) + list(REMOVE_ITEM __packages_not_found PCRE2) + set_property(GLOBAL PROPERTY PACKAGES_NOT_FOUND "${__packages_not_found}") + endif() + unset(__packages_not_found) +endif() + +if(NOT __pcre2_found) + list(PREPEND WrapSystemPCRE2_REQUIRED_VARS PCRE2_LIBRARIES PCRE2_INCLUDE_DIRS) + + find_package(PkgConfig QUIET) + pkg_check_modules(PC_PCRE2 QUIET "libpcre2-16") + + find_path(PCRE2_INCLUDE_DIRS + NAMES pcre2.h + HINTS ${PC_PCRE2_INCLUDEDIR}) + find_library(PCRE2_LIBRARY_RELEASE + NAMES pcre2-16 + HINTS ${PC_PCRE2_LIBDIR}) + find_library(PCRE2_LIBRARY_DEBUG + NAMES pcre2-16d pcre2-16 + HINTS ${PC_PCRE2_LIBDIR}) + include(SelectLibraryConfigurations) + select_library_configurations(PCRE2) + + if(PC_PCRE2_VERSION) + set(WrapSystemPCRE2_VERSION "${PC_PCRE2_VERSION}") + endif() + + if (PCRE2_LIBRARIES AND PCRE2_INCLUDE_DIRS) + set(__pcre2_found TRUE) + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapSystemPCRE2 + REQUIRED_VARS ${WrapSystemPCRE2_REQUIRED_VARS} + VERSION_VAR WrapSystemPCRE2_VERSION) +if(WrapSystemPCRE2_FOUND) + add_library(WrapSystemPCRE2::WrapSystemPCRE2 INTERFACE IMPORTED) + if(TARGET "${__pcre2_target_name}") + target_link_libraries(WrapSystemPCRE2::WrapSystemPCRE2 INTERFACE "${__pcre2_target_name}") + else() + target_link_libraries(WrapSystemPCRE2::WrapSystemPCRE2 INTERFACE ${PCRE2_LIBRARIES}) + target_include_directories(WrapSystemPCRE2::WrapSystemPCRE2 INTERFACE ${PCRE2_INCLUDE_DIRS}) + endif() +endif() +unset(__pcre2_target_name) +unset(__pcre2_found) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemPNG.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemPNG.cmake new file mode 100644 index 0000000000000000000000000000000000000000..26bfffa2a87fc5fafd5db3a1666550702a8c0de1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemPNG.cmake @@ -0,0 +1,42 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapSystemPNG::WrapSystemPNG) + set(WrapSystemPNG_FOUND TRUE) + return() +endif() +set(WrapSystemPNG_REQUIRED_VARS __png_found) + +find_package(PNG ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET) + +set(__png_target_name "PNG::PNG") +if(PNG_FOUND AND TARGET "${__png_target_name}") + set(__png_found TRUE) + if(PNG_VERSION) + set(WrapSystemPNG_VERSION "${PNG_VERSION}") + endif() +endif() + +if(PNG_LIBRARIES) + list(PREPEND WrapSystemPNG_REQUIRED_VARS PNG_LIBRARIES) +endif() +if(PNG_VERSION) + set(WrapSystemPNG_VERSION "${PNG_VERSION}") +elseif(PNG_VERSION_STRING) + set(WrapSystemPNG_VERSION "${PNG_VERSION_STRING}") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapSystemPNG + REQUIRED_VARS ${WrapSystemPNG_REQUIRED_VARS} + VERSION_VAR WrapSystemPNG_VERSION) + +if(WrapSystemPNG_FOUND) + add_library(WrapSystemPNG::WrapSystemPNG INTERFACE IMPORTED) + target_link_libraries(WrapSystemPNG::WrapSystemPNG + INTERFACE "${__png_target_name}") +endif() +unset(__png_target_name) +unset(__png_found) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemZLIB.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemZLIB.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a4aead27d4f73d50d8e2b1c78f8ba0de870b9d05 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapSystemZLIB.cmake @@ -0,0 +1,40 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapSystemZLIB::WrapSystemZLIB) + set(WrapSystemZLIB_FOUND ON) + return() +endif() + +set(WrapSystemZLIB_FOUND OFF) + +find_package(ZLIB ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION}) + +if(ZLIB_FOUND) + set(WrapSystemZLIB_FOUND ON) + + add_library(WrapSystemZLIB::WrapSystemZLIB INTERFACE IMPORTED) + if(APPLE) + # On Darwin platforms FindZLIB sets IMPORTED_LOCATION to the absolute path of the library + # within the framework. This ends up as an absolute path link flag, which we don't want, + # because that makes our .prl files un-relocatable and also breaks iOS simulator_and_device + # SDK switching in Xcode. + # Just pass a linker flag instead. + target_link_libraries(WrapSystemZLIB::WrapSystemZLIB INTERFACE "-lz") + else() + target_link_libraries(WrapSystemZLIB::WrapSystemZLIB INTERFACE ZLIB::ZLIB) + endif() +endif() + +if(ZLIB_VERSION) + set(WrapSystemZLIB_VERSION "${ZLIB_VERSION}") +elseif(ZLIB_VERSION_STRING) + set(WrapSystemZLIB_VERSION "${ZLIB_VERSION_STRING}") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapSystemZLIB + REQUIRED_VARS WrapSystemZLIB_FOUND + VERSION_VAR WrapSystemZLIB_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapVulkan.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapVulkan.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1631f73e8e3461ec42f5e702424c781228146410 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapVulkan.cmake @@ -0,0 +1,23 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapVulkan::WrapVulkan) + set(WrapVulkan_FOUND ON) + return() +endif() + +set(WrapVulkan_FOUND OFF) + +find_package(Vulkan ${WrapVulkan_FIND_VERSION} QUIET) + +if(Vulkan_FOUND) + set(WrapVulkan_FOUND ON) + + add_library(WrapVulkan::WrapVulkan INTERFACE IMPORTED) + target_link_libraries(WrapVulkan::WrapVulkan INTERFACE Vulkan::Vulkan) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapVulkan DEFAULT_MSG Vulkan_LIBRARY Vulkan_INCLUDE_DIR) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapVulkanHeaders.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapVulkanHeaders.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d1450b1a0c4738f2a8e81e49baf94e6faf109fe4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapVulkanHeaders.cmake @@ -0,0 +1,75 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapVulkanHeaders::WrapVulkanHeaders) + set(WrapVulkanHeaders_FOUND ON) + return() +endif() + +set(WrapVulkanHeaders_FOUND OFF) + +find_package(Vulkan ${WrapVulkanHeaders_FIND_VERSION} QUIET) + +# We are interested only in include headers. The libraries might be missing, so we can't check the +# _FOUND variable. +if(Vulkan_INCLUDE_DIR) + set(WrapVulkanHeaders_FOUND ON) + + add_library(WrapVulkanHeaders::WrapVulkanHeaders INTERFACE IMPORTED) + target_include_directories(WrapVulkanHeaders::WrapVulkanHeaders INTERFACE + ${Vulkan_INCLUDE_DIR}) + + set_target_properties(WrapVulkanHeaders::WrapVulkanHeaders PROPERTIES + _qt_is_nolink_target TRUE) + + set_target_properties(WrapVulkanHeaders::WrapVulkanHeaders PROPERTIES + _qt_skip_include_dir_for_pri TRUE) + + # Also propagate MoltenVK include directory on Apple platforms if found. + if(APPLE) + # Check for the LunarG Vulkan SDK folder structure. + set(__qt_molten_vk_include_path "${Vulkan_INCLUDE_DIR}/../../MoltenVK/include") + get_filename_component( + __qt_molten_vk_include_path + "${__qt_molten_vk_include_path}" ABSOLUTE) + if(EXISTS "${__qt_molten_vk_include_path}") + target_include_directories(WrapVulkanHeaders::WrapVulkanHeaders INTERFACE + ${__qt_molten_vk_include_path}) + endif() + + # Check for homebrew molten-vk folder structure + set(__qt_molten_vk_homebrew_include_path "${Vulkan_INCLUDE_DIR}/../../include") + get_filename_component( + __qt_molten_vk_homebrew_include_path + "${__qt_molten_vk_homebrew_include_path}" ABSOLUTE) + if(EXISTS "${__qt_molten_vk_homebrew_include_path}") + target_include_directories(WrapVulkanHeaders::WrapVulkanHeaders INTERFACE + ${__qt_molten_vk_homebrew_include_path}) + endif() + + # Check for homebrew vulkan-headers folder structure + # If instead of molten-vk folder, CMAKE_PREFIX_PATH points to Homebrew's + # vulkan-headers installation, then we will not be able to find molten-vk + # headers. If we assume that user has installed the molten-vk formula as + # well, then we might have a chance to pick it up like this. + if(Vulkan_INCLUDE_DIR MATCHES "/homebrew/Cellar/") + set(__qt_standalone_molten_vk_homebrew_include_path + "${Vulkan_INCLUDE_DIR}/../../../../opt/molten-vk/include") + else() + set(__qt_standalone_molten_vk_homebrew_include_path + "${Vulkan_INCLUDE_DIR}/../../molten-vk/include") + endif() + get_filename_component( + __qt_standalone_molten_vk_homebrew_include_path + "${__qt_standalone_molten_vk_homebrew_include_path}" ABSOLUTE) + if(EXISTS "${__qt_standalone_molten_vk_homebrew_include_path}") + target_include_directories(WrapVulkanHeaders::WrapVulkanHeaders INTERFACE + ${__qt_standalone_molten_vk_homebrew_include_path}) + endif() + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapVulkanHeaders DEFAULT_MSG Vulkan_INCLUDE_DIR) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapWebP.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapWebP.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ed0dfe1f31da30e058e5ff60580183a3ceac2963 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapWebP.cmake @@ -0,0 +1,57 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Latest upstream package provides both CMake and autotools building. +# Unfortunately Linux distros and homebrew build the package with autotools, +# so they do not ship the CMake Config file, but only the pkg-config files. +# vcpkg and Conan do ship Config files. +# So try config files first, and then use the regular find_library / find_path dance with pkg-config +# paths as hints. + +# We can't create the same interface imported target multiple times, CMake will complain if we do +# that. This can happen if the find_package call is done in multiple different subdirectories. +if(TARGET WrapWebP::WrapWebP) + set(WrapWebP_FOUND TRUE) + return() +endif() + +find_package(WebP QUIET) +if(TARGET WebP::webp AND TARGET WebP::webpdemux AND TARGET WebP::libwebpmux) + set(WrapWebP_FOUND ON) + add_library(WrapWebP::WrapWebP INTERFACE IMPORTED) + target_link_libraries(WrapWebP::WrapWebP INTERFACE WebP::webp WebP::webpdemux WebP::libwebpmux) + return() +endif() + +find_package(PkgConfig QUIET) +pkg_check_modules(PC_WebP libwebp) +pkg_check_modules(PC_WebPDemux libwebpdemux) +pkg_check_modules(PC_WebPMux libwebpmux) + +find_library(WebP_LIBRARY NAMES "webp" + HINTS ${PC_WebP_LIBDIR}) +find_library(WebP_demux_LIBRARY NAMES "webpdemux" + HINTS ${PC_WebPDemux_LIBDIR}) +find_library(WebP_mux_LIBRARY NAMES "webpmux" + HINTS ${PC_WebPMux_LIBDIR}) + +find_path(WebP_INCLUDE_DIR NAMES "webp/decode.h" + HINTS ${PC_WebP_INCLUDEDIR}) +find_path(WebP_demux_INCLUDE_DIR NAMES "webp/demux.h" + HINTS ${PC_WebPDemux_INCLUDEDIR}) +find_path(WebP_mux_INCLUDE_DIR NAMES "webp/mux.h" + HINTS ${PC_WebPMux_INCLUDEDIR}) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(WrapWebP DEFAULT_MSG WebP_INCLUDE_DIR WebP_LIBRARY + WebP_demux_INCLUDE_DIR WebP_demux_LIBRARY + WebP_mux_INCLUDE_DIR WebP_mux_LIBRARY) + +mark_as_advanced(WebP_INCLUDE_DIR WebP_LIBRARY WebP_demux_INCLUDE_DIR WebP_demux_LIBRARY WebP_mux_INCLUDE_DIR WebP_mux_LIBRARY) +if(WrapWebP_FOUND) + set(WebP_FOUND ON) + add_library(WrapWebP::WrapWebP INTERFACE IMPORTED) + target_link_libraries(WrapWebP::WrapWebP INTERFACE ${WebP_LIBRARY} ${WebP_demux_LIBRARY} ${WebP_mux_LIBRARY}) + target_include_directories(WrapWebP::WrapWebP + INTERFACE ${WebP_INCLUDE_DIR} ${WebP_demux_INCLUDE_DIR} ${WebP_mux_INCLUDE_DIR}) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapZLIB.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapZLIB.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6e03e1f5879ab779d6426809b0414c0ab98e72d5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapZLIB.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(QtFindWrapHelper NO_POLICY_SCOPE) + +qt_find_package_system_or_bundled(wrap_zlib + FRIENDLY_PACKAGE_NAME "ZLIB" + WRAP_PACKAGE_TARGET "WrapZLIB::WrapZLIB" + WRAP_PACKAGE_FOUND_VAR_NAME "WrapZLIB_FOUND" + BUNDLED_PACKAGE_NAME "BundledZLIB" + BUNDLED_PACKAGE_TARGET "BundledZLIB" + SYSTEM_PACKAGE_NAME "WrapSystemZLIB" + SYSTEM_PACKAGE_TARGET "WrapSystemZLIB::WrapSystemZLIB" +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapZSTD.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapZSTD.cmake new file mode 100644 index 0000000000000000000000000000000000000000..924195e6b8f583abb267170ad4da540201abbea6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindWrapZSTD.cmake @@ -0,0 +1,101 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +#.rst: +# FindZstd +# --------- +# +# Try to locate the Zstd library. +# If found, this will define the following variables: +# +# ``WrapZSTD_FOUND`` +# True if the zstd library is available +# ``ZSTD_INCLUDE_DIRS`` +# The zstd include directories +# ``ZSTD_LIBRARIES`` +# The zstd libraries for linking +# +# If ``WrapZSTD_FOUND`` is TRUE, it will also define the following +# imported target: +# +# ``WrapZSTD::WrapZSTD`` +# The zstd library + +find_package(zstd CONFIG QUIET) + +include(FindPackageHandleStandardArgs) + +if(TARGET zstd::libzstd_static OR TARGET zstd::libzstd_shared OR TARGET zstd::libzstd) + find_package_handle_standard_args(WrapZSTD + REQUIRED_VARS zstd_VERSION VERSION_VAR zstd_VERSION) + if(TARGET zstd::libzstd_shared) + set(zstdtargetsuffix "_shared") + elseif(TARGET zstd::libzstd) + set(zstdtargetsuffix "") + else() + set(zstdtargetsuffix "_static") + endif() + + if(NOT TARGET WrapZSTD::WrapZSTD) + add_library(WrapZSTD::WrapZSTD INTERFACE IMPORTED) + set_target_properties(WrapZSTD::WrapZSTD PROPERTIES + INTERFACE_LINK_LIBRARIES "zstd::libzstd${zstdtargetsuffix}") + endif() +else() + get_cmake_property(__packages_not_found PACKAGES_NOT_FOUND) + if(__packages_not_found) + list(REMOVE_ITEM __packages_not_found zstd) + set_property(GLOBAL PROPERTY PACKAGES_NOT_FOUND "${__packages_not_found}") + endif() + unset(__packages_not_found) + + find_package(PkgConfig QUIET) + pkg_check_modules(PC_ZSTD QUIET "libzstd") + + find_path(ZSTD_INCLUDE_DIRS + NAMES zstd.h + HINTS ${PC_ZSTD_INCLUDEDIR} + PATH_SUFFIXES zstd) + + find_library(ZSTD_LIBRARY_RELEASE + NAMES zstd zstd_static + HINTS ${PC_ZSTD_LIBDIR} + ) + find_library(ZSTD_LIBRARY_DEBUG + NAMES zstdd zstd_staticd zstd zstd_static + HINTS ${PC_ZSTD_LIBDIR} + ) + + include(SelectLibraryConfigurations) + select_library_configurations(ZSTD) + + if(PC_ZSTD_VERSION) + set(WrapZSTD_VERSION "${PC_ZSTD_VERSION}") + endif() + find_package_handle_standard_args(WrapZSTD + REQUIRED_VARS ZSTD_LIBRARIES ZSTD_INCLUDE_DIRS + VERSION_VAR WrapZSTD_VERSION) + + if(WrapZSTD_FOUND AND NOT TARGET WrapZSTD::WrapZSTD) + add_library(WrapZSTD::WrapZSTD UNKNOWN IMPORTED) + set_target_properties(WrapZSTD::WrapZSTD PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${ZSTD_INCLUDE_DIRS}") + set_target_properties(WrapZSTD::WrapZSTD PROPERTIES + IMPORTED_LOCATION "${ZSTD_LIBRARY}") + if(ZSTD_LIBRARY_RELEASE) + set_target_properties(WrapZSTD::WrapZSTD PROPERTIES + IMPORTED_LOCATION_RELEASE "${ZSTD_LIBRARY_RELEASE}") + endif() + if(ZSTD_LIBRARY_DEBUG) + set_target_properties(WrapZSTD::WrapZSTD PROPERTIES + IMPORTED_LOCATION_DEBUG "${ZSTD_LIBRARY_DEBUG}") + endif() + endif() + + mark_as_advanced(ZSTD_INCLUDE_DIRS ZSTD_LIBRARIES ZSTD_LIBRARY_RELEASE ZSTD_LIBRARY_DEBUG) +endif() +include(FeatureSummary) +set_package_properties(WrapZSTD PROPERTIES + URL "https://github.com/facebook/zstd" + DESCRIPTION "ZSTD compression library") + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindXKB_COMMON_X11.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindXKB_COMMON_X11.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ced1f7c1a1905e9d603afa9593e4520aa6c6ec93 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindXKB_COMMON_X11.cmake @@ -0,0 +1,10 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +pkg_check_modules(XKB_COMMON_X11 IMPORTED_TARGET "xkbcommon-x11>=0.4.1") + +if (NOT TARGET PkgConfig::XKB_COMMON_X11) + set(XKB_COMMON_X11_FOUND 0) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindXRender.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindXRender.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8ddb37285b083420daaf1e769103ab3aa176e9ff --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/FindXRender.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +find_package(PkgConfig QUIET) + +if(NOT TARGET PkgConfig::XRender) + pkg_check_modules(XRender IMPORTED_TARGET "xrender") + + if (NOT TARGET PkgConfig::XRender) + set(XRender_FOUND 0) + endif() +else() + set(XRender_FOUND 1) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/ModuleDescription.json.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/ModuleDescription.json.in new file mode 100644 index 0000000000000000000000000000000000000000..46322ccaf958ac59e532386053622151368dc546 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/ModuleDescription.json.in @@ -0,0 +1,13 @@ +{ + "name": "${target}", + "repository": "${lower_case_project_name}", + "version": "${PROJECT_VERSION}",${extra_module_information} + "built_with": {${extra_build_information} + "compiler_id": "${CMAKE_CXX_COMPILER_ID}", + "compiler_target": "${CMAKE_CXX_COMPILER_TARGET}", + "compiler_version": "${CMAKE_CXX_COMPILER_VERSION}", + "cross_compiled": ${cross_compilation}, + "target_system": "${CMAKE_SYSTEM_NAME}", + "architecture": "${TEST_architecture_arch}" + } +} diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/PkgConfigLibrary.pc.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/PkgConfigLibrary.pc.in new file mode 100644 index 0000000000000000000000000000000000000000..329ad196972bb333dec67dcd4da5dd454f7323b5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/PkgConfigLibrary.pc.in @@ -0,0 +1,14 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=${prefix} +bindir=${prefix}/@INSTALL_BINDIR@ +libexecdir=${prefix}/@INSTALL_LIBEXECDIR@ +libdir=${prefix}/@INSTALL_LIBDIR@ +includedir=${prefix}/@INSTALL_INCLUDEDIR@ +$<$:mkspecsdir=${prefix}/@INSTALL_MKSPECSDIR@> +$<1: > +Name: @pkgconfig_name@ +Description: @pkgconfig_description@ +Version: @PROJECT_VERSION@ +Libs: $<$:-L${libdir} -l@pkgconfig_file@> @link_options@ +Cflags: @include_dirs@ @compile_defs@ +Requires: $, > diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt3rdPartyLibraryConfig.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt3rdPartyLibraryConfig.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..5a933b22594ddc389e63534e83cb27fa4a6bd5aa --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt3rdPartyLibraryConfig.cmake.in @@ -0,0 +1,36 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +@PACKAGE_INIT@ + +cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_version@) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin +@extra_cmake_code@ +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake") +endif() + +if (NOT QT_NO_CREATE_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Targets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@AdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@VersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@VersionlessAliasTargets.cmake") + endif() + endif() +endif() + +foreach(extra_cmake_include @extra_cmake_includes@) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt3rdPartyLibraryHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt3rdPartyLibraryHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..270524e75003156b70e891dbb6077a0820bcf5a3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt3rdPartyLibraryHelpers.cmake @@ -0,0 +1,455 @@ +macro(qt_internal_get_add_library_option_args option_args) + set(${option_args} + SHARED + STATIC + MODULE + INTERFACE + NO_UNITY_BUILD + ) +endmacro() + +# Helper to create a library using the public _qt_internal_add_library function. +# +# The difference to _qt_internal_add_library is that MODULE is replaced with STATIC in a static +# Qt build. +# Everything else is just prepation for option validating. +function(qt_internal_add_common_qt_library_helper target) + qt_internal_get_add_library_option_args(option_args) + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" + "" + "" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + if(arg_SHARED) + set(arg_SHARED SHARED) + else() + set(arg_SHARED "") + endif() + + if(arg_MODULE) + set(arg_MODULE MODULE) + else() + set(arg_MODULE "") + endif() + + if(arg_STATIC) + set(arg_STATIC STATIC) + else() + set(arg_STATIC "") + endif() + + if(arg_INTERFACE) + set(arg_INTERFACE INTERFACE) + else() + set(arg_INTERFACE "") + endif() + + if(arg_MODULE AND NOT BUILD_SHARED_LIBS) + set(arg_MODULE STATIC) + endif() + + _qt_internal_add_library(${target} ${arg_STATIC} ${arg_SHARED} ${arg_MODULE} ${arg_INTERFACE}) + + if(arg_NO_UNITY_BUILD) + set_property(TARGET "${target}" PROPERTY UNITY_BUILD OFF) + endif() + + qt_internal_mark_as_internal_library(${target}) +endfunction() + +# Wrapper function to create a regular cmake target and forward all the +# arguments collected by the conversion script. +function(qt_internal_add_cmake_library target) + qt_internal_get_add_library_option_args(option_args) + set(single_args + OUTPUT_DIRECTORY + ARCHIVE_INSTALL_DIRECTORY + INSTALL_DIRECTORY + ) + set(multi_args + ${__default_private_args} + ${__default_public_args} + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" + "${single_args}" + "${multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + _qt_internal_validate_no_unity_build(arg) + + qt_remove_args(library_helper_args + ARGS_TO_REMOVE + ${single_args} + ${multi_args} + ALL_ARGS + ${option_args} + ${single_args} + ${multi_args} + ARGS + ${ARGN} + ) + + qt_internal_add_common_qt_library_helper(${target} ${library_helper_args}) + + qt_skip_warnings_are_errors_when_repo_unclean("${target}") + + if (arg_OUTPUT_DIRECTORY) + set_target_properties(${target} PROPERTIES + ARCHIVE_OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + RUNTIME_OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + LIBRARY_OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + ) + endif() + + qt_internal_extend_target("${target}" + SOURCES ${arg_SOURCES} + INCLUDE_DIRECTORIES + ${arg_INCLUDE_DIRECTORIES} + SYSTEM_INCLUDE_DIRECTORIES + ${arg_SYSTEM_INCLUDE_DIRECTORIES} + PUBLIC_INCLUDE_DIRECTORIES + ${arg_PUBLIC_INCLUDE_DIRECTORIES} + PUBLIC_DEFINES + ${arg_PUBLIC_DEFINES} + DEFINES + ${arg_DEFINES} + PUBLIC_LIBRARIES ${arg_PUBLIC_LIBRARIES} + LIBRARIES ${arg_LIBRARIES} Qt::PlatformCommonInternal + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + PUBLIC_COMPILE_OPTIONS ${arg_PUBLIC_COMPILE_OPTIONS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + PUBLIC_LINK_OPTIONS ${arg_PUBLIC_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS} + NO_UNITY_BUILD # Disabled by default + ) +endfunction() + +# This function replaces qmake's qt_helper_lib feature. It is intended to +# compile 3rdparty libraries as part of the build. +# +function(qt_internal_add_3rdparty_library target) + qt_internal_get_add_library_option_args(library_option_args) + + set(option_args + EXCEPTIONS + INSTALL + SKIP_AUTOMOC + ${__qt_internal_sbom_optional_args} + ) + set(single_args + OUTPUT_DIRECTORY + QMAKE_LIB_NAME + ${__qt_internal_sbom_single_args} + ) + set(multi_args + ${__default_private_args} + ${__default_public_args} + ${__qt_internal_sbom_multi_args} + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${library_option_args};${option_args}" + "${single_args}" + "${multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + _qt_internal_validate_no_unity_build(arg) + + qt_remove_args(library_helper_args + ARGS_TO_REMOVE + ${option_args} + ${single_args} + ${multi_args} + ALL_ARGS + ${library_option_args} + ${option_args} + ${single_args} + ${multi_args} + ARGS + ${ARGN} + ) + + qt_internal_add_common_qt_library_helper(${target} ${library_helper_args}) + + set_target_properties(${target} PROPERTIES + _qt_module_interface_name "${target}" + _qt_package_version "${PROJECT_VERSION}" + _qt_package_name "${INSTALL_CMAKE_NAMESPACE}${target}" + _qt_module_is_3rdparty_library TRUE + ) + + set(export_properties + "_qt_module_interface_name" + "_qt_package_version" + "_qt_package_name" + "_qt_module_is_3rdparty_library" + ) + + set_property(TARGET ${target} + APPEND PROPERTY + EXPORT_PROPERTIES "${export_properties}") + + qt_internal_add_qt_repo_known_module(${target}) + qt_internal_add_target_aliases(${target}) + + qt_skip_warnings_are_errors_when_repo_unclean("${target}") + + set_target_properties(${target} PROPERTIES + LIBRARY_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_LIBDIR}" + RUNTIME_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_BINDIR}" + ARCHIVE_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_LIBDIR}" + VERSION ${PROJECT_VERSION} + SOVERSION ${PROJECT_VERSION_MAJOR} + _qt_module_skip_depends_include TRUE + ) + set_property(TARGET "${target}" + APPEND PROPERTY EXPORT_PROPERTIES _qt_module_is_3rdparty_library) + set_property(TARGET "${target}" + APPEND PROPERTY EXPORT_PROPERTIES _qt_module_skip_depends_include) + + qt_handle_multi_config_output_dirs("${target}") + + set_target_properties(${target} PROPERTIES + OUTPUT_NAME "${INSTALL_CMAKE_NAMESPACE}${target}" + ) + + if(NOT arg_INTERFACE) + qt_set_common_target_properties(${target}) + endif() + + if(NOT arg_SKIP_AUTOMOC) + qt_autogen_tools_initial_setup(${target}) + endif() + + if(NOT arg_EXCEPTIONS AND NOT arg_INTERFACE) + qt_internal_set_exceptions_flags("${target}" FALSE) + elseif(arg_EXCEPTIONS) + qt_internal_set_exceptions_flags("${target}" TRUE) + endif() + + qt_internal_extend_target("${target}" + SOURCES ${arg_SOURCES} + INCLUDE_DIRECTORIES + ${arg_INCLUDE_DIRECTORIES} + PUBLIC_INCLUDE_DIRECTORIES + ${arg_PUBLIC_INCLUDE_DIRECTORIES} + PUBLIC_DEFINES + ${arg_PUBLIC_DEFINES} + DEFINES + ${arg_DEFINES} + PUBLIC_LIBRARIES ${arg_PUBLIC_LIBRARIES} + LIBRARIES ${arg_LIBRARIES} Qt::PlatformModuleInternal + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + PUBLIC_COMPILE_OPTIONS ${arg_PUBLIC_COMPILE_OPTIONS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + PUBLIC_LINK_OPTIONS ${arg_PUBLIC_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS} + NO_UNITY_BUILD + ) + + if(NOT BUILD_SHARED_LIBS OR arg_INSTALL) + set(will_install TRUE) + else() + set(will_install FALSE) + endif() + + if(will_install) + qt_generate_3rdparty_lib_pri_file("${target}" "${arg_QMAKE_LIB_NAME}" pri_file) + if(pri_file) + qt_install(FILES "${pri_file}" DESTINATION "${INSTALL_MKSPECSDIR}/modules") + endif() + + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}${target}") + qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${path_suffix}) + qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${path_suffix}) + set(export_name "${INSTALL_CMAKE_NAMESPACE}${target}Targets") + + qt_internal_get_min_new_policy_cmake_version(min_new_policy_version) + qt_internal_get_max_new_policy_cmake_version(max_new_policy_version) + configure_package_config_file( + "${QT_CMAKE_DIR}/Qt3rdPartyLibraryConfig.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake" + INSTALL_DESTINATION "${config_install_dir}" + ) + + write_basic_package_version_file( + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion + ) + qt_internal_write_qt_package_version_file( + "${INSTALL_CMAKE_NAMESPACE}${target}" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersion.cmake" + ) + + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersion.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + + qt_install(TARGETS ${target} + EXPORT "${export_name}" + RUNTIME DESTINATION ${INSTALL_BINDIR} + LIBRARY DESTINATION ${INSTALL_LIBDIR} + ARCHIVE DESTINATION ${INSTALL_LIBDIR} + ) + + qt_install(EXPORT ${export_name} + NAMESPACE "${QT_CMAKE_EXPORT_NAMESPACE}::" + DESTINATION "${config_install_dir}" + ) + + qt_internal_export_additional_targets_file( + TARGETS ${target} + EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target} + CONFIG_INSTALL_DIR "${config_install_dir}" + ) + + qt_internal_export_modern_cmake_config_targets_file( + TARGETS ${target} + EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target} + CONFIG_BUILD_DIR "${config_build_dir}" + CONFIG_INSTALL_DIR "${config_install_dir}" + ) + + set(debug_install_dir "${INSTALL_LIBDIR}") + if (MINGW) + set(debug_install_dir "${INSTALL_BINDIR}") + endif() + qt_enable_separate_debug_info(${target} "${debug_install_dir}") + qt_internal_install_pdb_files(${target} "${INSTALL_LIBDIR}") + endif() + + if(BUILD_SHARED_LIBS AND MSVC) + set_target_properties(${target} PROPERTIES + INTERPROCEDURAL_OPTIMIZATION OFF + ) + endif() + + if(QT_GENERATE_SBOM) + set(sbom_args "") + list(APPEND sbom_args TYPE QT_THIRD_PARTY_MODULE) + + if(NOT will_install) + list(APPEND sbom_args NO_INSTALL) + endif() + + qt_get_cmake_configurations(configs) + foreach(config IN LISTS configs) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + RUNTIME_PATH + "${INSTALL_BINDIR}" + "${config}" + sbom_args + ) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + LIBRARY_PATH + "${INSTALL_LIBDIR}" + "${config}" + sbom_args + ) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + ARCHIVE_PATH + "${INSTALL_LIBDIR}" + "${config}" + sbom_args + ) + endforeach() + + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + ${__qt_internal_sbom_optional_args} + FORWARD_SINGLE + ${__qt_internal_sbom_single_args} + FORWARD_MULTI + ${__qt_internal_sbom_multi_args} + ) + + _qt_internal_extend_sbom(${target} ${sbom_args}) + endif() + + qt_add_list_file_finalizer(qt_internal_finalize_3rdparty_library ${target}) +endfunction() + +function(qt_internal_finalize_3rdparty_library target) + _qt_internal_finalize_sbom(${target}) +endfunction() + +function(qt_install_3rdparty_library_wrap_config_extra_file target) + if(TARGET "${target}") + set(use_bundled "ON") + else() + set(use_bundled "OFF") + endif() + + set(QT_USE_BUNDLED_${target} "${use_bundled}" CACHE INTERNAL "") + set(extra_cmake_code "set(QT_USE_BUNDLED_${target} ${use_bundled} CACHE INTERNAL \"\")") + configure_file( + "${QT_CMAKE_DIR}/QtFindWrapConfigExtra.cmake.in" + "${QT_CONFIG_BUILD_DIR}/${INSTALL_CMAKE_NAMESPACE}/FindWrap${target}ConfigExtra.cmake" + @ONLY + ) + + qt_install(FILES + "${QT_CONFIG_BUILD_DIR}/${INSTALL_CMAKE_NAMESPACE}/FindWrap${target}ConfigExtra.cmake" + DESTINATION "${QT_CONFIG_INSTALL_DIR}/${INSTALL_CMAKE_NAMESPACE}" + COMPONENT Devel + ) +endfunction() + +# This function implements qmake's qt_helper_lib MODULE_EXT_HEADERS and MODULE_EXT_HEADERS_DIR features. +# It creates a header-only module exposing a subset or all headers of a 3rd-party library. +function(qt_internal_add_3rdparty_header_module target) + set(single_args + EXTERNAL_HEADERS_DIR + ) + set(multi_args + EXTERNAL_HEADERS + ) + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" + "${single_args}" + "${multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + _qt_internal_forward_function_args( + FORWARD_PREFIX arg + FORWARD_OUT_VAR add_module_args + FORWARD_SINGLE + EXTERNAL_HEADERS + EXTERNAL_HEADERS_DIR + ) + + qt_internal_add_module(${target} + IS_QT_3RD_PARTY_HEADER_MODULE + INTERNAL_MODULE + HEADER_MODULE + NO_CONFIG_HEADER_FILE + NO_GENERATE_CPP_EXPORTS + ${add_module_args} + ) + + set_target_properties(${target} PROPERTIES + _qt_module_is_3rdparty_header_library TRUE + _qt_module_skip_depends_include TRUE + ) + set_property(TARGET "${target}" + APPEND PROPERTY EXPORT_PROPERTIES _qt_module_is_3rdparty_header_library) + set_property(TARGET "${target}" + APPEND PROPERTY EXPORT_PROPERTIES _qt_module_skip_depends_include) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Config.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Config.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0d55be66ab1634f042bb4ec3b7e2206b822c833d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Config.cmake @@ -0,0 +1,264 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConfigExtras.cmake") +include("${CMAKE_CURRENT_LIST_DIR}/QtPublicCMakeVersionHelpers.cmake") +include("${CMAKE_CURRENT_LIST_DIR}/QtPublicCMakeHelpers.cmake") +include("${CMAKE_CURRENT_LIST_DIR}/QtInstallPaths.cmake") + +__qt_internal_require_suitable_cmake_version_for_using_qt() + +get_filename_component(_qt_cmake_dir "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE) +set(_qt_6_config_cmake_dir "${CMAKE_CURRENT_LIST_DIR}") + +if (NOT QT_NO_CREATE_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6Targets.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6VersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6VersionlessAliasTargets.cmake") + endif() + endif() +else() + # For examples using `find_package(...)` inside their CMakeLists.txt files: + # Make CMake's AUTOGEN detect this Qt version properly + set_directory_properties(PROPERTIES + QT_VERSION_MAJOR 6 + QT_VERSION_MINOR 8 + QT_VERSION_PATCH 1) +endif() + +get_filename_component(_qt_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_qt_import_prefix "${_qt_import_prefix}" REALPATH) +list(APPEND CMAKE_MODULE_PATH "${_qt_import_prefix}") +list(APPEND CMAKE_MODULE_PATH "${_qt_import_prefix}/3rdparty/extra-cmake-modules/find-modules") +list(APPEND CMAKE_MODULE_PATH "${_qt_import_prefix}/3rdparty/kwin") + +if(APPLE) + if(NOT CMAKE_SYSTEM_NAME OR CMAKE_SYSTEM_NAME STREQUAL "Darwin") + set(__qt_internal_cmake_apple_support_files_path "${_qt_import_prefix}/macos") + elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS") + set(__qt_internal_cmake_apple_support_files_path "${_qt_import_prefix}/ios") + elseif(CMAKE_SYSTEM_NAME STREQUAL "visionOS") + set(__qt_internal_cmake_apple_support_files_path "${_qt_import_prefix}/visionos") + endif() +endif() + +# Public helpers available to all Qt packages. +set(__qt_public_files_to_include + QtFeature + QtFeatureCommon + QtPublicAppleHelpers + QtPublicCMakeHelpers + QtPublicCMakeVersionHelpers + QtPublicDependencyHelpers + QtPublicExternalProjectHelpers + QtPublicFinalizerHelpers + QtPublicFindPackageHelpers + QtPublicGitHelpers + QtPublicPluginHelpers + QtPublicSbomGenerationHelpers + QtPublicSbomHelpers + QtPublicTargetHelpers + QtPublicTestHelpers + QtPublicToolHelpers + QtPublicWalkLibsHelpers +) +foreach(__qt_public_file_to_include IN LISTS __qt_public_files_to_include) + include("${__qt_public_file_to_include}") +endforeach() + +if(NOT DEFINED QT_CMAKE_EXPORT_NAMESPACE) + set(QT_CMAKE_EXPORT_NAMESPACE Qt6) +endif() + +set(QT_ADDITIONAL_PACKAGES_PREFIX_PATH "" CACHE STRING + "Additional directories where find(Qt6 ...) components are searched") +set(QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH "" CACHE STRING + "Additional directories where find(Qt6 ...) host Qt components are searched") + +__qt_internal_collect_additional_prefix_paths(_qt_additional_packages_prefix_paths + QT_ADDITIONAL_PACKAGES_PREFIX_PATH) +__qt_internal_collect_additional_prefix_paths(_qt_additional_host_packages_prefix_paths + QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH) + +__qt_internal_prefix_paths_to_roots(_qt_additional_host_packages_root_paths + "${_qt_additional_host_packages_prefix_paths}") + +__qt_internal_collect_additional_module_paths() + +# Propagate sanitizer flags to both internal Qt builds and user projects. +# Allow opt-out in case if downstream projects handle it in a different way. +set(QT_CONFIGURED_SANITIZER_OPTIONS "") + +if(QT_CONFIGURED_SANITIZER_OPTIONS + AND NOT __qt_sanitizer_options_set + AND NOT QT_NO_ADD_SANITIZER_OPTIONS) + set(ECM_ENABLE_SANITIZERS "${QT_CONFIGURED_SANITIZER_OPTIONS}") + include( + "${CMAKE_CURRENT_LIST_DIR}/3rdparty/extra-cmake-modules/modules/ECMEnableSanitizers.cmake") +endif() +# Mark that the current directory scope has its sanitizer flags set. +set(__qt_sanitizer_options_set TRUE) + +# Find required dependencies, if any. +include(CMakeFindDependencyMacro) +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6Dependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6Dependencies.cmake") + + _qt_internal_suggest_dependency_debugging(Qt6 + __qt_Qt6_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) + + if(NOT Qt6_FOUND) + # Clear the components, no need to look for them if dependencies were not found, otherwise + # you get a wall of recursive error messages. + set(Qt6_FIND_COMPONENTS "") + endif() +endif() + +set(_Qt6_FIND_PARTS_QUIET) +if(Qt6_FIND_QUIETLY) + set(_Qt6_FIND_PARTS_QUIET QUIET) +endif() + +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +foreach(module ${Qt6_FIND_COMPONENTS}) + if(NOT "${QT_HOST_PATH}" STREQUAL "" + AND "${module}" MATCHES "Tools$" + AND NOT "${module}" MATCHES "UiTools$" + AND NOT "${module}" MATCHES "ShaderTools$" + AND NOT "${module}" MATCHES "^Tools$" + AND NOT QT_NO_FIND_HOST_TOOLS_PATH_MANIPULATION) + # Make sure that a Qt*Tools package is also looked up in QT_HOST_PATH. + # But don't match QtShaderTools and QtTools which are cross-compiled target package names. + # Allow opt out just in case. + get_filename_component(__qt_find_package_host_qt_path + "${Qt6HostInfo_DIR}/.." ABSOLUTE) + set(__qt_backup_cmake_prefix_path "${CMAKE_PREFIX_PATH}") + set(__qt_backup_cmake_find_root_path "${CMAKE_FIND_ROOT_PATH}") + list(PREPEND CMAKE_PREFIX_PATH "${__qt_find_package_host_qt_path}" + ${_qt_additional_host_packages_prefix_paths}) + list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_HOST_PATH}" + ${_qt_additional_host_packages_root_paths}) + endif() + + _qt_internal_save_find_package_context_for_debugging(Qt6${module}) + + if(NOT Qt6${module}_FOUND) + find_package(Qt6${module} + ${Qt6_FIND_VERSION} + ${_Qt6_FIND_PARTS_QUIET} + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + ${_qt_cmake_dir} + ${_qt_additional_packages_prefix_paths} + ${__qt_find_package_host_qt_path} + ${_qt_additional_host_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) + endif() + + if(NOT "${__qt_find_package_host_qt_path}" STREQUAL "") + set(CMAKE_PREFIX_PATH "${__qt_backup_cmake_prefix_path}") + set(CMAKE_FIND_ROOT_PATH "${__qt_backup_cmake_find_root_path}") + unset(__qt_backup_cmake_prefix_path) + unset(__qt_backup_cmake_find_root_path) + unset(__qt_find_package_host_qt_path) + endif() + + if (NOT Qt6${module}_FOUND) + set(_qt_expected_component_config_path + "${_qt_cmake_dir}/Qt6${module}/Qt6${module}Config.cmake") + get_filename_component( + _qt_expected_component_dir_path "${_qt_expected_component_config_path}" DIRECTORY) + + set(_qt_component_not_found_msg + "\nExpected Config file at \"${_qt_expected_component_config_path}\"") + + if(EXISTS "${_qt_expected_component_config_path}") + string(APPEND _qt_component_not_found_msg " exists \n") + else() + string(APPEND _qt_component_not_found_msg " does NOT exist\n") + endif() + + set(_qt_candidate_component_dir_path "${Qt6${module}_DIR}") + + if(_qt_candidate_component_dir_path AND + NOT _qt_expected_component_dir_path STREQUAL _qt_candidate_component_dir_path) + string(APPEND _qt_component_not_found_msg + "\nQt6${module}_DIR was computed by CMake or specified on the " + "command line by the user: \"${_qt_candidate_component_dir_path}\" " + "\nThe expected and computed paths are different, which might be the reason for " + "the package not to be found.") + endif() + + if(Qt6_FIND_REQUIRED_${module}) + set(Qt6_FOUND False) + set(_Qt_NOTFOUND_MESSAGE + "${_Qt_NOTFOUND_MESSAGE}Failed to find required Qt component \"${module}\". ${_qt_component_not_found_msg}") + set(_qt_full_component_name "Qt6${module}") + _qt_internal_suggest_dependency_debugging(${_qt_full_component_name} + _qt_full_component_name _Qt_NOTFOUND_MESSAGE) + unset(_qt_full_component_name) + break() + elseif(NOT Qt6_FIND_QUIETLY) + message(WARNING + "Failed to find optional Qt component \"${module}\". ${_qt_component_not_found_msg}") + endif() + + unset(_qt_expected_component_config_path) + unset(_qt_expected_component_dir_path) + unset(_qt_candidate_component_dir_path) + unset(_qt_component_not_found_msg) + endif() +endforeach() + +if(Qt6_FIND_COMPONENTS AND _Qt_NOTFOUND_MESSAGE) + set(Qt6_NOT_FOUND_MESSAGE "${_Qt_NOTFOUND_MESSAGE}") + unset(_Qt_NOTFOUND_MESSAGE) +endif() + +if(Qt6_FOUND + AND COMMAND _qt_internal_override_example_install_dir_to_dot + AND NOT _qt_internal_example_dir_set_to_dot) + _qt_internal_override_example_install_dir_to_dot() +endif() + +__qt_internal_defer_promote_targets_in_dir_scope_to_global() +if(CMAKE_VERSION VERSION_LESS 3.21) + __qt_internal_check_link_order_matters() + __qt_internal_check_cmp0099_available() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigExtras.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigExtras.cmake new file mode 100644 index 0000000000000000000000000000000000000000..26462ef568df64efee27940efabd9d56d68d1049 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigExtras.cmake @@ -0,0 +1,66 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT "3.16") +set(QT_COMPUTED_MIN_CMAKE_VERSION_FOR_USING_QT "3.16") + + +if(NOT QT_SUPPORTED_MIN_IOS_SDK_VERSION) + set(QT_SUPPORTED_MIN_IOS_SDK_VERSION "17") +endif() + +if(NOT QT_SUPPORTED_MAX_IOS_SDK_VERSION) + set(QT_SUPPORTED_MAX_IOS_SDK_VERSION "18") +endif() + +if(NOT QT_SUPPORTED_MIN_IOS_XCODE_VERSION) + set(QT_SUPPORTED_MIN_IOS_XCODE_VERSION "15") +endif() + +if(NOT QT_SUPPORTED_MIN_IOS_VERSION) + set(QT_SUPPORTED_MIN_IOS_VERSION "16") +endif() + +if(NOT QT_SUPPORTED_MAX_IOS_VERSION_TESTED) + set(QT_SUPPORTED_MAX_IOS_VERSION_TESTED "18") +endif() + +if(NOT QT_SUPPORTED_MIN_VISIONOS_SDK_VERSION) + set(QT_SUPPORTED_MIN_VISIONOS_SDK_VERSION "1") +endif() + +if(NOT QT_SUPPORTED_MAX_VISIONOS_SDK_VERSION) + set(QT_SUPPORTED_MAX_VISIONOS_SDK_VERSION "2") +endif() + +if(NOT QT_SUPPORTED_MIN_VISIONOS_XCODE_VERSION) + set(QT_SUPPORTED_MIN_VISIONOS_XCODE_VERSION "15") +endif() + +if(NOT QT_SUPPORTED_MIN_VISIONOS_VERSION) + set(QT_SUPPORTED_MIN_VISIONOS_VERSION "1") +endif() + +if(NOT QT_SUPPORTED_MAX_VISIONOS_VERSION_TESTED) + set(QT_SUPPORTED_MAX_VISIONOS_VERSION_TESTED "2") +endif() + +if(NOT QT_SUPPORTED_MIN_MACOS_SDK_VERSION) + set(QT_SUPPORTED_MIN_MACOS_SDK_VERSION "14") +endif() + +if(NOT QT_SUPPORTED_MAX_MACOS_SDK_VERSION) + set(QT_SUPPORTED_MAX_MACOS_SDK_VERSION "15") +endif() + +if(NOT QT_SUPPORTED_MIN_MACOS_XCODE_VERSION) + set(QT_SUPPORTED_MIN_MACOS_XCODE_VERSION "15") +endif() + +if(NOT QT_SUPPORTED_MIN_MACOS_VERSION) + set(QT_SUPPORTED_MIN_MACOS_VERSION "12") +endif() + +if(NOT QT_SUPPORTED_MAX_MACOS_VERSION_TESTED) + set(QT_SUPPORTED_MAX_MACOS_VERSION_TESTED "15") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..05de1065cead7bf29427a1a1c6c91f6d8563b24f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6ConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Dependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Dependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c8220b2b0b8fdfd41731eec2fde678e18b72731e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Dependencies.cmake @@ -0,0 +1,36 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(Qt6_FOUND FALSE) + +if(DEFINED QT_REQUIRE_HOST_PATH_CHECK) + set(__qt_platform_requires_host_info_package "${QT_REQUIRE_HOST_PATH_CHECK}") +elseif(DEFINED ENV{QT_REQUIRE_HOST_PATH_CHECK}) + set(__qt_platform_requires_host_info_package "$ENV{QT_REQUIRE_HOST_PATH_CHECK}") +else() + set(__qt_platform_requires_host_info_package "FALSE") +endif() +set(__qt_platform_initial_qt_host_path "") +set(__qt_platform_initial_qt_host_path_cmake_dir "") + +_qt_internal_setup_qt_host_path( + "${__qt_platform_requires_host_info_package}" + "${__qt_platform_initial_qt_host_path}" + "${__qt_platform_initial_qt_host_path_cmake_dir}") +_qt_internal_find_host_info_package(${__qt_platform_requires_host_info_package}) + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_third_party_deps "Threads\;FALSE\;\;\;") +set(__qt_Qt6_third_party_package_Threads_provided_targets "Threads::Threads") + +if(NOT QT_NO_THREADS_PREFER_PTHREAD_FLAG) + set(THREADS_PREFER_PTHREAD_FLAG TRUE) +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +_qt_internal_find_third_party_dependencies(Qt6 __qt_third_party_deps) + +set(Qt6_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Targets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Targets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..40a943094b2294a9887477949f422d07d8d0a079 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6Targets.cmake @@ -0,0 +1,221 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Platform Qt6::GlobalConfig Qt6::GlobalConfigPrivate Qt6::PlatformCommonInternal Qt6::PlatformModuleInternal Qt6::PlatformPluginInternal Qt6::PlatformAppInternal Qt6::PlatformToolInternal) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Platform +add_library(Qt6::Platform INTERFACE IMPORTED) + +set_target_properties(Qt6::Platform PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "WIN32;_ENABLE_EXTENDED_ALIGNED_STORAGE;WIN64;_WIN64;\$<\$>>:UNICODE\$_UNICODE>" + INTERFACE_COMPILE_FEATURES "cxx_std_17" + INTERFACE_COMPILE_OPTIONS "\$<\$,\$>:-Zc:__cplusplus;-permissive->;\$<\$>>,\$>:\$<\$:-utf-8>>" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/mkspecs/win32-msvc;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Threads::Threads" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Platform" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" + _qt_should_skip_3rd_party_global_promotion "TRUE" +) + +# Create imported target Qt6::GlobalConfig +add_library(Qt6::GlobalConfig INTERFACE IMPORTED) + +set_target_properties(Qt6::GlobalConfig PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include/QtCore" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-GlobalConfig" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" + _qt_should_skip_3rd_party_global_promotion "TRUE" +) + +# Create imported target Qt6::GlobalConfigPrivate +add_library(Qt6::GlobalConfigPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::GlobalConfigPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtCore/6.8.1;${_IMPORT_PREFIX}/include/QtCore/6.8.1/QtCore" + INTERFACE_LINK_LIBRARIES "Qt6::GlobalConfig" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-GlobalConfigPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" + _qt_should_skip_3rd_party_global_promotion "TRUE" +) + +# Create imported target Qt6::PlatformCommonInternal +add_library(Qt6::PlatformCommonInternal INTERFACE IMPORTED) + +set_target_properties(Qt6::PlatformCommonInternal PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "\$<\$>>:QT_NO_JAVA_STYLE_ITERATORS>;\$<\$>>:QT_NO_QASCONST>;\$<\$>>:QT_NO_QEXCHANGE>;\$<\$>>:QT_NO_QSNPRINTF>;\$<\$>>:QT_NO_NARROWING_CONVERSIONS_IN_CONNECT>;\$<\$>>:QT_EXPLICIT_QFILE_CONSTRUCTION_FROM_PATH>;\$<\$>>:QT_NO_FOREACH>;NOMINMAX;QT_NO_NARROWING_CONVERSIONS_IN_CONNECT;\$<\$>:QT_NO_DEBUG>;_CRT_SECURE_NO_WARNINGS;\$<\$,SHARED_LIBRARY>:_WINDLL>" + INTERFACE_COMPILE_OPTIONS "-FS;-Zc:rvalueCast;-Zc:inline;-Zc:strictStrings;\$<\$,Clang>>:-Zc:throwingNew>;\$<\$,Clang>>:-Zc:referenceBinding>;-Zc:ternary;\$<\$,Clang>>:-Zc:externConstexpr>;-Zc:wchar_t;-bigobj;\$<\$>:-guard:cf;-Gw>" + INTERFACE_LINK_LIBRARIES "Qt6::Platform" + INTERFACE_LINK_OPTIONS "\$<\$>:-DYNAMICBASE;-NXCOMPAT;-LARGEADDRESSAWARE;\$<\$>:-OPT:REF;-OPT:ICF;-GUARD:CF>>;\$<\$>:\$<\$>>:-CETCOMPAT>>" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-PlatformCommonInternal" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" + _qt_should_skip_3rd_party_global_promotion "TRUE" +) + +# Create imported target Qt6::PlatformModuleInternal +add_library(Qt6::PlatformModuleInternal INTERFACE IMPORTED) + +set_target_properties(Qt6::PlatformModuleInternal PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "\$<\$>>:QT_USE_QSTRINGBUILDER>;_USE_MATH_DEFINES" + INTERFACE_LINK_LIBRARIES "Qt6::PlatformCommonInternal" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-PlatformModuleInternal" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" + _qt_should_skip_3rd_party_global_promotion "TRUE" +) + +# Create imported target Qt6::PlatformPluginInternal +add_library(Qt6::PlatformPluginInternal INTERFACE IMPORTED) + +set_target_properties(Qt6::PlatformPluginInternal PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "\$<\$>>:QT_USE_QSTRINGBUILDER>" + INTERFACE_LINK_LIBRARIES "Qt6::PlatformCommonInternal" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-PlatformPluginInternal" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" + _qt_should_skip_3rd_party_global_promotion "TRUE" +) + +# Create imported target Qt6::PlatformAppInternal +add_library(Qt6::PlatformAppInternal INTERFACE IMPORTED) + +set_target_properties(Qt6::PlatformAppInternal PROPERTIES + INTERFACE_LINK_LIBRARIES "Qt6::PlatformCommonInternal" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-PlatformAppInternal" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" + _qt_should_skip_3rd_party_global_promotion "TRUE" +) + +# Create imported target Qt6::PlatformToolInternal +add_library(Qt6::PlatformToolInternal INTERFACE IMPORTED) + +set_target_properties(Qt6::PlatformToolInternal PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "\$<\$>>:QT_USE_QSTRINGBUILDER>" + INTERFACE_LINK_LIBRARIES "Qt6::PlatformAppInternal" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-PlatformToolInternal" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" + _qt_should_skip_3rd_party_global_promotion "TRUE" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6Targets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6VersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6VersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b53b44d52efee4b86b3a88927c354306302335b0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6VersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Platform;GlobalConfig;GlobalConfigPrivate;PlatformCommonInternal;PlatformModuleInternal;PlatformPluginInternal;PlatformAppInternal;PlatformToolInternal") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6VersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6VersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..71a0c484b67d175e61949b53bbbffccc2d35b98f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/Qt6VersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Platform;GlobalConfig;GlobalConfigPrivate;PlatformCommonInternal;PlatformModuleInternal;PlatformPluginInternal;PlatformAppInternal;PlatformToolInternal") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAndroidHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAndroidHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4ab84f6504928e0dd2635c4ae9d944b9572c523f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAndroidHelpers.cmake @@ -0,0 +1,328 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# +# Android specific functions/macros/properties required for building Qt Modules +# + +macro(qt_internal_setup_android_target_properties) + define_property(TARGET + PROPERTY + QT_ANDROID_MODULE_INSTALL_DIR + BRIEF_DOCS + "Recorded install location for a Qt Module." + FULL_DOCS + "Recorded install location for a Qt Module. Used by qt_internal_android_dependencies()." + ) + + define_property(TARGET + PROPERTY + QT_ANDROID_JAR_DEPENDENCIES + BRIEF_DOCS + "Qt Module Jar dependencies list." + FULL_DOCS + "Qt Module Jar dependencies list." + ) + + define_property(TARGET + PROPERTY + QT_ANDROID_BUNDLED_JAR_DEPENDENCIES + BRIEF_DOCS + "Qt Module Jars that should be bundled with it during packing." + FULL_DOCS + "Qt Module Jars that should be bundled with it during packing." + ) + + define_property(TARGET + PROPERTY + QT_ANDROID_LIB_DEPENDENCIES + BRIEF_DOCS + "Qt Module C++ libraries that should be bundled with it during packing." + FULL_DOCS + "Qt Module C++ libraries that should be bundled with it during packing." + ) + + define_property(TARGET + PROPERTY + QT_ANDROID_LIB_DEPENDENCY_REPLACEMENTS + BRIEF_DOCS + "Qt Module C++ libraries that can replace libraries declared with the QT_ANDROID_LIB_DEPENDENCIES property." + FULL_DOCS + "Qt Module C++ libraries that can replace libraries declared with the QT_ANDROID_LIB_DEPENDENCIES property." + ) + + define_property(TARGET + PROPERTY + QT_ANDROID_BUNDLED_FILES + BRIEF_DOCS + "Qt Module files that need to be bundled during packing." + FULL_DOCS + "Qt Module files that need to be bundled during packing." + ) + + define_property(TARGET + PROPERTY + QT_ANDROID_PERMISSIONS + BRIEF_DOCS + "Qt Module android permission list." + FULL_DOCS + "Qt Module android permission list." + ) + + define_property(TARGET + PROPERTY + QT_ANDROID_FEATURES + BRIEF_DOCS + "Qt Module android feature list." + FULL_DOCS + "Qt Module android feature list." + ) + + define_property(TARGET + PROPERTY + QT_ANDROID_ABIS + BRIEF_DOCS + "List of ABIs that the target packages are built with." + FULL_DOCS + "List of ABIs that the target packages are built with." + ) +endmacro() + +function(qt_internal_add_android_permission target) + cmake_parse_arguments(arg "" "NAME" "ATTRIBUTES" ${ARGN}) + + if(NOT target) + message(FATAL_ERROR "Target for adding Android permission cannot be empty (${arg_NAME})") + endif() + + if(NOT arg_NAME) + message(FATAL_ERROR "NAME for adding Android permission cannot be empty (${target})") + endif() + + set(permission_entry "${arg_NAME}") + + if(arg_ATTRIBUTES) + # Permission with additional attributes + list(LENGTH arg_ATTRIBUTES attributes_len) + math(EXPR attributes_modulus "${attributes_len} % 2") + if(NOT (attributes_len GREATER 1 AND attributes_modulus EQUAL 0)) + message(FATAL_ERROR "Android permission attributes must be name-value pairs (${arg_NAME})") + endif() + # Combine name-value pairs + set(index 0) + set(attributes "") + while(index LESS attributes_len) + list(GET arg_ATTRIBUTES ${index} name) + math(EXPR index "${index} + 1") + list(GET arg_ATTRIBUTES ${index} value) + string(APPEND attributes " android:${name}=\"${value}\"") + math(EXPR index "${index} + 1") + endwhile() + set(permission_entry "${permission_entry}\;${attributes}") + endif() + + # Append the permission to the target's property + set_property(TARGET ${target} APPEND PROPERTY QT_ANDROID_PERMISSIONS "${permission_entry}") +endfunction() + + +function(qt_internal_android_dependencies_content target file_content_out) + get_target_property(arg_JAR_DEPENDENCIES ${target} QT_ANDROID_JAR_DEPENDENCIES) + get_target_property(arg_BUNDLED_JAR_DEPENDENCIES ${target} QT_ANDROID_BUNDLED_JAR_DEPENDENCIES) + get_target_property(arg_LIB_DEPENDENCIES ${target} QT_ANDROID_LIB_DEPENDENCIES) + get_target_property(arg_LIB_DEPENDENCY_REPLACEMENTS ${target} QT_ANDROID_LIB_DEPENDENCY_REPLACEMENTS) + get_target_property(arg_BUNDLED_FILES ${target} QT_ANDROID_BUNDLED_FILES) + get_target_property(arg_PERMISSIONS ${target} QT_ANDROID_PERMISSIONS) + get_target_property(arg_FEATURES ${target} QT_ANDROID_FEATURES) + + if ((NOT arg_JAR_DEPENDENCIES) + AND (NOT arg_BUNDLED_JAR_DEPENDENCIES) + AND (NOT arg_LIB_DEPENDENCIES) + AND (NOT arg_LIB_DEPENDENCY_REPLACEMENTS) + AND (NOT arg_BUNDLED_FILES) + AND (NOT arg_PERMISSIONS) + AND (NOT arg_FEATURES)) + # None of the values were set, so there's nothing to do + return() + endif() + + # mimic qmake's section and string splitting from + # mkspecs/feature/qt_android_deps.prf + macro(section string delimiter first second) + string(FIND ${string} ${delimiter} delimiter_location) + if (NOT ${delimiter_location} EQUAL -1) + string(SUBSTRING ${string} 0 ${delimiter_location} ${first}) + math(EXPR delimiter_location "${delimiter_location} + 1") + string(SUBSTRING ${string} ${delimiter_location} -1 ${second}) + else() + set(${first} ${string}) + set(${second} "") + endif() + endmacro() + + set(file_contents "") + + # Jar Dependencies + if(arg_JAR_DEPENDENCIES) + foreach(jar_dependency IN LISTS arg_JAR_DEPENDENCIES) + section(${jar_dependency} ":" jar_file init_class) + if (init_class) + set(init_class "initClass=\"${init_class}\"") + endif() + # Use unix path to allow using files on any host platform. + file(TO_CMAKE_PATH ${jar_file} jar_file_unix_path) + string(APPEND file_contents "\n") + endforeach() + endif() + + # Bundled Jar Dependencies + if(arg_BUNDLED_JAR_DEPENDENCIES) + foreach(jar_bundle IN LISTS arg_BUNDLED_JAR_DEPENDENCIES) + section(${jar_bundle} ":" bundle_file init_class) + if (init_class) + set(init_class "initClass=\"${init_class}\"") + endif() + # Use unix path to allow using files on any host platform. + file(TO_CMAKE_PATH ${bundle_file} jar_bundle_unix_path) + string(APPEND file_contents + "\n") + endforeach() + endif() + + # Lib Dependencies + if(arg_LIB_DEPENDENCIES) + foreach(lib IN LISTS arg_LIB_DEPENDENCIES) + string(REPLACE ".so" "_${CMAKE_ANDROID_ARCH_ABI}.so" lib ${lib}) + section(${lib} ":" lib_file lib_extends) + if (lib_extends) + set(lib_extends "extends=\"${lib_extends}\"") + endif() + # Use unix path to allow using files on any host platform. + file(TO_CMAKE_PATH ${lib_file} lib_file_unix_path) + string(APPEND file_contents "\n") + endforeach() + endif() + + # Lib Dependencies Replacements + if(arg_LIB_DEPENDENCY_REPLACEMENTS) + foreach(lib IN LISTS arg_LIB_DEPENDENCY_REPLACEMENTS) + string(REPLACE ".so" "_${CMAKE_ANDROID_ARCH_ABI}.so" lib ${lib}) + section(${lib} ":" lib_file lib_replacement) + if (lib_replacement) + # Use unix path to allow using files on any host platform. + file(TO_CMAKE_PATH ${lib_replacement} lib_replacement_unix_path) + set(lib_replacement "replaces=\"${lib_replacement_unix_path}\"") + endif() + # Use unix path to allow using files on any host platform. + file(TO_CMAKE_PATH ${lib_file} lib_file_unix_path) + string(APPEND file_contents + "\n") + endforeach() + endif() + + # Bundled files + if(arg_BUNDLED_FILES) + foreach(bundled_file IN LISTS arg_BUNDLED_FILES) + # Use unix path to allow using files on any host platform. + file(TO_CMAKE_PATH ${bundled_file} file_unix_path) + string(APPEND file_contents "\n") + endforeach() + endif() + + # Android Permissions + if(arg_PERMISSIONS) + foreach(permission IN LISTS arg_PERMISSIONS) + # Check if the permission has also extra attributes in addition to the permission name + list(LENGTH permission permission_len) + if(permission_len EQUAL 1) + string(APPEND file_contents "\n") + elseif(permission_len EQUAL 2) + list(GET permission 0 name) + list(GET permission 1 extras) + string(APPEND file_contents "\n") + else() + message(FATAL_ERROR "Unexpected permission: " "${permission}" "${permission_len}") + endif() + endforeach() + endif() + + # Android Features + if(arg_FEATURES) + foreach(feature IN LISTS arg_FEATURES) + string(APPEND file_contents "\n") + endforeach() + endif() + + set(${file_content_out} ${file_contents} PARENT_SCOPE) +endfunction() + +# Generate Qt Module -android-dependencies.xml required by the +# androiddeploytoolqt to successfully copy all the plugins and other dependent +# items into the APK +function(qt_internal_android_dependencies target) + get_target_property(target_type "${target}" TYPE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + return() + endif() + + # Get plugins for the current module + get_target_property(module_plugin_types ${target} MODULE_PLUGIN_TYPES) + + # Get depends for the current module + qt_internal_android_dependencies_content(${target} file_contents) + + # Get plugins from the module's plugin types and get their dependencies + foreach(plugin ${QT_KNOWN_PLUGINS}) + get_target_property(iter_known_plugin_type ${plugin} QT_PLUGIN_TYPE) + foreach(plugin_type ${module_plugin_types}) + if (plugin_type STREQUAL iter_known_plugin_type) + qt_internal_android_dependencies_content(${plugin} plugin_file_contents) + string(APPEND file_contents ${plugin_file_contents}) + endif() + endforeach() + endforeach() + + if ((NOT module_plugin_types) + AND (NOT file_contents)) + # None of the values were set, so there's nothing to do + return() + endif() + + get_target_property(target_output_name ${target} OUTPUT_NAME) + if (NOT target_output_name) + set(target_name ${target}) + else() + set(target_name ${target_output_name}) + endif() + + string(PREPEND file_contents "\n") + string(PREPEND file_contents "\n") + + # Module plugins + if(module_plugin_types) + foreach(plugin IN LISTS module_plugin_types) + string(APPEND file_contents + "\n") + endforeach() + endif() + + string(APPEND file_contents "\n") + string(APPEND file_contents "") + + qt_path_join(dependency_file "${QT_BUILD_DIR}" "${INSTALL_LIBDIR}" "${target_name}_${CMAKE_ANDROID_ARCH_ABI}-android-dependencies.xml") + file(WRITE ${dependency_file} ${file_contents}) + + get_target_property(target_install_dir ${target} QT_ANDROID_MODULE_INSTALL_DIR) + if (NOT target_install_dir) + message(SEND_ERROR "qt_internal_android_dependencies: Target ${target} is either not a Qt Module or has no recorded install location") + return() + endif() + + # Copy file into install directory, required by the androiddeployqt tool. + qt_install(FILES + ${dependency_file} + DESTINATION + ${target_install_dir} + COMPONENT + Devel) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAppHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAppHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..56614defdea8ac4a43bac80a7fcf5dfe8304e2f3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAppHelpers.cmake @@ -0,0 +1,208 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This function creates a CMake target for a Qt internal app. +# Such projects had a load(qt_app) command. +function(qt_internal_add_app target) + set(option_args + NO_INSTALL + INSTALL_VERSIONED_LINK + EXCEPTIONS + NO_UNITY_BUILD + ${__qt_internal_sbom_optional_args} + ) + set(single_args + ${__default_target_info_args} + ${__qt_internal_sbom_single_args} + INSTALL_DIR + ) + set(multi_args + ${__default_private_args} + ${__qt_internal_sbom_multi_args} + PUBLIC_LIBRARIES + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" + "${single_args}" + "${multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + set(exceptions "") + if(arg_EXCEPTIONS) + set(exceptions EXCEPTIONS) + endif() + + if(DEFINED arg_INSTALL_DIR) + set(forward_install_dir INSTALL_DIRECTORY ${arg_INSTALL_DIR}) + else() + set(forward_install_dir "") + set(arg_INSTALL_DIR ${INSTALL_BINDIR}) + endif() + set(output_directory "${QT_BUILD_DIR}/${arg_INSTALL_DIR}") + + set(no_install "") + if(arg_NO_INSTALL) + set(no_install NO_INSTALL) + endif() + + if(arg_PUBLIC_LIBRARIES) + message(WARNING + "qt_internal_add_app's PUBLIC_LIBRARIES option is deprecated, and will be removed in " + "a future Qt version. Use the LIBRARIES option instead.") + endif() + + if(arg_NO_UNITY_BUILD) + set(arg_NO_UNITY_BUILD "NO_UNITY_BUILD") + else() + set(arg_NO_UNITY_BUILD "") + endif() + + _qt_internal_forward_function_args( + FORWARD_PREFIX arg + FORWARD_OUT_VAR add_executable_args + FORWARD_SINGLE + TARGET_COMPANY + TARGET_COPYRIGHT + TARGET_DESCRIPTION + TARGET_PRODUCT + TARGET_VERSION + ) + + qt_internal_add_executable("${target}" + QT_APP + DELAY_RC + DELAY_TARGET_INFO + OUTPUT_DIRECTORY "${output_directory}" + ${exceptions} + ${no_install} + ${arg_NO_UNITY_BUILD} + ${forward_install_dir} + SOURCES ${arg_SOURCES} + NO_PCH_SOURCES ${arg_NO_PCH_SOURCES} + NO_UNITY_BUILD_SOURCES ${arg_NO_UNITY_BUILD_SOURCES} + INCLUDE_DIRECTORIES + ${arg_INCLUDE_DIRECTORIES} + DEFINES + ${arg_DEFINES} + ${deprecation_define} + LIBRARIES + ${arg_LIBRARIES} + ${arg_PUBLIC_LIBRARIES} + Qt::PlatformAppInternal + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS} + ${add_executable_args} + # If you are putting anything after these, make sure that + # qt_set_target_info_properties knows how to process them + ) + qt_internal_add_target_aliases("${target}") + qt_internal_adjust_main_config_runtime_output_dir("${target}" "${output_directory}") + + # To mimic the default behaviors of qt_app.prf, we by default enable GUI Windows applications, + # but don't enable macOS bundles. + # Bundles are enabled in a separate set_target_properties call if an Info.plist file + # is provided. + # Similarly, the Windows GUI flag is disabled in a separate call + # if CONFIG += console was encountered during conversion. + set_target_properties("${target}" PROPERTIES WIN32_EXECUTABLE TRUE) + + # Consider every app as user facing tool. + set_property(GLOBAL APPEND PROPERTY QT_USER_FACING_TOOL_TARGETS ${target}) + + # Install versioned link if requested. + if(NOT arg_NO_INSTALL AND arg_INSTALL_VERSIONED_LINK) + qt_internal_install_versioned_link(WORKING_DIRECTORY "${arg_INSTALL_DIR}" + TARGETS ${target}) + endif() + + if(QT_GENERATE_SBOM) + set(sbom_args "") + list(APPEND sbom_args TYPE QT_APP) + + qt_get_cmake_configurations(cmake_configs) + foreach(cmake_config IN LISTS cmake_configs) + qt_get_install_target_default_args( + OUT_VAR unused_install_targets_default_args + OUT_VAR_RUNTIME runtime_install_destination + RUNTIME "${arg_INSTALL_DIR}" + CMAKE_CONFIG "${cmake_config}" + ALL_CMAKE_CONFIGS ${cmake_configs}) + + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + RUNTIME_PATH + "${runtime_install_destination}" + "${cmake_config}" + sbom_args + ) + endforeach() + + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + NO_INSTALL + ${__qt_internal_sbom_optional_args} + FORWARD_SINGLE + ${__qt_internal_sbom_single_args} + FORWARD_MULTI + ${__qt_internal_sbom_multi_args} + ) + + _qt_internal_extend_sbom(${target} ${sbom_args}) + endif() + + qt_add_list_file_finalizer(qt_internal_finalize_app ${target}) +endfunction() + +function(qt_internal_get_title_case value out_var) + if(NOT value) + set(${out_var} "" PARENT_SCOPE) + return() + endif() + string(SUBSTRING "${value}" 0 1 first_char) + string(TOUPPER "${first_char}" first_char_upper) + string(SUBSTRING "${value}" 1 -1 rest_of_value) + set(title_value "${first_char_upper}${rest_of_value}") + set(${out_var} "${title_value}" PARENT_SCOPE) +endfunction() + +function(qt_internal_update_app_target_info_properties target) + # First update the delayed properties with any values that might have been set after the + # qt_internal_add_app() call. + qt_internal_update_delayed_target_info_properties(${target}) + + # Set defaults in case if no values were set. + get_target_property(target_version ${target} QT_DELAYED_TARGET_VERSION) + if(NOT target_version) + set_target_properties(${target} PROPERTIES QT_DELAYED_TARGET_VERSION "${PROJECT_VERSION}") + endif() + + get_target_property(target_description ${target} QT_DELAYED_TARGET_DESCRIPTION) + if(NOT target_description) + qt_internal_get_title_case("${target}" upper_name) + set_target_properties(${target} PROPERTIES QT_DELAYED_TARGET_DESCRIPTION "Qt ${upper_name}") + endif() + + # Finally set the final values. + qt_internal_set_target_info_properties_from_delayed_properties("${target}") +endfunction() + +function(qt_internal_finalize_app target) + qt_internal_update_app_target_info_properties("${target}") + + if(WIN32) + _qt_internal_generate_win32_rc_file("${target}") + endif() + + # Rpaths need to be applied in the finalizer, because the MACOSX_BUNDLE property might be + # set after a qt_internal_add_app call. + qt_apply_rpaths(TARGET "${target}" INSTALL_PATH "${INSTALL_BINDIR}" RELATIVE_RPATH) + qt_internal_apply_staging_prefix_build_rpath_workaround() + _qt_internal_finalize_sbom(${target}) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAutoDetectHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAutoDetectHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..95e72b307c333b61559359ff309cae58f3b1edc5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAutoDetectHelpers.cmake @@ -0,0 +1,624 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Collection of auto detection routines to improve the user experience when +# building Qt from source. +# +# Make sure to not run detection when building standalone tests, because the detection was already +# done when initially configuring qtbase. + +function(qt_internal_ensure_static_qt_config) + if(NOT DEFINED BUILD_SHARED_LIBS) + set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build Qt statically or dynamically" FORCE) + endif() + + if(BUILD_SHARED_LIBS) + message(FATAL_ERROR + "Building Qt for ${CMAKE_SYSTEM_NAME} as shared libraries is not supported.") + endif() +endfunction() + +function(qt_auto_detect_wasm) + if("${QT_QMAKE_TARGET_MKSPEC}" STREQUAL "wasm-emscripten" + OR "${QT_QMAKE_TARGET_MKSPEC}" STREQUAL "wasm-emscripten-64") + if (NOT DEFINED ENV{EMSDK}) + message(FATAL_ERROR + "Can't find an Emscripten SDK! Make sure the EMSDK environment variable is " + "available by activating and sourcing the emscripten sdk. Also ensure emcc is in " + "your path.") + endif() + if(NOT DEFINED QT_AUTODETECT_WASM_IS_DONE) + message(STATUS "Extracting Emscripten SDK info from EMSDK env var: $ENV{EMSDK}") + __qt_internal_get_emroot_path_suffix_from_emsdk_env(EMROOT_PATH) + + __qt_internal_query_emsdk_version("${EMROOT_PATH}" TRUE CMAKE_EMSDK_REGEX_VERSION) + set(EMCC_VERSION "${CMAKE_EMSDK_REGEX_VERSION}" CACHE STRING INTERNAL FORCE) + + if(NOT DEFINED BUILD_SHARED_LIBS) + qt_internal_ensure_static_qt_config() + endif() + + # Find toolchain file + if(NOT DEFINED CMAKE_TOOLCHAIN_FILE) + __qt_internal_get_emscripten_cmake_toolchain_file_path_from_emsdk_env( + "${EMROOT_PATH}" wasm_toolchain_file) + set(CMAKE_TOOLCHAIN_FILE "${wasm_toolchain_file}" CACHE STRING "" FORCE) + endif() + + if(EXISTS "${CMAKE_TOOLCHAIN_FILE}") + message(STATUS + "Emscripten ${EMCC_VERSION} toolchain file detected at ${CMAKE_TOOLCHAIN_FILE}") + else() + __qt_internal_show_error_no_emscripten_toolchain_file_found_when_building_qt() + endif() + + __qt_internal_get_emcc_recommended_version(recommended_version) + set(QT_EMCC_RECOMMENDED_VERSION "${recommended_version}" CACHE STRING INTERNAL FORCE) + + set(QT_AUTODETECT_WASM_IS_DONE TRUE CACHE BOOL "") + else() + message(STATUS + "Reusing cached Emscripten ${EMCC_VERSION} toolchain file detected at " + "${CMAKE_TOOLCHAIN_FILE}") + endif() + endif() +endfunction() + +function(qt_auto_detect_android) + # We assume an Android build if any of the ANDROID_* cache variables are set. + if(DEFINED ANDROID_SDK_ROOT + OR DEFINED ANDROID_NDK_ROOT + OR DEFINED ANDROID_ABI + OR DEFINED ANDROID_NATIVE_ABI_LEVEL + OR DEFINED ANDROID_STL) + set(android_detected TRUE) + else() + set(android_detected FALSE) + endif() + + # Auto-detect NDK root + if(NOT DEFINED ANDROID_NDK_ROOT AND DEFINED ANDROID_SDK_ROOT) + file(GLOB ndk_versions LIST_DIRECTORIES true RELATIVE "${ANDROID_SDK_ROOT}/ndk" + "${ANDROID_SDK_ROOT}/ndk/*") + unset(ndk_root) + if(NOT ndk_versions STREQUAL "") + # Use the NDK with the highest version number. + if(CMAKE_VERSION VERSION_LESS 3.18) + list(SORT ndk_versions) + list(REVERSE ndk_versions) + else() + list(SORT ndk_versions COMPARE NATURAL ORDER DESCENDING) + endif() + list(GET ndk_versions 0 ndk_root) + string(PREPEND ndk_root "${ANDROID_SDK_ROOT}/ndk/") + else() + # Fallback: use the deprecated "ndk-bundle" directory within the SDK root. + set(ndk_root "${ANDROID_SDK_ROOT}/ndk-bundle") + if(NOT IS_DIRECTORY "${ndk_root}") + unset(ndk_root) + endif() + endif() + if(DEFINED ndk_root) + message(STATUS "Android NDK detected: ${ndk_root}") + set(ANDROID_NDK_ROOT "${ndk_root}" CACHE STRING "") + endif() + endif() + + # Auto-detect toolchain file + if(NOT DEFINED CMAKE_TOOLCHAIN_FILE AND DEFINED ANDROID_NDK_ROOT) + set(toolchain_file "${ANDROID_NDK_ROOT}/build/cmake/android.toolchain.cmake") + if(EXISTS "${toolchain_file}") + message(STATUS "Android toolchain file within NDK detected: ${toolchain_file}") + set(CMAKE_TOOLCHAIN_FILE "${toolchain_file}" CACHE STRING "") + else() + message(FATAL_ERROR "Cannot find the toolchain file '${toolchain_file}'. " + "Please specify the toolchain file with -DCMAKE_TOOLCHAIN_FILE=.") + endif() + endif() + + if(NOT DEFINED CMAKE_TOOLCHAIN_FILE AND android_detected) + message(FATAL_ERROR "An Android build was requested, but no Android toolchain file was " + "specified nor detected.") + endif() + + if(DEFINED CMAKE_TOOLCHAIN_FILE AND NOT DEFINED QT_AUTODETECT_ANDROID) + # Peek into the toolchain file and check if it looks like an Android one. + if(NOT android_detected) + file(READ ${CMAKE_TOOLCHAIN_FILE} toolchain_file_content OFFSET 0 LIMIT 80) + string(FIND "${toolchain_file_content}" "The Android Open Source Project" + find_result REVERSE) + if(NOT ${find_result} EQUAL -1) + set(android_detected TRUE) + endif() + endif() + + if(android_detected) + message(STATUS "Android build detected, checking configuration defaults...") + # ANDROID_NATIVE_API_LEVEL is an just an alias to ANDROID_PLATFORM, check for both + if(NOT DEFINED ANDROID_PLATFORM AND NOT DEFINED ANDROID_NATIVE_API_LEVEL) + message(STATUS "Neither ANDROID_PLATFORM nor ANDROID_NATIVE_API_LEVEL" + " were specified, using API level 28 as default") + set(ANDROID_PLATFORM "android-28" CACHE STRING "") + set(ANDROID_NATIVE_API_LEVEL 28 CACHE STRING "") + endif() + if(NOT DEFINED ANDROID_STL) + set(ANDROID_STL "c++_shared" CACHE STRING "") + endif() + endif() + set(QT_AUTODETECT_ANDROID ${android_detected} CACHE STRING "") + elseif (QT_AUTODETECT_ANDROID) + message(STATUS "Android build detected") + endif() +endfunction() + +function(qt_auto_detect_vcpkg) + if(QT_USE_VCPKG AND DEFINED ENV{VCPKG_ROOT}) + set(vcpkg_toolchain_file "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake") + get_filename_component(vcpkg_toolchain_file "${vcpkg_toolchain_file}" ABSOLUTE) + + if(DEFINED CMAKE_TOOLCHAIN_FILE) + get_filename_component(supplied_toolchain_file "${CMAKE_TOOLCHAIN_FILE}" ABSOLUTE) + if(NOT supplied_toolchain_file STREQUAL vcpkg_toolchain_file) + set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${supplied_toolchain_file}" CACHE STRING "") + endif() + unset(supplied_toolchain_file) + endif() + set(CMAKE_TOOLCHAIN_FILE "${vcpkg_toolchain_file}" CACHE STRING "" FORCE) + message(STATUS "Using vcpkg from $ENV{VCPKG_ROOT}") + if(DEFINED ENV{QT_VCPKG_TARGET_TRIPLET} AND NOT DEFINED VCPKG_TARGET_TRIPLET) + set(VCPKG_TARGET_TRIPLET "$ENV{QT_VCPKG_TARGET_TRIPLET}" CACHE STRING "") + message(STATUS "Using vcpkg triplet ${VCPKG_TARGET_TRIPLET}") + endif() + unset(vcpkg_toolchain_file) + message(STATUS "CMAKE_TOOLCHAIN_FILE is: ${CMAKE_TOOLCHAIN_FILE}") + if(DEFINED VCPKG_CHAINLOAD_TOOLCHAIN_FILE) + message(STATUS "VCPKG_CHAINLOAD_TOOLCHAIN_FILE is: ${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}") + endif() + endif() +endfunction() + +function(qt_auto_detect_apple) + if(NOT APPLE) + if(CMAKE_OSX_ARCHITECTURES AND NOT QT_NO_SHOW_NON_APPLE_CMAKE_OSX_ARCHITECTURES_WARNING) + message(WARNING + "CMAKE_OSX_ARCHITECTURES is set while targeting a non-Apple platform. This can " + "lead to build failures. Consider reconfiguring with the variable unset.") + endif() + return() + endif() + + if("${QT_QMAKE_TARGET_MKSPEC}" STREQUAL "macx-ios-clang") + set(CMAKE_SYSTEM_NAME "iOS" CACHE STRING "") + elseif("${QT_QMAKE_TARGET_MKSPEC}" STREQUAL "macx-visionos-clang") + set(CMAKE_SYSTEM_NAME "visionOS" CACHE STRING "") + endif() + + if(CMAKE_SYSTEM_NAME STREQUAL iOS) + message(STATUS "Using internal CMake ${CMAKE_SYSTEM_NAME} toolchain file.") + + # Pass on QT_UIKIT_SDK for compatibility + if(QT_UIKIT_SDK AND NOT QT_APPLE_SDK) + set(QT_APPLE_SDK "${QT_UIKIT_SDK}" CACHE STRING "") + endif() + + # The QT_APPLE_SDK check simulates the input.sdk condition for simulator_and_device in + # configure.json. + # If the variable is explicitly provided, assume simulator_and_device to be off. + if(QT_APPLE_SDK) + set(simulator_and_device OFF) + else() + # Default to simulator_and_device when an explicit sdk is not requested. + # Requires CMake 3.17.0+. + set(simulator_and_device ON) + endif() + + message(STATUS "simulator_and_device set to: \"${simulator_and_device}\".") + + # Choose relevant architectures. + # Using a non Xcode generator requires explicit setting of the + # architectures, otherwise compilation fails with unknown defines. + if(simulator_and_device) + set(osx_architectures "arm64;x86_64") + elseif(QT_APPLE_SDK STREQUAL "iphoneos") + set(osx_architectures "arm64") + elseif(QT_APPLE_SDK STREQUAL "iphonesimulator") + set(osx_architectures "x86_64") + else() + if(NOT DEFINED QT_APPLE_SDK) + message(FATAL_ERROR "Please provide a value for -DQT_APPLE_SDK." + " Possible values: iphoneos, iphonesimulator.") + else() + message(FATAL_ERROR + "Unknown SDK argument given to QT_APPLE_SDK: ${QT_APPLE_SDK}.") + endif() + endif() + + set(CMAKE_OSX_ARCHITECTURES "${osx_architectures}" CACHE STRING "") + endif() + + if(QT_APPLE_SDK) + set(CMAKE_OSX_SYSROOT "${QT_APPLE_SDK}" CACHE STRING "") + endif() + + if(CMAKE_SYSTEM_NAME STREQUAL iOS OR CMAKE_SYSTEM_NAME STREQUAL visionOS) + if(NOT DEFINED BUILD_SHARED_LIBS) + qt_internal_ensure_static_qt_config() + endif() + + # Disable qt rpaths for iOS, just like mkspecs/common/uikit.conf does, due to those + # bundles not being able to use paths outside the app bundle. Not sure this is strictly + # needed though. + set(QT_DISABLE_RPATH "OFF" CACHE BOOL "Disable automatic Qt rpath handling." FORCE) + endif() + + # If no CMAKE_OSX_DEPLOYMENT_TARGET is provided, default to a value that Qt defines. + # This replicates the behavior in mkspecs/common/macx.conf where + # QMAKE_MACOSX_DEPLOYMENT_TARGET is set. + set(description + "Minimum OS X version to target for deployment (at runtime); newer APIs weak linked." + " Set to empty string for default value.") + if(NOT CMAKE_OSX_DEPLOYMENT_TARGET) + if(NOT CMAKE_SYSTEM_NAME) + # macOS + set(version "${QT_SUPPORTED_MIN_MACOS_VERSION}") + elseif(CMAKE_SYSTEM_NAME STREQUAL iOS) + set(version "${QT_SUPPORTED_MIN_IOS_VERSION}") + endif() + if(version) + set(CMAKE_OSX_DEPLOYMENT_TARGET "${version}" CACHE STRING "${description}") + endif() + endif() + + _qt_internal_get_apple_sdk_version(apple_sdk_version) + set(QT_MAC_SDK_VERSION "${apple_sdk_version}" CACHE STRING "Darwin SDK version.") + + _qt_internal_get_xcode_version_raw(xcode_version_raw) + set(QT_MAC_XCODE_VERSION "${xcode_version_raw}" CACHE STRING "Xcode version.") + + if(NOT CMAKE_SYSTEM_NAME) + # macOS + list(LENGTH CMAKE_OSX_ARCHITECTURES arch_count) + if(arch_count GREATER 0) + foreach(arch ${CMAKE_OSX_ARCHITECTURES}) + if(arch STREQUAL "arm64e") + message(WARNING "Applications built against an arm64e Qt architecture will " + "likely fail to run on Apple Silicon. Consider targeting " + "'arm64' instead.") + endif() + endforeach() + endif() + + set(is_universal "OFF") + if(arch_count GREATER 1) + set(is_universal "ON") + endif() + set(QT_IS_MACOS_UNIVERSAL "${is_universal}" CACHE INTERNAL "Build universal Qt for macOS") + endif() +endfunction() + +function(qt_auto_detect_cmake_config) + # If CMAKE_CONFIGURATION_TYPES are not set for the multi-config generator use Release and + # Debug configurations by default, instead of those are proposed by the CMake internal logic. + get_property(is_multi GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(is_multi) + if(NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_CONFIGURATION_TYPES Release Debug) + set(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" PARENT_SCOPE) + endif() + + # Allow users to specify this option. + if(NOT QT_MULTI_CONFIG_FIRST_CONFIG) + list(GET CMAKE_CONFIGURATION_TYPES 0 first_config_type) + set(QT_MULTI_CONFIG_FIRST_CONFIG "${first_config_type}") + set(QT_MULTI_CONFIG_FIRST_CONFIG "${first_config_type}" PARENT_SCOPE) + endif() + + set(CMAKE_TRY_COMPILE_CONFIGURATION "${QT_MULTI_CONFIG_FIRST_CONFIG}" PARENT_SCOPE) + if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config") + # Create build-.ninja files for all specified configurations. + set(CMAKE_CROSS_CONFIGS "all" CACHE STRING "") + + # The configuration that will be considered the main one (for example when + # configuring standalone tests with a single-config generator like Ninja). + set(CMAKE_DEFAULT_BUILD_TYPE "${QT_MULTI_CONFIG_FIRST_CONFIG}" CACHE STRING "") + + # By default when ninja is called without parameters, it will build all configurations. + set(CMAKE_DEFAULT_CONFIGS "all" CACHE STRING "") + endif() + endif() +endfunction() + +function(qt_auto_detect_cyclic_toolchain) + if(CMAKE_TOOLCHAIN_FILE AND CMAKE_TOOLCHAIN_FILE MATCHES "/qt\\.toolchain\\.cmake$") + message(FATAL_ERROR + "Woah there! You can't use the Qt generated qt.toolchain.cmake file to configure " + "qtbase, because that will create a toolchain file that includes itself!\n" + "Did you accidentally use qt-cmake to configure qtbase? Make sure to remove the " + "CMakeCache.txt file, and configure qtbase with 'cmake' instead of 'qt-cmake'.") + endif() +endfunction() + +# Gets output of running 'uname -m', finding uname in path, and caching its location in QT_UNAME. +# Usually returns an architecture string like 'arch64' or 'x86_64'. +# Returns an empty string in case of an error. +# Does not pierce Rosetta, so will not always return the actual physical architecture. +# Usually that is based on the architecture of the parent process that invokes cmake. +function(qt_internal_get_uname_m_output out_var) + # This caches by default. + find_program(QT_UNAME NAMES uname PATHS /bin /usr/bin /usr/local/bin) + + execute_process(COMMAND ${QT_UNAME} -m + OUTPUT_VARIABLE output + RESULT_VARIABLE result + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_QUIET) + if(result EQUAL 0) + set(value "${output}") + else() + set(value "") + endif() + + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +# Sets out_var to TRUE if running on a host machine with an Apple silicon arm64 CPU. +# This is TRUE even when running under Rosetta, aka it pierces Rosetta, unlike the result of +# 'uname -m'. +# Same as the logic in Modules/Platform/Darwin-Initialize.cmake +# Or https://github.com/Homebrew/brew/pull/7995/files +function(qt_internal_is_apple_physical_cpu_arm64 out_var) + execute_process( + COMMAND sysctl -q hw.optional.arm64 + OUTPUT_VARIABLE sysctl_stdout + ERROR_VARIABLE sysctl_stderr + RESULT_VARIABLE sysctl_result) + + if(sysctl_result EQUAL 0 AND sysctl_stdout MATCHES "hw.optional.arm64: 1") + set(value TRUE) + else() + set(value FALSE) + endif() + + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +# Mirror CMake's logic of detecting the CMAKE_HOST_SYSTEM_PROCESSOR, including handling of Apple +# silicon, before project() is actually called. +# Honors whatever architecture Rosetta reports. +# Similar to the code in Modules/CMakeDetermineSystem.cmake +# and thus allows override via CMAKE_APPLE_SILICON_PROCESSOR. +function(qt_internal_get_early_apple_host_system_arch out_var_processor) + # If we are running on Apple Silicon, honor CMAKE_APPLE_SILICON_PROCESSOR. + if(DEFINED CMAKE_APPLE_SILICON_PROCESSOR) + set(processor "${CMAKE_APPLE_SILICON_PROCESSOR}") + elseif(DEFINED ENV{CMAKE_APPLE_SILICON_PROCESSOR}) + set(processor "$ENV{CMAKE_APPLE_SILICON_PROCESSOR}") + else() + set(processor "") + endif() + + if(processor) + # Handle case when CMAKE_APPLE_SILICON_PROCESSOR is passed on an Intel x86_64 machine, in + # that case we unset the given value, instead relying on the output of 'uname -m'. + if(";${processor};" MATCHES "^;(arm64|x86_64);$") + qt_internal_is_apple_physical_cpu_arm64(is_arm64) + if(NOT is_arm64) + set(processor "") + endif() + endif() + endif() + + if(processor) + set(output "${processor}") + else() + qt_internal_get_uname_m_output(output) + endif() + + set(${out_var_processor} "${output}" PARENT_SCOPE) +endfunction() + +# Detect whether the user intends to cross-compile to arm64 on an x86_64 macOS host, or vice versa, +# based on the passed-in CMAKE_OSX_ARCHITECTURES and the real physical host architecture. +# +# CMake doesn't handle this properly by default, unless one explicitly passes +# -DCMAKE_SYSTEM_NAME=Darwin, which people don't really know about and is somewhat unintuitive. +# +# If a cross-compilation is detected, a host Qt will be required for tools. +function(qt_auto_detect_macos_single_arch_cross_compilation) + # Skip on non-Apple platforms. + if(NOT APPLE + + # If CMAKE_SYSTEM_NAME is explicitly specified, it means CMake will implicitly + # do `set(CMAKE_CROSSCOMPILING TRUE)`, so we don't need to do anything extra. + OR CMAKE_SYSTEM_NAME OR CMAKE_CROSSCOMPILING + + # Opt out just in case this breaks something + OR QT_NO_HANDLE_APPLE_SINGLE_ARCH_CROSS_COMPILING + + # Exit early if check was previously done, so we don't need to do extra process calls. + OR QT_INTERNAL_MACOS_SINGLE_ARCH_CROSS_COMPILING_DETECTION_DONE) + return() + endif() + + list(LENGTH CMAKE_OSX_ARCHITECTURES arch_count) + + # We only consider cross-compilation the case where arch count is exactly 1. + if(NOT arch_count EQUAL 1) + return() + else() + set(target_arch "${CMAKE_OSX_ARCHITECTURES}") + endif() + + qt_internal_get_early_apple_host_system_arch(host_arch) + if(NOT "${host_arch}" STREQUAL "${target_arch}" AND + NOT ("${host_arch}" STREQUAL "x86_64" AND "${target_arch}" STREQUAL "x86_64h")) + message( + STATUS "Detected implicit macOS cross-compilation. " + "Host arch: ${host_arch} Target arch: ${target_arch}. " + "Setting CMAKE_CROSSCOMPILING to TRUE." + ) + + # Setting these tells CMake we are cross-compiling. This gets set in the correct scope + # for top-level builds as well, because it is included via + # qt_internal_top_level_setup_autodetect -> include() -> qt_internal_setup_autodetect() + # all of which are macros that don't create a new scope. + set(CMAKE_SYSTEM_NAME "Darwin" PARENT_SCOPE) + set(CMAKE_CROSSCOMPILING "TRUE" PARENT_SCOPE) + endif() + + set(QT_INTERNAL_MACOS_SINGLE_ARCH_CROSS_COMPILING_DETECTION_DONE TRUE CACHE BOOL "") +endfunction() + +function(qt_auto_detect_pch) + set(default_value "ON") + + if(CMAKE_OSX_ARCHITECTURES AND CMAKE_VERSION VERSION_LESS 3.18.0 AND NOT QT_FORCE_PCH) + list(LENGTH CMAKE_OSX_ARCHITECTURES arch_count) + # CMake versions lower than 3.18 don't support PCH when multiple architectures are set. + # This is the case for simulator_and_device builds. + if(arch_count GREATER 1) + set(default_value "OFF") + message(WARNING "PCH support disabled due to usage of multiple architectures.") + endif() + endif() + + option(BUILD_WITH_PCH "Build Qt using precompiled headers?" "${default_value}") +endfunction() + +function(qt_auto_detect_win32_arm) + if("${QT_QMAKE_TARGET_MKSPEC}" STREQUAL "win32-arm64-msvc") + set(CMAKE_SYSTEM_NAME "Windows" CACHE STRING "") + set(CMAKE_SYSTEM_VERSION "10" CACHE STRING "") + set(CMAKE_SYSTEM_PROCESSOR "arm64" CACHE STRING "") + endif() +endfunction() + +function(qt_auto_detect_linux_x86) + if("${QT_QMAKE_TARGET_MKSPEC}" STREQUAL "linux-g++-32" AND NOT QT_NO_AUTO_DETECT_LINUX_X86) + + # Add flag to ensure code is compiled for 32bit x86 ABI aka i386 or its flavors. + set(__qt_toolchain_common_flags_init "-m32") + + if(NOT QT_NO_OVERRIDE_LANG_FLAGS_INIT) + set(CMAKE_C_FLAGS_INIT "${__qt_toolchain_common_flags_init}" PARENT_SCOPE) + set(CMAKE_CXX_FLAGS_INIT "${__qt_toolchain_common_flags_init}" PARENT_SCOPE) + set(CMAKE_ASM_FLAGS_INIT "${__qt_toolchain_common_flags_init}" PARENT_SCOPE) + endif() + + # Each distro places arch-specific libraries according to its own file system layout. + # + # https://wiki.debian.org/Multiarch/TheCaseForMultiarch + # https://wiki.ubuntu.com/MultiarchSpec + # https://wiki.gentoo.org/wiki/Project:AMD64/Multilib_layout + # https://wiki.archlinux.org/title/official_repositories#multilib + # https://documentation.suse.com/sles/15-SP3/html/SLES-all/cha-64bit.html + # https://pilotlogic.com/sitejoom/index.php/wiki?id=398 + # https://unix.stackexchange.com/questions/458069/multilib-and-multiarch + # + # CMake can usually find 32 bit libraries just fine on its own. + # find_library will use prefixes from CMAKE_PREFIX_PATH / CMAKE_SYSTEM_PREFIX_PATH + # and add arch-specific lib folders like 'lib/i386-linux-gnu' on debian based systems + # or lib32/lib64 on other distros. + # The problem is that if no 32 bit library is found, a 64 bit one might get picked up. + # That's why we need to specify additional ignore paths. + # + # The paths used in the code below are Ubuntu specific. + # You can opt out of using them if you are using a different distro, but then you need to + # specify appropriate paths yourself in your own CMake toolchain file. + # + # Note that to absolutely ensure no x86_64 library is picked up on a multiarch / + # multilib-enabled system, you might need to specify extra directories in + # CMAKE_INGORE_PATH for each sub-directory containing a library. + # + # For example to exclude /usr/lib/x86_64-linux-gnu/mit-krb5/libgssapi_krb5.so + # you need to add /usr/lib/x86_64-linux-gnu/mit-krb5 explicitly to CMAKE_IGNORE_PATH. + # Adding just /usr/lib/x86_64-linux-gnu to either CMAKE_IGNORE_PATH or + # CMAKE_IGNORE_PREFIX_PATH is not enough. + # + # Another consideration are results returned by CMake's pkg_check_modules which uses + # pkg-config. + # CMAKE_IGNORE_PATH is not read by pkg_check_modules, but CMAKE_PREFIX_PATH + # values are passed as additional prefixes to look for .pc files, IN ADDITION to the default + # prefixes searched by pkg-config of each specific distro. + # For example on Ubuntu, the default searched paths on an x86_64 host are: + # /usr/local/lib/x86_64-linux-gnu/pkgconfig + # /usr/local/lib/pkgconfig + # /usr/local/share/pkgconfig + # /usr/lib/x86_64-linux-gnu/pkgconfig + # /usr/lib/pkgconfig + # /usr/share/pkgconfig + # To ensure the x86_64 packages are not picked up, the PKG_CONFIG_LIBDIR environment + # variable can be overridden with an explicit list of prefixes. + # Again, the paths below are Ubuntu specific. + if(NOT QT_NO_OVERRIDE_CMAKE_IGNORE_PATH) + set(linux_x86_ignore_path "/usr/lib/x86_64-linux-gnu;/lib/x86_64-linux-gnu") + set(CMAKE_IGNORE_PATH "${linux_x86_ignore_path}" PARENT_SCOPE) + set_property(GLOBAL PROPERTY + _qt_internal_linux_x86_ignore_path "${linux_x86_ignore_path}") + endif() + if(NOT QT_NO_OVERRIDE_PKG_CONFIG_LIBDIR) + set(pc_config_libdir "") + list(APPEND pc_config_libdir "/usr/local/lib/i386-linux-gnu/pkgconfig") + list(APPEND pc_config_libdir "/usr/local/lib/pkgconfig") + list(APPEND pc_config_libdir "/usr/local/share/pkgconfig") + list(APPEND pc_config_libdir "/usr/lib/i386-linux-gnu/pkgconfig") + list(APPEND pc_config_libdir "/usr/lib/pkgconfig") + list(APPEND pc_config_libdir "/usr/share/pkgconfig") + list(JOIN pc_config_libdir ":" pc_config_libdir) + + set_property(GLOBAL PROPERTY + _qt_internal_linux_x86_pc_config_libdir "${pc_config_libdir}") + + # Overrides the default prefix list. + set(ENV{PKG_CONFIG_LIBDIR} "${pc_config_libdir}") + + # Overrides the additional prefixes list. + set(ENV{PKG_CONFIG_DIR} "") + endif() + endif() +endfunction() + +function(qt_auto_detect_integrity) + if( + # Qt's custom CMake toolchain file sets this value. + CMAKE_SYSTEM_NAME STREQUAL "Integrity" OR + + # Upstream CMake expects this name, but we don't currently use it in Qt. + CMAKE_SYSTEM_NAME STREQUAL "GHS-MULTI" + ) + qt_internal_ensure_static_qt_config() + endif() +endfunction() + +# Save the build type before project() might set one. +# This allows us to determine if the user has set an explicit build type that we should use. +function(qt_auto_detect_cmake_build_type) + set(__qt_auto_detect_cmake_build_type_before_project_call "${CMAKE_BUILD_TYPE}" PARENT_SCOPE) +endfunction() + +macro(qt_internal_setup_autodetect) + # This needs to be here because QtAutoDetect loads before any other modules + option(QT_USE_VCPKG "Enable the use of vcpkg" OFF) + + include("${CMAKE_CURRENT_LIST_DIR}/QtPublicAppleHelpers.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/QtPublicWasmToolchainHelpers.cmake") + + # Let CMake load our custom platform modules. + # CMake-provided platform modules take precedence. + if(NOT QT_AVOID_CUSTOM_PLATFORM_MODULES) + list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/platforms") + endif() + + qt_auto_detect_cyclic_toolchain() + qt_auto_detect_cmake_config() + qt_auto_detect_apple() + qt_auto_detect_macos_single_arch_cross_compilation() + qt_auto_detect_android() + qt_auto_detect_pch() + qt_auto_detect_wasm() + qt_auto_detect_win32_arm() + qt_auto_detect_linux_x86() + qt_auto_detect_integrity() + qt_auto_detect_cmake_build_type() + qt_auto_detect_vcpkg() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAutogenHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAutogenHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6e94e07fd1a6f457b5e3b6a8629b4bc236173545 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtAutogenHelpers.cmake @@ -0,0 +1,216 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Initial autogen setup for a target to specify certain CMake properties which are common +# to all autogen tools. Also enable AUTOMOC by default. +function(qt_autogen_tools_initial_setup target) + set_property(TARGET "${target}" PROPERTY INTERFACE_QT_MAJOR_VERSION ${PROJECT_VERSION_MAJOR}) + set_property(TARGET "${target}" APPEND PROPERTY COMPATIBLE_INTERFACE_STRING QT_MAJOR_VERSION) + + set_directory_properties(PROPERTIES + QT_VERSION_MAJOR ${PROJECT_VERSION_MAJOR} + QT_VERSION_MINOR ${PROJECT_VERSION_MINOR} + QT_VERSION_PATCH ${PROJECT_VERSION_PATCH} + ) + + qt_enable_autogen_tool(${target} "moc" ON) +endfunction() + +# Enables or disables an autogen tool like moc, uic or rcc on ${target}. +function(qt_enable_autogen_tool target tool enable) + string(TOUPPER "${tool}" captitalAutogenTool) + + get_target_property(tool_enabled ${target} AUTO${captitalAutogenTool}) + get_target_property(autogen_target_depends ${target} AUTOGEN_TARGET_DEPENDS) + + if(NOT autogen_target_depends) + set(autogen_target_depends "") + endif() + set(tool_executable "$") + set(tool_target_name ${QT_CMAKE_EXPORT_NAMESPACE}::${tool}) + + if(enable) + list(APPEND autogen_target_depends ${tool_target_name}) + else() + list(REMOVE_ITEM autogen_target_depends ${tool_target_name}) + endif() + + # f66c1db16c050c9d685a44a38ad7c5cf9f6fcc96 in qtbase introduced a new macro + # that the moc scanner has to look for. Inform the CMake moc scanner about it. + if(tool STREQUAL "moc" AND enable) + set_target_properties("${target}" PROPERTIES + AUTOMOC_MACRO_NAMES "${CMAKE_AUTOMOC_MACRO_NAMES};Q_ENUM_NS;Q_GADGET_EXPORT") + if (TARGET Qt::Platform) + get_target_property(_abi_tag Qt::Platform qt_libcpp_abi_tag) + if (_abi_tag) + set_property(TARGET "${target}" APPEND PROPERTY + AUTOMOC_MOC_OPTIONS --libcpp-abi-version "${_abi_tag}" + ) + endif() + endif() + endif() + + set_target_properties("${target}" + PROPERTIES + AUTO${captitalAutogenTool} "${enable}" + AUTO${captitalAutogenTool}_EXECUTABLE "${tool_executable}" + AUTOGEN_TARGET_DEPENDS "${autogen_target_depends}" + ) +endfunction() + +# This function adds or removes additional AUTOGEN tools to a target: AUTOMOC/UIC/RCC +function(qt_autogen_tools target) + cmake_parse_arguments(PARSE_ARGV 1 arg "" "" "${__default_private_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(arg_ENABLE_AUTOGEN_TOOLS) + foreach(tool ${arg_ENABLE_AUTOGEN_TOOLS}) + qt_enable_autogen_tool(${target} ${tool} ON) + endforeach() + endif() + + if(arg_DISABLE_AUTOGEN_TOOLS) + foreach(tool ${arg_DISABLE_AUTOGEN_TOOLS}) + qt_enable_autogen_tool(${target} ${tool} OFF) + endforeach() + endif() +endfunction() + +# Complete manual moc invocation with full control. +# Use AUTOMOC whenever possible. +# Multi-value Arguments: +# INCLUDE_DIRECTORIES +# Specifies a list of include directories used by 'moc'. +# INCLUDE_DIRECTORY_TARGETS +# Specifies a list of targets to extract the INTERFACE_INCLUDE_DIRECTORIES +# property and use it as the 'moc' include directories.(Deprecated use TARGETS instead) +# DEFINITIONS +# List of the definitions that should be added to the moc command line arguments. +# Supports the syntax both with and without the prepending '-D'. +# TARGETS +# The list of targets that will be used to collect the INTERFACE_INCLUDE_DIRECTORIES, +# INCLUDE_DIRECTORIES, and COMPILE_DEFINITIONS properties. +function(qt_manual_moc result) + cmake_parse_arguments(arg + "" + "OUTPUT_MOC_JSON_FILES" + "FLAGS;INCLUDE_DIRECTORIES;INCLUDE_DIRECTORY_TARGETS;DEFINITIONS;TARGETS" + ${ARGN}) + set(moc_files) + set(metatypes_json_list) + foreach(infile ${arg_UNPARSED_ARGUMENTS}) + qt_make_output_file("${infile}" "moc_" ".cpp" + "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" outfile) + list(APPEND moc_files "${outfile}") + + set(moc_parameters_file "${outfile}_parameters$<$>:_$>") + set(moc_parameters ${arg_FLAGS} -o "${outfile}" "${infile}") + + foreach(dir IN ITEMS ${arg_INCLUDE_DIRECTORIES}) + list(APPEND moc_parameters + "-I\n${dir}") + endforeach() + + foreach(dep IN LISTS arg_INCLUDE_DIRECTORY_TARGETS arg_TARGETS) + set(include_expr "$") + list(APPEND moc_parameters + "$<$:-I\n$>") + + if(APPLE AND TARGET ${dep}) + get_target_property(is_versionless ${dep} _qt_is_versionless_target) + if(is_versionless) + string(REGEX REPLACE "^Qt::(.*)" "\\1" dep "${dep}") + set(dep "${QT_CMAKE_EXPORT_NAMESPACE}::${dep}") + endif() + + get_target_property(alias_dep ${dep} ALIASED_TARGET) + if(alias_dep) + set(dep ${alias_dep}) + endif() + + get_target_property(loc ${dep} IMPORTED_LOCATION) + string(REGEX REPLACE "(.*)/Qt[^/]+\\.framework.*" "\\1" loc "${loc}") + + if(loc) + list(APPEND moc_parameters "\n-F\n${loc}\n") + endif() + endif() + endforeach() + + foreach(dep IN LISTS arg_TARGETS) + set(include_property_expr + "$>") + list(APPEND moc_parameters + "$<$:-I\n$>") + + set(defines_property_expr + "$>") + set(defines_with_d "$") + set(defines_without_d "$") + list(APPEND moc_parameters + "$<$:$>") + list(APPEND moc_parameters + "$<$:-D\n$>") + endforeach() + + foreach(def IN LISTS arg_DEFINITIONS) + if(NOT def MATCHES "^-D") + list(APPEND moc_parameters "-D\n${def}") + else() + list(APPEND moc_parameters "${def}") + endif() + endforeach() + + set(metatypes_byproducts) + if (arg_OUTPUT_MOC_JSON_FILES) + set(moc_json_file "${outfile}.json") + list(APPEND moc_parameters --output-json) + list(APPEND metatypes_json_list "${outfile}.json") + set(metatypes_byproducts "${outfile}.json") + endif() + + if (TARGET Qt::Platform) + get_target_property(_abi_tag Qt::Platform qt_libcpp_abi_tag) + if (_abi_tag) + list(APPEND moc_parameters --libcpp-abi-version "${_abi_tag}") + endif() + endif() + + string (REPLACE ";" "\n" moc_parameters "${moc_parameters}") + + file(GENERATE OUTPUT "${moc_parameters_file}" CONTENT "${moc_parameters}\n") + + add_custom_command(OUTPUT "${outfile}" ${metatypes_byproducts} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::moc "@${moc_parameters_file}" + DEPENDS "${infile}" ${moc_depends} ${QT_CMAKE_EXPORT_NAMESPACE}::moc + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" VERBATIM) + endforeach() + set("${result}" ${moc_files} PARENT_SCOPE) + + # Register generated json files + if (arg_OUTPUT_MOC_JSON_FILES) + set(${arg_OUTPUT_MOC_JSON_FILES} "${metatypes_json_list}" PARENT_SCOPE) + endif() +endfunction() + +# From Qt6CoreMacros +# Function used to create the names of output files preserving relative dirs +function(qt_make_output_file infile prefix suffix source_dir binary_dir result) + get_filename_component(outfilename "${infile}" NAME_WE) + + set(base_dir "${source_dir}") + string(FIND "${infile}" "${binary_dir}/" in_binary) + if (in_binary EQUAL 0) + set(base_dir "${binary_dir}") + endif() + + get_filename_component(abs_infile "${infile}" ABSOLUTE BASE_DIR "${base_dir}") + file(RELATIVE_PATH rel_infile "${base_dir}" "${abs_infile}") + string(REPLACE "../" "__/" mapped_infile "${rel_infile}") + + get_filename_component(abs_mapped_infile "${mapped_infile}" ABSOLUTE BASE_DIR "${binary_dir}") + get_filename_component(outpath "${abs_mapped_infile}" PATH) + + file(MAKE_DIRECTORY "${outpath}") + set("${result}" "${outpath}/${prefix}${outfilename}${suffix}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBaseTopLevelHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBaseTopLevelHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ea6dc383af0762737decd1a3060c8672e28815c0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBaseTopLevelHelpers.cmake @@ -0,0 +1,100 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# There are three necessary copies of this macro in +# qtbase/cmake/QtBaseHelpers.cmake +# qtbase/cmake/QtBaseTopLevelHelpers.cmake +# qtbase/cmake/QtBuildRepoHelpers.cmake +macro(qt_internal_top_level_setup_standalone_parts) + # A generic marker for any kind of standalone builds, either tests or examples. + if(NOT DEFINED QT_INTERNAL_BUILD_STANDALONE_PARTS + AND (QT_BUILD_STANDALONE_TESTS OR QT_BUILD_STANDALONE_EXAMPLES)) + set(QT_INTERNAL_BUILD_STANDALONE_PARTS TRUE CACHE INTERNAL + "Whether standalone tests or examples are being built") + endif() +endmacro() + +# Depends on __qt6_qtbase_src_path being set in the top-level dir. +macro(qt_internal_top_level_setup_autodetect) + qt_internal_top_level_setup_standalone_parts() + + # Run platform auto-detection /before/ the first project() call and thus + # before the toolchain file is loaded. + # Don't run auto-detection when doing standalone tests. In that case, the detection + # results are taken from either QtBuildInternals or the qt.toolchain.cmake file. + + if(NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + set(__qt6_auto_detect_path "${__qt6_qtbase_src_path}/cmake/QtAutoDetect.cmake") + if(NOT EXISTS "${__qt6_auto_detect_path}") + message(FATAL_ERROR "Required file does not exist: '${__qt6_auto_detect_path}'") + endif() + include("${__qt6_auto_detect_path}") + endif() +endmacro() + +macro(qt_internal_top_level_setup_after_project) + qt_internal_top_level_setup_testing() +endmacro() + +macro(qt_internal_top_level_setup_testing) + # Required so we can call ctest from the root build directory + enable_testing() +endmacro() + +# Depends on __qt6_qtbase_src_path being set in the top-level dir. +macro(qt_internal_top_level_setup_cmake_module_path) + if (NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + set(__qt6_cmake_module_path "${__qt6_qtbase_src_path}/cmake") + if(NOT EXISTS "${__qt6_cmake_module_path}") + message(FATAL_ERROR "Required directory does not exist: '${__qt6_cmake_module_path}'") + endif() + + list(APPEND CMAKE_MODULE_PATH "${__qt6_cmake_module_path}") + + list(APPEND CMAKE_MODULE_PATH + "${__qt6_cmake_module_path}/3rdparty/extra-cmake-modules/find-modules") + list(APPEND CMAKE_MODULE_PATH "${__qt6_cmake_module_path}/3rdparty/kwin") + endif() +endmacro() + +macro(qt_internal_top_level_before_build_submodules) + qt_internal_top_level_setup_no_create_targets() +endmacro() + +macro(qt_internal_top_level_setup_no_create_targets) + # Also make sure the CMake config files do not recreate the already-existing targets + if (NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + set(QT_NO_CREATE_TARGETS TRUE) + endif() +endmacro() + +macro(qt_internal_top_level_end) + if(QT_BUILD_TESTS) + qt_internal_finalize_test_batch_blacklist() + endif() + + qt_internal_print_top_level_info() + + # Depends on QtBuildInternalsConfig being included, which is the case whenver any repo is + # configured. + qt_internal_qt_configure_end() +endmacro() + +function(qt_internal_print_top_level_info) + if(NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + # Display a summary of everything + include(QtBuildInformation) + include(QtPlatformSupport) + qt_print_feature_summary() + qt_print_build_instructions() + endif() +endfunction() + +macro(qt_internal_top_level_after_add_subdirectory) + if(module STREQUAL "qtbase") + if (NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + list(APPEND CMAKE_PREFIX_PATH "${QtBase_BINARY_DIR}/${INSTALL_LIBDIR}/cmake") + list(APPEND CMAKE_FIND_ROOT_PATH "${QtBase_BINARY_DIR}") + endif() + endif() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuild.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuild.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cb9576a5acdb675cc1339715952a1ab3fd21b691 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuild.cmake @@ -0,0 +1,4 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +qt_internal_setup_build_and_global_variables() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..50300a3c4f9c334b7b013586df4528df2d064399 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildHelpers.cmake @@ -0,0 +1,474 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_internal_validate_cmake_generator) + get_property(warning_shown GLOBAL PROPERTY _qt_validate_cmake_generator_warning_shown) + + if(NOT warning_shown + AND NOT CMAKE_GENERATOR MATCHES "Ninja" + AND NOT QT_SILENCE_CMAKE_GENERATOR_WARNING + AND NOT DEFINED ENV{QT_SILENCE_CMAKE_GENERATOR_WARNING}) + set_property(GLOBAL PROPERTY _qt_validate_cmake_generator_warning_shown TRUE) + message(WARNING + "The officially supported CMake generator for building Qt is " + "Ninja / Ninja Multi-Config. " + "You are using: '${CMAKE_GENERATOR}' instead. " + "Thus, you might encounter issues. Use at your own risk.") + endif() +endfunction() + +macro(qt_internal_set_qt_building_qt) + # Set the QT_BUILDING_QT variable so we can verify whether we are building + # Qt from source. + # Make sure not to set it when building a standalone test, otherwise + # upon reconfiguration we get an error about qt_internal_add_test + # not being found due the if(NOT QT_BUILDING_QT) check we have + # in each standalone test. + if(NOT QT_INTERNAL_IS_STANDALONE_TEST) + set(QT_BUILDING_QT TRUE CACHE BOOL + "When this is present and set to true, it signals that we are building Qt from source.") + endif() +endmacro() + +macro(qt_internal_unset_extra_build_internals_vars) + # Reset content of extra build internal vars for each inclusion of QtSetup. + unset(QT_EXTRA_BUILD_INTERNALS_VARS) +endmacro() + +macro(qt_internal_get_generator_is_multi_config) + # Save the global property in a variable to make it available to feature conditions. + get_property(QT_GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +endmacro() + +macro(qt_internal_setup_position_independent_code) + ## Position independent code: + set(CMAKE_POSITION_INDEPENDENT_CODE ON) + + # Does the linker support position independent code? + include(CheckPIESupported) + check_pie_supported() +endmacro() + +macro(qt_internal_set_link_depends_no_shared) + # Do not relink dependent libraries when no header has changed: + set(CMAKE_LINK_DEPENDS_NO_SHARED ON) +endmacro() + +macro(qt_internal_set_qt_source_tree_var) + # Specify the QT_SOURCE_TREE only when building qtbase. Needed by some tests when the tests are + # built as part of the project, and not standalone. For standalone tests, the value is set in + # QtBuildInternalsExtra.cmake. + if(PROJECT_NAME STREQUAL "QtBase") + set(QT_SOURCE_TREE "${QtBase_SOURCE_DIR}" CACHE PATH + "A path to the source tree of the previously configured QtBase project." FORCE) + endif() +endmacro() + +macro(qt_internal_include_qt_platform_android) + ## Android platform settings + if(ANDROID) + include(QtPlatformAndroid) + endif() +endmacro() + +macro(qt_internal_include_qt_properties) + include(QtProperties) +endmacro() + +macro(qt_internal_set_compiler_optimization_flags) + include(QtCompilerOptimization) +endmacro() + +macro(qt_internal_set_compiler_warning_flags) + include(QtCompilerFlags) +endmacro() + +macro(qt_internal_set_skip_setup_deployment) + if(NOT QT_BUILD_EXAMPLES) + # Disable deployment setup to avoid warnings about missing patchelf with CMake < 3.21. + set(QT_SKIP_SETUP_DEPLOYMENT ON) + endif() +endmacro() + +macro(qt_internal_reset_global_state) + qt_internal_clear_qt_repo_known_modules() + qt_internal_clear_qt_repo_known_plugin_types() + qt_internal_set_qt_known_plugins("") + + set(QT_KNOWN_MODULES_WITH_TOOLS "" CACHE INTERNAL "Known Qt modules with tools" FORCE) +endmacro() + +macro(qt_internal_set_qt_path_separator) + # For adjusting variables when running tests, we need to know what + # the correct variable is for separating entries in PATH-alike + # variables. + if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") + set(QT_PATH_SEPARATOR "\\;") + else() + set(QT_PATH_SEPARATOR ":") + endif() +endmacro() + +macro(qt_internal_set_internals_extra_cmake_code) + # This is used to hold extra cmake code that should be put into QtBuildInternalsExtra.cmake file + # at the QtPostProcess stage. + set(QT_BUILD_INTERNALS_EXTRA_CMAKE_CODE "") +endmacro() + +macro(qt_internal_set_top_level_source_dir) + # Save the value of the current first project source dir. + # This will be /path/to/qtbase for qtbase both in a super-build and a non super-build. + # This will be /path/to/qtbase/tests when building standalone tests. + set(QT_TOP_LEVEL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") +endmacro() + +macro(qt_internal_set_apple_archiver_flags) + # Prevent warnings about object files without any symbols. This is a common + # thing in Qt as we tend to build files unconditionally, and then use ifdefs + # to compile out parts that are not relevant. + if(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang") + foreach(lang ASM C CXX) + # We have to tell 'ar' to not run ranlib by itself, by passing the 'S' option + set(CMAKE_${lang}_ARCHIVE_CREATE " qcS ") + set(CMAKE_${lang}_ARCHIVE_APPEND " qS ") + set(CMAKE_${lang}_ARCHIVE_FINISH " -no_warning_for_no_symbols ") + endforeach() + endif() +endmacro() + +macro(qt_internal_set_apple_privacy_manifest target manifest_file) + set_target_properties(${target} PROPERTIES _qt_privacy_manifest "${manifest_file}") +endmacro() + +macro(qt_internal_set_debug_extend_target) + option(QT_CMAKE_DEBUG_EXTEND_TARGET "Debug extend_target calls in Qt's build system" OFF) +endmacro() + +# These upstream CMake modules will be automatically include()'d when doing +# find_package(Qt6 COMPONENTS BuildInternals). +function(qt_internal_get_qt_build_upstream_cmake_modules out_var) + set(${out_var} + CMakeFindBinUtils + CMakePackageConfigHelpers + CheckCXXSourceCompiles + FeatureSummary + PARENT_SCOPE + ) +endfunction() + +# These helpers will be installed when building qtbase, and they will be automatically include()'d +# when doing find_package(Qt6 COMPONENTS BuildInternals). +# The helpers are expected to exist under the qtbase/cmake sub-directory and their file name +# extension should be '.cmake'. +function(qt_internal_get_qt_build_private_helpers out_var) + set(${out_var} + Qt3rdPartyLibraryHelpers + QtAndroidHelpers + QtAppHelpers + QtAutoDetectHelpers + QtAutogenHelpers + QtBuildInformation + QtBuildOptionsHelpers + QtBuildPathsHelpers + QtBuildRepoExamplesHelpers + QtBuildRepoHelpers + QtCMakeHelpers + QtCMakeVersionHelpers + QtDbusHelpers + QtDeferredDependenciesHelpers + QtDocsHelpers + QtExecutableHelpers + QtFindPackageHelpers + QtFlagHandlingHelpers + QtFrameworkHelpers + QtGlobalStateHelpers + QtHeadersClean + QtInstallHelpers + QtJavaHelpers + QtLalrHelpers + QtMkspecHelpers + QtModuleHelpers + QtNoLinkTargetHelpers + QtPkgConfigHelpers + QtPlatformTargetHelpers + QtPluginHelpers + QtPostProcessHelpers + QtPrecompiledHeadersHelpers + QtPriHelpers + QtPrlHelpers + QtProperties + QtQmakeHelpers + QtResourceHelpers + QtRpathHelpers + QtSanitizerHelpers + QtSbomHelpers + QtScopeFinalizerHelpers + QtSeparateDebugInfo + QtSimdHelpers + QtSingleRepoTargetSetBuildHelpers + QtSyncQtHelpers + QtTargetHelpers + QtTestHelpers + QtToolHelpers + QtToolchainHelpers + QtUnityBuildHelpers + QtWasmHelpers + QtWrapperScriptHelpers + PARENT_SCOPE + ) +endfunction() + +# These files will be installed when building qtbase, but will NOT be automatically include()d +# when doing find_package(Qt6 COMPONENTS BuildInternals). +# The files are expected to exist under the qtbase/cmake sub-directory. +function(qt_internal_get_qt_build_private_files_to_install out_var) + set(${out_var} + ModuleDescription.json.in + PkgConfigLibrary.pc.in + Qt3rdPartyLibraryConfig.cmake.in + QtBaseTopLevelHelpers.cmake + QtBuild.cmake + QtBuildHelpers.cmake + QtBuildStaticDocToolsScript.cmake + QtCMakePackageVersionFile.cmake.in + QtCompilerFlags.cmake + QtCompilerOptimization.cmake + QtConfigDependencies.cmake.in + QtConfigureTimeExecutableCMakeLists.txt.in + QtFileConfigure.txt.in + QtFindWrapConfigExtra.cmake.in + QtFindWrapHelper.cmake + QtFinishPkgConfigFile.cmake + QtFinishPrlFile.cmake + QtGenerateExtPri.cmake + QtGenerateLibHelpers.cmake + QtGenerateLibPri.cmake + QtGenerateVersionScript.cmake + QtModuleConfig.cmake.in + QtModuleDependencies.cmake.in + QtModuleHeadersCheck.cmake + QtModuleToolsConfig.cmake.in + QtModuleToolsDependencies.cmake.in + QtModuleToolsVersionlessTargets.cmake.in + QtPlatformAndroid.cmake + QtPlatformSupport.cmake + QtPluginConfig.cmake.in + QtPluginDependencies.cmake.in + QtPlugins.cmake.in + QtPostProcess.cmake + QtProcessConfigureArgs.cmake + QtSeparateDebugInfo.Info.plist.in + QtSetup.cmake + QtStandaloneTestsConfig.cmake.in + QtVersionlessAliasTargets.cmake.in + QtVersionlessTargets.cmake.in + QtWriteArgsFile.cmake + modulecppexports.h.in + qbatchedtestrunner.in.cpp + PARENT_SCOPE + ) +endfunction() + +# These helpers will be installed when building qtbase, and they will be automatically include()'d +# when doing find_package(Qt6 COMPONENTS BuildInternals). +# The helpers are expected to exist under the qtbase/cmake sub-directory and their file name +# extension should be '.cmake'. +# In addition, they are meant to be included when doing find_package(Qt6) as well. +function(qt_internal_get_qt_build_public_helpers out_var) + set(${out_var} + QtFeature + QtFeatureCommon + QtPublicAppleHelpers + QtPublicCMakeHelpers + QtPublicCMakeVersionHelpers + QtPublicDependencyHelpers + QtPublicExternalProjectHelpers + QtPublicFinalizerHelpers + QtPublicFindPackageHelpers + QtPublicGitHelpers + QtPublicPluginHelpers + QtPublicSbomGenerationHelpers + QtPublicSbomHelpers + QtPublicTargetHelpers + QtPublicTestHelpers + QtPublicToolHelpers + QtPublicWalkLibsHelpers + PARENT_SCOPE + ) +endfunction() + +# These files will be installed when building qtbase, but will NOT be automatically include()d +# when doing find_package(Qt6) nor find_package(Qt6 COMPONENTS BuildInternals). +# The files are expected to exist under the qtbase/cmake sub-directory. +function(qt_internal_get_qt_build_public_files_to_install out_var) + set(${out_var} + QtCopyFileIfDifferent.cmake + QtInitProject.cmake + + # Public CMake files that are installed next Qt6Config.cmake, but are NOT included by it. + # Instead they are included by the generated CMake toolchain file. + QtPublicWasmToolchainHelpers.cmake + + PARENT_SCOPE + ) +endfunction() + +# Includes all Qt CMake helper files that define functions and macros. +macro(qt_internal_include_all_helpers) + # Upstream cmake modules. + qt_internal_get_qt_build_upstream_cmake_modules(__qt_upstream_helpers) + foreach(__qt_file_name IN LISTS __qt_upstream_helpers) + include("${__qt_file_name}") + endforeach() + + # Internal helpers available only while building Qt itself. + qt_internal_get_qt_build_private_helpers(__qt_private_helpers) + foreach(__qt_file_name IN LISTS __qt_private_helpers) + include("${__qt_file_name}") + endforeach() + + # Helpers that are available in public projects and while building Qt itself. + qt_internal_get_qt_build_public_helpers(__qt_public_helpers) + foreach(__qt_file_name IN LISTS __qt_public_helpers) + include("${__qt_file_name}") + endforeach() +endmacro() + +function(qt_internal_check_host_path_set_for_cross_compiling) + if(CMAKE_CROSSCOMPILING) + if(NOT IS_DIRECTORY "${QT_HOST_PATH}") + message(FATAL_ERROR "You need to set QT_HOST_PATH to cross compile Qt.") + endif() + endif() +endfunction() + +macro(qt_internal_setup_find_host_info_package) + _qt_internal_determine_if_host_info_package_needed(__qt_build_requires_host_info_package) + _qt_internal_find_host_info_package("${__qt_build_requires_host_info_package}") +endmacro() + +macro(qt_internal_setup_poor_mans_scope_finalizer) + # This sets up the poor man's scope finalizer mechanism. + # For newer CMake versions, we use cmake_language(DEFER CALL) instead. + if(CMAKE_VERSION VERSION_LESS "3.19.0") + variable_watch(CMAKE_CURRENT_LIST_DIR qt_watch_current_list_dir) + endif() +endmacro() + +macro(qt_internal_set_qt_namespace) + set(QT_NAMESPACE "" CACHE STRING "Qt Namespace") +endmacro() + +macro(qt_internal_set_qt_coord_type) + if(PROJECT_NAME STREQUAL "QtBase") + set(QT_COORD_TYPE double CACHE STRING "Type of qreal") + endif() +endmacro() + +function(qt_internal_check_macos_host_version) + # macOS versions 10.14 and less don't have the implementation of std::filesystem API. + if(CMAKE_HOST_APPLE AND CMAKE_HOST_SYSTEM_VERSION VERSION_LESS "19.0.0") + message(FATAL_ERROR "macOS versions less than 10.15 are not supported for building Qt.") + endif() +endfunction() + +function(qt_internal_setup_tool_path_command) + if(NOT CMAKE_HOST_WIN32) + return() + endif() + set(bindir "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_BINDIR}") + file(TO_NATIVE_PATH "${bindir}" bindir) + list(APPEND command COMMAND) + list(APPEND command set PATH=${bindir}$%PATH%) + set(QT_TOOL_PATH_SETUP_COMMAND "${command}" CACHE INTERNAL + "internal command prefix for tool invocations" FORCE) + # QT_TOOL_PATH_SETUP_COMMAND is deprecated. Please use _qt_internal_get_wrap_tool_script_path + # instead. +endfunction() + +macro(qt_internal_setup_android_platform_specifics) + if(ANDROID) + qt_internal_setup_android_target_properties() + endif() +endmacro() + +macro(qt_internal_setup_build_and_global_variables) + qt_internal_validate_cmake_generator() + qt_internal_set_qt_building_qt() + qt_internal_set_cmake_build_type() + qt_internal_set_message_log_level(CMAKE_MESSAGE_LOG_LEVEL) + qt_internal_unset_extra_build_internals_vars() + qt_internal_get_generator_is_multi_config() + + # Depends on qt_internal_set_cmake_build_type + qt_internal_setup_cmake_config_postfix() + + qt_internal_setup_position_independent_code() + qt_internal_set_link_depends_no_shared() + qt_internal_setup_default_install_prefix() + qt_internal_set_qt_source_tree_var() + qt_internal_set_export_compile_commands() + qt_internal_set_configure_from_ide() + + # Depends on qt_internal_set_configure_from_ide + qt_internal_set_sync_headers_at_configure_time() + + qt_internal_setup_build_benchmarks() + + # Depends on qt_internal_setup_build_benchmarks + qt_internal_setup_build_tests() + + qt_internal_setup_build_tools() + + qt_internal_setup_sbom() + + # Depends on qt_internal_setup_default_install_prefix + qt_internal_setup_build_examples() + + qt_internal_set_qt_host_path() + + qt_internal_setup_build_docs() + + qt_internal_include_qt_platform_android() + + qt_internal_include_qt_properties() + + # Depends on qt_internal_setup_default_install_prefix + qt_internal_setup_paths_and_prefixes() + + qt_internal_reset_global_state() + + # Depends on qt_internal_setup_paths_and_prefixes + qt_internal_set_mkspecs_dir() + qt_internal_setup_platform_definitions_and_mkspec() + + qt_internal_check_macos_host_version() + _qt_internal_check_apple_sdk_and_xcode_versions() + qt_internal_check_host_path_set_for_cross_compiling() + qt_internal_setup_android_platform_specifics() + qt_internal_setup_find_host_info_package() + qt_internal_setup_tool_path_command() + qt_internal_setup_default_target_function_options() + qt_internal_set_default_rpath_settings() + qt_internal_set_qt_namespace() + qt_internal_set_qt_coord_type() + qt_internal_set_qt_path_separator() + qt_internal_set_internals_extra_cmake_code() + qt_internal_set_top_level_source_dir() + qt_internal_set_apple_archiver_flags() + qt_internal_set_debug_extend_target() + qt_internal_setup_poor_mans_scope_finalizer() + + qt_internal_set_compiler_optimization_flags() + qt_internal_set_compiler_warning_flags() + + qt_set_language_standards() + qt_internal_set_use_ccache() + qt_internal_set_unity_build() + qt_internal_set_allow_symlink_in_paths() + qt_internal_set_skip_setup_deployment() + qt_internal_set_qt_allow_download() + + qt_internal_detect_dirty_features() +endmacro() + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildInformation.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8c0ce66a1b3078b8683da143723cd842c08e4930 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildInformation.cmake @@ -0,0 +1,582 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_internal_set_message_log_level out_var) + # Decide whether output should be verbose or not. + # Default to verbose (--log-level=STATUS) in a developer-build and + # non-verbose (--log-level=NOTICE) otherwise. + # If a custom CMAKE_MESSAGE_LOG_LEVEL was specified, it takes priority. + # Passing an explicit --log-level=Foo has the highest priority. + if(NOT CMAKE_MESSAGE_LOG_LEVEL) + if(FEATURE_developer_build OR QT_FEATURE_developer_build) + set(CMAKE_MESSAGE_LOG_LEVEL "STATUS") + else() + set(CMAKE_MESSAGE_LOG_LEVEL "NOTICE") + endif() + set(${out_var} "${CMAKE_MESSAGE_LOG_LEVEL}" PARENT_SCOPE) + endif() +endfunction() + +function(qt_print_feature_summary) + if(QT_SUPERBUILD) + qt_internal_set_message_log_level(message_log_level) + if(message_log_level) + # In a top-level build, ensure that the feature_summary is affected by the + # selected log-level. + set(CMAKE_MESSAGE_LOG_LEVEL "${message_log_level}") + endif() + endif() + + # Show which packages were found. + feature_summary(INCLUDE_QUIET_PACKAGES + WHAT PACKAGES_FOUND + REQUIRED_PACKAGES_NOT_FOUND + RECOMMENDED_PACKAGES_NOT_FOUND + OPTIONAL_PACKAGES_NOT_FOUND + RUNTIME_PACKAGES_NOT_FOUND + FATAL_ON_MISSING_REQUIRED_PACKAGES) + qt_internal_run_additional_summary_checks() + qt_configure_print_summary() +endfunction() + +function(qt_internal_run_additional_summary_checks) + get_property( + rpath_workaround_enabled + GLOBAL PROPERTY _qt_internal_staging_prefix_build_rpath_workaround) + if(rpath_workaround_enabled) + set(message + "Due to CMAKE_STAGING_PREFIX usage and an unfixed CMake bug, + to ensure correct build time rpaths, directory-level install + rules like ninja src/gui/install will not work. + Check QTBUG-102592 for further details.") + qt_configure_add_report_entry( + TYPE NOTE + MESSAGE "${message}" + ) + endif() +endfunction() + +function(qt_print_build_instructions) + if((NOT PROJECT_NAME STREQUAL "QtBase" AND + NOT PROJECT_NAME STREQUAL "Qt") OR QT_INTERNAL_BUILD_STANDALONE_PARTS) + + return() + endif() + + if(QT_SUPERBUILD) + qt_internal_set_message_log_level(message_log_level) + if(message_log_level) + # In a top-level build, ensure that qt_print_build_instructions is affected by the + # selected log-level. + set(CMAKE_MESSAGE_LOG_LEVEL "${message_log_level}") + endif() + endif() + + set(build_command "cmake --build . --parallel") + set(install_command "cmake --install .") + + # Suggest "ninja install" for Multi-Config builds + # until https://gitlab.kitware.com/cmake/cmake/-/issues/21475 is fixed. + if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config") + set(install_command "ninja install") + endif() + + set(configure_module_command "qt-configure-module") + if(CMAKE_HOST_WIN32) + string(APPEND configure_module_command ".bat") + endif() + if("${CMAKE_STAGING_PREFIX}" STREQUAL "") + set(local_install_prefix "${CMAKE_INSTALL_PREFIX}") + else() + set(local_install_prefix "${CMAKE_STAGING_PREFIX}") + endif() + + set(msg "\n") + + list(APPEND msg "Qt is now configured for building. Just run '${build_command}'\n") + if(QT_WILL_INSTALL) + list(APPEND msg "Once everything is built, you must run '${install_command}'") + list(APPEND msg "Qt will be installed into '${CMAKE_INSTALL_PREFIX}'") + else() + list(APPEND msg + "Once everything is built, Qt is installed. You should NOT run '${install_command}'") + list(APPEND msg + "Note that this build cannot be deployed to other machines or devices.") + endif() + list(APPEND msg + "\nTo configure and build other Qt modules, you can use the following convenience script: + ${local_install_prefix}/${INSTALL_BINDIR}/${configure_module_command}") + list(APPEND msg "\nIf reconfiguration fails for some reason, try removing 'CMakeCache.txt' \ +from the build directory") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24") + list(APPEND msg "Alternatively, you can add the --fresh flag to your CMake flags.\n") + else() + list(APPEND msg "\n") + endif() + + list(JOIN msg "\n" msg) + + if(NOT QT_INTERNAL_BUILD_INSTRUCTIONS_SHOWN) + qt_configure_print_build_instructions_helper("${msg}") + endif() + + set(QT_INTERNAL_BUILD_INSTRUCTIONS_SHOWN "TRUE" CACHE STRING "" FORCE) + + if(QT_SUPERBUILD) + qt_internal_save_previously_visited_packages() + endif() +endfunction() + +function(qt_configure_print_summary_helper summary_reports force_show) + # We force show the summary by temporarily (within the scope of the function) resetting the + # current log level. + if(force_show) + set(CMAKE_MESSAGE_LOG_LEVEL "STATUS") + + # Need 2 flushes to ensure no interleaved input is printed due to a mix of message(STATUS) + # and message(NOTICE) calls. + execute_process(COMMAND ${CMAKE_COMMAND} -E echo " ") + + message(STATUS "Configure summary:\n${summary_reports}") + + execute_process(COMMAND ${CMAKE_COMMAND} -E echo " ") + endif() +endfunction() + +function(qt_configure_print_build_instructions_helper msg) + # We want to ensure build instructions are always shown the first time, regardless of the + # current log level. + set(CMAKE_MESSAGE_LOG_LEVEL "STATUS") + message(STATUS "${msg}") +endfunction() + +function(qt_configure_print_summary) + # Evaluate all recorded commands. + qt_configure_eval_commands() + + set(summary_file "${CMAKE_BINARY_DIR}/config.summary") + file(WRITE "${summary_file}" "") + + get_property(features_possibly_changed GLOBAL PROPERTY _qt_dirty_build) + + # Show Qt-specific configuration summary. + if(__qt_configure_reports) + # The summary will only be printed for log level STATUS or above. + # Check whether the log level is sufficient for printing the summary. + set(log_level_sufficient_for_printed_summary TRUE) + if(CMAKE_VERSION GREATER_EQUAL "3.25") + cmake_language(GET_MESSAGE_LOG_LEVEL log_level) + set(sufficient_log_levels STATUS VERBOSE DEBUG TRACE) + if(NOT log_level IN_LIST sufficient_log_levels) + set(log_level_sufficient_for_printed_summary FALSE) + endif() + endif() + + # We want to show the configuration summary file and log level message only on + # first configuration or when we detect a feature change, to keep most + # reconfiguration output as quiet as possible. + # Currently feature change detection is not entirely reliable. + if(log_level_sufficient_for_printed_summary + AND (NOT QT_INTERNAL_SUMMARY_INSTRUCTIONS_SHOWN OR features_possibly_changed)) + set(force_show_summary TRUE) + message( + "\n" + "-- Configuration summary shown below. It has also been written to" + " ${CMAKE_BINARY_DIR}/config.summary") + message( + "-- Configure with --log-level=STATUS or higher to increase " + "CMake's message verbosity. " + "The log level does not persist across reconfigurations.") + else() + set(force_show_summary FALSE) + message( + "\n" + "-- Configuration summary has been written to" + " ${CMAKE_BINARY_DIR}/config.summary") + endif() + + qt_configure_print_summary_helper( + "${__qt_configure_reports}" + ${force_show_summary}) + + file(APPEND "${summary_file}" "${__qt_configure_reports}") + endif() + + # Show Qt specific notes, warnings, errors. + if(__qt_configure_notes) + message("${__qt_configure_notes}") + file(APPEND "${summary_file}" "${__qt_configure_notes}") + endif() + if(__qt_configure_warnings) + message("${__qt_configure_warnings}") + file(APPEND "${summary_file}" "${__qt_configure_warnings}") + endif() + if(__qt_configure_errors) + message("${__qt_configure_errors}") + file(APPEND "${summary_file}" "${__qt_configure_errors}") + endif() + message("") + if(__qt_configure_an_error_occurred) + message(FATAL_ERROR "Check the configuration messages for an error that has occurred.") + endif() + file(APPEND "${summary_file}" "\n") + set(QT_INTERNAL_SUMMARY_INSTRUCTIONS_SHOWN "TRUE" CACHE STRING "" FORCE) +endfunction() + +# Takes a list of arguments, and saves them to be evaluated at the end of the configuration +# phase when the configuration summary is shown. +# +# RECORD_ON_FEATURE_EVALUATION option allows to record the command even while the feature +# evaluation-only stage. +function(qt_configure_record_command) + cmake_parse_arguments(arg "RECORD_ON_FEATURE_EVALUATION" + "" + "" ${ARGV}) + # Don't record commands when only evaluating features of a configure.cmake file. + if(__QtFeature_only_evaluate_features AND NOT arg_RECORD_ON_FEATURE_EVALUATION) + return() + endif() + + get_property(command_count GLOBAL PROPERTY qt_configure_command_count) + + if(NOT DEFINED command_count) + set(command_count 0) + endif() + + set_property(GLOBAL PROPERTY qt_configure_command_${command_count} "${arg_UNPARSED_ARGUMENTS}") + + math(EXPR command_count "${command_count}+1") + set_property(GLOBAL PROPERTY qt_configure_command_count "${command_count}") +endfunction() + +function(qt_configure_eval_commands) + get_property(command_count GLOBAL PROPERTY qt_configure_command_count) + if(NOT command_count) + set(command_count 0) + endif() + set(command_index 0) + + while(command_index LESS command_count) + get_property(command_args GLOBAL PROPERTY qt_configure_command_${command_index}) + if(NOT command_args) + message(FATAL_ERROR + "Empty arguments encountered while processing qt configure reports.") + endif() + + list(POP_FRONT command_args command_name) + if(command_name STREQUAL ADD_SUMMARY_SECTION) + qt_configure_process_add_summary_section(${command_args}) + elseif(command_name STREQUAL END_SUMMARY_SECTION) + qt_configure_process_end_summary_section(${command_args}) + elseif(command_name STREQUAL ADD_REPORT_ENTRY) + qt_configure_process_add_report_entry(${command_args}) + elseif(command_name STREQUAL ADD_SUMMARY_ENTRY) + qt_configure_process_add_summary_entry(${command_args}) + elseif(command_name STREQUAL ADD_BUILD_TYPE_AND_CONFIG) + qt_configure_process_add_summary_build_type_and_config(${command_args}) + elseif(command_name STREQUAL ADD_BUILD_MODE) + qt_configure_process_add_summary_build_mode(${command_args}) + elseif(command_name STREQUAL ADD_BUILD_PARTS) + qt_configure_process_add_summary_build_parts(${command_args}) + endif() + + math(EXPR command_index "${command_index}+1") + endwhile() + + # Propagate content to parent. + set(__qt_configure_reports "${__qt_configure_reports}" PARENT_SCOPE) + set(__qt_configure_notes "${__qt_configure_notes}" PARENT_SCOPE) + set(__qt_configure_warnings "${__qt_configure_warnings}" PARENT_SCOPE) + set(__qt_configure_errors "${__qt_configure_errors}" PARENT_SCOPE) + set(__qt_configure_an_error_occurred "${__qt_configure_an_error_occurred}" PARENT_SCOPE) +endfunction() + +macro(qt_configure_add_report message) + string(APPEND __qt_configure_reports "\n${message}") + set(__qt_configure_reports "${__qt_configure_reports}" PARENT_SCOPE) +endmacro() + +macro(qt_configure_add_report_padded label message) + qt_configure_get_padded_string("${__qt_configure_indent}${label}" "${message}" padded_message) + string(APPEND __qt_configure_reports "\n${padded_message}") + set(__qt_configure_reports "${__qt_configure_reports}" PARENT_SCOPE) +endmacro() + +# Pad 'label' and 'value' with dots like this: +# "label ............... value" +# +# PADDING_LENGTH specifies the number of characters from the start to the last dot. +# Default is 30. +# MIN_PADDING specifies the minimum number of dots that are used for the padding. +# Default is 0. +function(qt_configure_get_padded_string label value out_var) + cmake_parse_arguments(arg "" "PADDING_LENGTH;MIN_PADDING" "" ${ARGN}) + if("${arg_MIN_PADDING}" STREQUAL "") + set(arg_MIN_PADDING 0) + endif() + if(arg_PADDING_LENGTH) + set(pad_string "") + math(EXPR n "${arg_PADDING_LENGTH} - 1") + foreach(i RANGE ${n}) + string(APPEND pad_string ".") + endforeach() + else() + set(pad_string ".........................................") + endif() + string(LENGTH "${label}" label_len) + string(LENGTH "${pad_string}" pad_len) + math(EXPR pad_len "${pad_len}-${label_len}") + if(pad_len LESS "0") + set(pad_len ${arg_MIN_PADDING}) + endif() + string(SUBSTRING "${pad_string}" 0 "${pad_len}" pad_string) + set(output "${label} ${pad_string} ${value}") + set("${out_var}" "${output}" PARENT_SCOPE) +endfunction() + +function(qt_configure_add_summary_entry) + qt_configure_record_command(ADD_SUMMARY_ENTRY ${ARGV}) +endfunction() + +function(qt_configure_process_add_summary_entry) + cmake_parse_arguments(PARSE_ARGV 0 arg + "" + "ARGS;TYPE;MESSAGE" + "CONDITION") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_TYPE) + set(arg_TYPE "feature") + endif() + + if(NOT "${arg_CONDITION}" STREQUAL "") + qt_evaluate_config_expression(condition_result ${arg_CONDITION}) + if(NOT condition_result) + return() + endif() + endif() + + if(arg_TYPE STREQUAL "firstAvailableFeature") + set(first_feature_found FALSE) + set(message "") + string(REPLACE " " ";" args_list "${arg_ARGS}") + foreach(feature ${args_list}) + qt_feature_normalize_name("${feature}" feature) + if(NOT DEFINED QT_FEATURE_${feature}) + message(FATAL_ERROR "Asking for a report on undefined feature ${feature}.") + endif() + if(QT_FEATURE_${feature}) + set(first_feature_found TRUE) + set(message "${QT_FEATURE_LABEL_${feature}}") + break() + endif() + endforeach() + + if(NOT first_feature_found) + set(message "") + endif() + qt_configure_add_report_padded("${arg_MESSAGE}" "${message}") + elseif(arg_TYPE STREQUAL "featureList") + set(available_features "") + string(REPLACE " " ";" args_list "${arg_ARGS}") + + foreach(feature ${args_list}) + qt_feature_normalize_name("${feature}" feature) + if(NOT DEFINED QT_FEATURE_${feature}) + message(FATAL_ERROR "Asking for a report on undefined feature ${feature}.") + endif() + if(QT_FEATURE_${feature}) + list(APPEND available_features "${QT_FEATURE_LABEL_${feature}}") + endif() + endforeach() + + if(NOT available_features) + set(message "") + else() + list(JOIN available_features " " message) + endif() + qt_configure_add_report_padded("${arg_MESSAGE}" "${message}") + elseif(arg_TYPE STREQUAL "feature") + qt_feature_normalize_name("${arg_ARGS}" feature) + + set(label "${QT_FEATURE_LABEL_${feature}}") + + if(NOT label) + set(label "${feature}") + endif() + + if(QT_FEATURE_${feature}) + set(value "yes") + else() + set(value "no") + endif() + + qt_configure_add_report_padded("${label}" "${value}") + elseif(arg_TYPE STREQUAL "message") + qt_configure_add_report_padded("${arg_ARGS}" "${arg_MESSAGE}") + endif() +endfunction() + +function(qt_configure_add_summary_build_type_and_config) + qt_configure_record_command(ADD_BUILD_TYPE_AND_CONFIG ${ARGV}) +endfunction() + +function(qt_configure_process_add_summary_build_type_and_config) + get_property(subarch_summary GLOBAL PROPERTY qt_configure_subarch_summary) + if(APPLE AND (CMAKE_OSX_ARCHITECTURES MATCHES ";")) + set(message + "Building for: ${QT_QMAKE_TARGET_MKSPEC} (${CMAKE_OSX_ARCHITECTURES}), ${TEST_architecture_arch} features: ${subarch_summary})") + else() + set(message + "Building for: ${QT_QMAKE_TARGET_MKSPEC} (${TEST_architecture_arch}, CPU features: ${subarch_summary})") + endif() + qt_configure_add_report("${message}") + + set(message "Compiler: ") + if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang") + string(APPEND message "clang (Apple)") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM") + string(APPEND message "clang (Intel LLVM)") + elseif(CLANG) + string(APPEND message "clang") + elseif(QCC) + string(APPEND message "rim_qcc") + elseif(GCC) + string(APPEND message "gcc") + elseif(MSVC) + string(APPEND message "msvc") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GHS") + string(APPEND message "ghs") + else() + string(APPEND message "unknown (${CMAKE_CXX_COMPILER_ID})") + endif() + string(APPEND message " ${CMAKE_CXX_COMPILER_VERSION}") + qt_configure_add_report("${message}") +endfunction() + +function(qt_configure_add_summary_build_mode) + qt_configure_record_command(ADD_BUILD_MODE ${ARGV}) +endfunction() + +function(qt_configure_process_add_summary_build_mode label) + set(message "") + if(DEFINED CMAKE_BUILD_TYPE) + if(CMAKE_BUILD_TYPE STREQUAL "Debug") + string(APPEND message "debug") + elseif(CMAKE_BUILD_TYPE STREQUAL "Release") + string(APPEND message "release") + elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo") + string(APPEND message "release (with debug info)") + else() + string(APPEND message "${CMAKE_BUILD_TYPE}") + endif() + elseif(DEFINED CMAKE_CONFIGURATION_TYPES) + if("Release" IN_LIST CMAKE_CONFIGURATION_TYPES + AND "Debug" IN_LIST CMAKE_CONFIGURATION_TYPES) + string(APPEND message "debug and release") + elseif("RelWithDebInfo" IN_LIST CMAKE_CONFIGURATION_TYPES + AND "Debug" IN_LIST CMAKE_CONFIGURATION_TYPES) + string(APPEND message "debug and release (with debug info)") + else() + string(APPEND message "${CMAKE_CONFIGURATION_TYPES}") + endif() + endif() + + qt_configure_add_report_padded("${label}" "${message}") +endfunction() + +function(qt_configure_add_summary_build_parts) + qt_configure_record_command(ADD_BUILD_PARTS ${ARGV}) +endfunction() + +function(qt_configure_process_add_summary_build_parts label) + qt_get_build_parts(parts) + string(REPLACE ";" " " message "${parts}") + qt_configure_add_report_padded("${label}" "${message}") +endfunction() + +function(qt_configure_add_summary_section) + qt_configure_record_command(ADD_SUMMARY_SECTION ${ARGV}) +endfunction() + +function(qt_configure_process_add_summary_section) + cmake_parse_arguments(PARSE_ARGV 0 arg + "" + "NAME" + "") + _qt_internal_validate_all_args_are_parsed(arg) + + qt_configure_add_report("${__qt_configure_indent}${arg_NAME}:") + if(NOT DEFINED __qt_configure_indent) + set(__qt_configure_indent " " PARENT_SCOPE) + else() + set(__qt_configure_indent "${__qt_configure_indent} " PARENT_SCOPE) + endif() +endfunction() + +function(qt_configure_end_summary_section) + qt_configure_record_command(END_SUMMARY_SECTION ${ARGV}) +endfunction() + +function(qt_configure_process_end_summary_section) + string(LENGTH "${__qt_configure_indent}" indent_len) + if(indent_len GREATER_EQUAL 2) + string(SUBSTRING "${__qt_configure_indent}" 2 -1 __qt_configure_indent) + set(__qt_configure_indent "${__qt_configure_indent}" PARENT_SCOPE) + endif() +endfunction() + +function(qt_configure_add_report_entry) + qt_configure_record_command(ADD_REPORT_ENTRY ${ARGV}) +endfunction() + +function(qt_configure_add_report_error error) + message(SEND_ERROR "${error}") + qt_configure_add_report_entry(TYPE ERROR MESSAGE "${error}" CONDITION TRUE ${ARGN}) +endfunction() + +function(qt_configure_process_add_report_entry) + cmake_parse_arguments(PARSE_ARGV 0 arg + "" + "TYPE;MESSAGE" + "CONDITION") + _qt_internal_validate_all_args_are_parsed(arg) + + set(possible_types NOTE WARNING ERROR FATAL_ERROR) + if(NOT "${arg_TYPE}" IN_LIST possible_types) + message(FATAL_ERROR "qt_configure_add_report_entry: '${arg_TYPE}' is not a valid type.") + endif() + + if(NOT arg_MESSAGE) + message(FATAL_ERROR "qt_configure_add_report_entry: Empty message given.") + endif() + + if(arg_TYPE STREQUAL "NOTE") + set(contents_var "__qt_configure_notes") + set(prefix "Note: ") + elseif(arg_TYPE STREQUAL "WARNING") + set(contents_var "__qt_configure_warnings") + set(prefix "WARNING: ") + elseif(arg_TYPE STREQUAL "ERROR") + set(contents_var "__qt_configure_errors") + set(prefix "ERROR: ") + elseif(arg_TYPE STREQUAL "FATAL_ERROR") + set(contents_var "__qt_configure_errors") + set(prefix "FATAL ERROR: ") + endif() + + if(NOT "${arg_CONDITION}" STREQUAL "") + qt_evaluate_config_expression(condition_result ${arg_CONDITION}) + endif() + + if("${arg_CONDITION}" STREQUAL "" OR condition_result) + set(new_report "${prefix}${arg_MESSAGE}") + string(APPEND "${contents_var}" "\n${new_report}") + + if(arg_TYPE STREQUAL "ERROR" OR arg_TYPE STREQUAL "FATAL_ERROR") + set(__qt_configure_an_error_occurred "TRUE" PARENT_SCOPE) + endif() + endif() + + set("${contents_var}" "${${contents_var}}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildOptionsHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildOptionsHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e39b647ed5a8fa9259215b82b676c6bd1d586e88 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildOptionsHelpers.cmake @@ -0,0 +1,444 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Try to detect if CMAKE_BUILD_TYPE is default initialized by CMake, or it was set by the user. +# +# CMake initializes CMAKE_BUILD_TYPE to the value of CMAKE_BUILD_TYPE_INIT during the first +# project() call if CMAKE_BUILD_TYPE is empty. +# +# Unfortunately on most Windows platforms, it defaults to 'Debug', so we can't differentiate +# between a 'Debug' value set on the command line by the user, a value set by the project, or if it +# was default initialized. +# We need to rely on heuristics to determine that. +# +# We try to check the value of CMAKE_BUILD_TYPE before the first project() call by inspecting +# various variables: +# 1) When using a qt.toolchain.cmake file, we rely on the toolchain file to tell us +# if a value was set by the user at initial configure time via the +# __qt_toolchain_cmake_build_type_before_project_call variable. On a 2nd run there will +# always be a value in the cache, but at that point we've already set it to whatever it needs +# to be. +# 2) Whe configuring qtbase, a top-level qt, or a standalone project we rely on one of the following +# variables being set: +# - __qt_auto_detect_cmake_build_type_before_project_call (e.g for qtbase) +# - __qt_internal_standalone_project_cmake_build_type_before_project_call (e.g for sqldrivers) +# 3) When using a multi-config generator, we assume that the CMAKE_BUILD_TYPE is not default +# initialized. +# 4) The user can also force the build type to be considered non-default-initialized by setting +# QT_NO_FORCE_SET_CMAKE_BUILD_TYPE to TRUE. It has weird naming that doesn't quite correspond +# to the meaning, but it's been called like that for a while now and I'm hesitant to change +# the name in case it's used by various projects. +# +# The code doesn't handle an empty "" config set by the user, but we claim that's an +# unsupported config when building Qt. +function(qt_internal_is_cmake_build_type_default_initialized_heuristic out_var) + get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + get_cmake_property(aready_force_set _qt_build_internals_cmake_build_type_set) + + if( + # Set by CMake's Platform/Windows-MSVC.cmake when CMAKE_BUILD_TYPE is empty + # The STREQUAL check needs to have expanded variables because an undefined var is not equal + # to an empty defined var. + "${CMAKE_BUILD_TYPE}" STREQUAL "${CMAKE_BUILD_TYPE_INIT}" + + # Set by qt_internal_force_set_cmake_build_type() + AND aready_force_set MATCHES "NOTFOUND" + + # Set by qt_auto_detect_cmake_build_type() + AND NOT __qt_auto_detect_cmake_build_type_before_project_call + + # Set by sqldrivers project + AND NOT __qt_internal_standalone_project_cmake_build_type_before_project_call + + # Set by qt.toolchain.cmake + AND NOT __qt_toolchain_cmake_build_type_before_project_call + + # Set by user explicitily + AND NOT QT_NO_FORCE_SET_CMAKE_BUILD_TYPE + + # Set in multi-config builds + AND NOT is_multi_config) + + set(${out_var} TRUE PARENT_SCOPE) + else() + set(${out_var} FALSE PARENT_SCOPE) + endif() +endfunction() + +function(qt_internal_force_set_cmake_build_type value) + cmake_parse_arguments(PARSE_ARGV 1 arg + "SHOW_MESSAGE" + "" + "" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + set(CMAKE_BUILD_TYPE "${value}" CACHE STRING "Choose the type of build." FORCE) + set_property(CACHE CMAKE_BUILD_TYPE + PROPERTY STRINGS + "Debug" "Release" "MinSizeRel" "RelWithDebInfo") # Set the possible values for cmake-gui. + if(arg_SHOW_MESSAGE) + message(STATUS "Force setting build type to '${value}'.") + endif() + set_property(GLOBAL PROPERTY _qt_build_internals_cmake_build_type_set "${value}") +endfunction() + +# Only override the build type if it was default initialized by CMake. +function(qt_internal_force_set_cmake_build_type_if_cmake_default_initialized value) + qt_internal_is_cmake_build_type_default_initialized_heuristic(is_default_cmake_build_type) + if(is_default_cmake_build_type) + qt_internal_force_set_cmake_build_type("${value}" SHOW_MESSAGE) + endif() +endfunction() + +function(qt_internal_set_cmake_build_type) + # When building standalone tests against a multi-config Qt, we want to configure the + # tests / examples with + # the first multi-config configuration, rather than use CMake's default configuration. + # In the case of Windows, we definitely don't want it to default to Debug, because that causes + # issues in the CI. + if(QT_INTERNAL_BUILD_STANDALONE_PARTS AND QT_MULTI_CONFIG_FIRST_CONFIG) + qt_internal_force_set_cmake_build_type_if_cmake_default_initialized( + "${QT_MULTI_CONFIG_FIRST_CONFIG}") + + # We want the same build type to be used when configuring all Qt repos or standalone + # tests or single tests, so we reuse the initial build type set by qtbase. + # __qt_internal_initial_qt_cmake_build_type is saved in QtBuildInternalsExtra.cmake.in. + elseif(__qt_internal_initial_qt_cmake_build_type) + qt_internal_force_set_cmake_build_type_if_cmake_default_initialized( + "${__qt_internal_initial_qt_cmake_build_type}") + + # Default to something sensible when configuring qtbase / top-level. + else() + qt_internal_set_qt_appropriate_default_cmake_build_type() + endif() +endfunction() + +# Sets a default cmake build type for qtbase / top-level. +macro(qt_internal_set_qt_appropriate_default_cmake_build_type) + set(_default_build_type "Release") + if(FEATURE_developer_build) + set(_default_build_type "Debug") + endif() + + qt_internal_is_cmake_build_type_default_initialized_heuristic(is_default_cmake_build_type) + if(is_default_cmake_build_type) + qt_internal_force_set_cmake_build_type("${_default_build_type}") + message(STATUS "Setting build type to '${_default_build_type}' as none was specified.") + elseif(CMAKE_CONFIGURATION_TYPES) + message(STATUS "Building for multiple configurations: ${CMAKE_CONFIGURATION_TYPES}.") + message(STATUS "Main configuration is: ${QT_MULTI_CONFIG_FIRST_CONFIG}.") + if(CMAKE_NINJA_MULTI_DEFAULT_BUILD_TYPE) + message(STATUS + "Default build configuration set to '${CMAKE_NINJA_MULTI_DEFAULT_BUILD_TYPE}'.") + endif() + if(CMAKE_GENERATOR STREQUAL "Ninja") + message(FATAL_ERROR + "It's not possible to build multiple configurations with the single config Ninja " + "generator. Consider configuring with -G\"Ninja Multi-Config\" instead of -GNinja." + ) + endif() + else() + message(STATUS "CMAKE_BUILD_TYPE was already explicitly set to: '${CMAKE_BUILD_TYPE}'") + endif() +endmacro() + +macro(qt_internal_set_configure_from_ide) + # QT_INTERNAL_CONFIGURE_FROM_IDE is set to TRUE for the following known IDE applications: + # - Qt Creator, detected by QTC_RUN environment variable + # - CLion, detected by CLION_IDE environment variable + # - Visual Studio Code, detected by VSCODE_CLI environment variable + if("$ENV{QTC_RUN}" OR "$ENV{CLION_IDE}" OR "$ENV{VSCODE_CLI}") + set(QT_INTERNAL_CONFIGURE_FROM_IDE TRUE CACHE INTERNAL "Configuring Qt Project from IDE") + else() + set(QT_INTERNAL_CONFIGURE_FROM_IDE FALSE CACHE INTERNAL "Configuring Qt Project from IDE") + endif() +endmacro() + +macro(qt_internal_set_sync_headers_at_configure_time) + set(_qt_sync_headers_at_configure_time_default ${QT_INTERNAL_CONFIGURE_FROM_IDE}) + + if(FEATURE_developer_build) + # Sync headers during the initial configuration of a -developer-build to facilitate code + # navigation for code editors that use an LSP-based code model. + set(_qt_sync_headers_at_configure_time_default TRUE) + endif() + + # Sync Qt header files at configure time + option(QT_SYNC_HEADERS_AT_CONFIGURE_TIME "Run syncqt at configure time already" + ${_qt_sync_headers_at_configure_time_default}) + unset(_qt_sync_headers_at_configure_time_default) + + # In static Ninja Multi-Config builds the sync_headers dependencies(and other autogen + # dependencies are not added to '_autogen/timestamp' targets. See QTBUG-113974. + if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config" AND NOT QT_BUILD_SHARED_LIBS) + set(QT_SYNC_HEADERS_AT_CONFIGURE_TIME TRUE CACHE BOOL "" FORCE) + endif() +endmacro() + +macro(qt_internal_set_export_compile_commands) + if(FEATURE_developer_build) + if(DEFINED QT_CMAKE_EXPORT_COMPILE_COMMANDS) + set(CMAKE_EXPORT_COMPILE_COMMANDS ${QT_CMAKE_EXPORT_COMPILE_COMMANDS}) + else() + set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + endif() + endif() +endmacro() + +macro(qt_internal_setup_build_benchmarks) + if(FEATURE_developer_build) + set(__build_benchmarks ON) + + # Disable benchmarks for single configuration generators which do not build + # with release configuration. + if(CMAKE_BUILD_TYPE AND CMAKE_BUILD_TYPE STREQUAL Debug) + set(__build_benchmarks OFF) + endif() + else() + set(__build_benchmarks OFF) + endif() + + # Build Benchmarks + option(QT_BUILD_BENCHMARKS "Build Qt Benchmarks" ${__build_benchmarks}) +endmacro() + +macro(qt_internal_setup_build_tests) + if(FEATURE_developer_build) + set(_qt_build_tests_default ON) + + # Tests are not built by default with qmake for iOS and friends, and thus the overall build + # tends to fail. Disable them by default when targeting uikit. + if(UIKIT OR ANDROID) + set(_qt_build_tests_default OFF) + endif() + else() + set(_qt_build_tests_default OFF) + endif() + + # If benchmarks are explicitly enabled, force tests to also be built, even if they might + # not work on the platform. + if(QT_BUILD_BENCHMARKS) + set(_qt_build_tests_default ON) + endif() + + ## Set up testing + option(QT_BUILD_TESTS "Build the testing tree." ${_qt_build_tests_default}) + unset(_qt_build_tests_default) + option(QT_BUILD_TESTS_BY_DEFAULT + "Should tests be built as part of the default 'all' target." ON) + if(QT_BUILD_STANDALONE_TESTS) + # BuildInternals might have set it to OFF on initial configuration. So force it to ON when + # building standalone tests. + set(QT_BUILD_TESTS ON CACHE BOOL "Build the testing tree." FORCE) + + # Also force the tests to be built as part of the default build target. + set(QT_BUILD_TESTS_BY_DEFAULT ON CACHE BOOL + "Should tests be built as part of the default 'all' target." FORCE) + endif() + set(BUILD_TESTING ${QT_BUILD_TESTS} CACHE INTERNAL "") + + if(WASM) + set(_qt_batch_tests ON) + else() + set(_qt_batch_tests OFF) + endif() + + if(DEFINED INPUT_batch_tests) + if (${INPUT_batch_tests}) + set(_qt_batch_tests ON) + else() + set(_qt_batch_tests OFF) + endif() + endif() + + option(QT_BUILD_TESTS_BATCHED "Link all tests into a single binary." ${_qt_batch_tests}) + + if(QT_BUILD_TESTS AND QT_BUILD_TESTS_BATCHED AND CMAKE_VERSION VERSION_LESS "3.19") + message(FATAL_ERROR + "Test batching requires at least CMake 3.19, due to requiring per-source " + "TARGET_DIRECTORY assignments and DEFER calls.") + endif() + + option(QT_BUILD_MANUAL_TESTS "Build Qt manual tests" OFF) + + if(WASM AND _qt_batch_tests) + set(_qt_wasm_and_batch_tests ON) + else() + set(_qt_wasm_and_batch_tests OFF) + endif() + + option(QT_BUILD_MINIMAL_STATIC_TESTS "Build minimal subset of tests for static Qt builds" ${_qt_wasm_and_batch_tests}) + + option(QT_BUILD_WASM_BATCHED_TESTS "Build subset of tests for wasm batched tests" ${_qt_wasm_and_batch_tests}) + + option(QT_BUILD_MINIMAL_ANDROID_MULTI_ABI_TESTS + "Build minimal subset of tests for Android multi-ABI Qt builds" OFF) + + include(CTest) + enable_testing() +endmacro() + +macro(qt_internal_setup_build_tools) + # QT_BUILD_TOOLS_WHEN_CROSSCOMPILING -> QT_FORCE_BUILD_TOOLS + # pre-6.4 compatibility flag (remove sometime in the future) + if(CMAKE_CROSSCOMPILING AND QT_BUILD_TOOLS_WHEN_CROSSCOMPILING) + message(WARNING "QT_BUILD_TOOLS_WHEN_CROSSCOMPILING is deprecated. " + "Please use QT_FORCE_BUILD_TOOLS instead.") + set(QT_FORCE_BUILD_TOOLS TRUE CACHE INTERNAL "" FORCE) + endif() + + # When cross-building, we don't build tools by default. Sometimes this also covers Qt apps as + # well. Like in qttools/assistant/assistant.pro, load(qt_app), which is guarded by a + # qtNomakeTools() call. + set(_qt_build_tools_by_default_default ON) + if(CMAKE_CROSSCOMPILING AND NOT QT_FORCE_BUILD_TOOLS) + set(_qt_build_tools_by_default_default OFF) + endif() + option(QT_BUILD_TOOLS_BY_DEFAULT "Should tools be built as part of the default 'all' target." + "${_qt_build_tools_by_default_default}") + unset(_qt_build_tools_by_default_default) +endmacro() + +# A heuristic to determine that the currently processed project is a cmake build test project. +function(qt_internal_current_project_is_cmake_build_test_project out_var) + set(current_dir "${CMAKE_CURRENT_SOURCE_DIR}") + + set(result FALSE) + + if(current_dir MATCHES "tests/auto/cmake") + set(result TRUE) + endif() + + set(${out_var} "${result}" PARENT_SCOPE) +endfunction() + +function(qt_internal_compute_sbom_default out_var) + # Default to generating the SBOM, except for: + # - developer-builds + # - no-prefix builds. + # - standalone tests or examples + # - cmake build tests + # Regular developers of Qt (which would pass -developer-build) likely don't need SBOMs. + # -no-prefix builds don't make much sense for SBOMs because the installed file checksums + # will be missing, and thus the SBOMs will not be complete / valid. + # Honor any explicitly or previously set value. + qt_internal_current_project_is_cmake_build_test_project(is_cmake_build_test) + + if(FEATURE_developer_build + OR QT_FEATURE_developer_build + OR FEATURE_no_prefix + OR QT_FEATURE_no_prefix + OR QT_BUILD_STANDALONE_EXAMPLES + OR QT_BUILD_STANDALONE_TESTS + OR QT_INTERNAL_BUILD_STANDALONE_PARTS + OR is_cmake_build_test + ) + set(enable_sbom OFF) + else() + set(enable_sbom ON) + endif() + set(${out_var} "${enable_sbom}" PARENT_SCOPE) +endfunction() + +macro(qt_internal_setup_sbom) + qt_internal_compute_sbom_default(_qt_generate_sbom_default) + + option(QT_GENERATE_SBOM "Generate SBOM documents in SPDX v2.3 tag:value format." + "${_qt_generate_sbom_default}") + + option(QT_SBOM_GENERATE_JSON + "Generate SBOM documents in SPDX v2.3 JSON format if dependencies are available" ON) + option(QT_SBOM_REQUIRE_GENERATE_JSON + "Error out if JSON SBOM generation dependencies are not found." OFF) + + option(QT_SBOM_VERIFY "Verify generated SBOM documents." ON) + option(QT_SBOM_REQUIRE_VERIFY + "Error out if SBOM verification dependencies are not found." OFF) +endmacro() + +macro(qt_internal_setup_build_examples) + option(QT_BUILD_EXAMPLES "Build Qt examples" OFF) + option(QT_BUILD_EXAMPLES_BY_DEFAULT + "Should examples be built as part of the default 'all' target." ON) + option(QT_INSTALL_EXAMPLES_SOURCES "Install example sources" OFF) + option(QT_INSTALL_EXAMPLES_SOURCES_BY_DEFAULT + "Install example sources as part of the default 'install' target" ON) + + # We need a way to force disable building in-tree examples in the CI, so that we instead build + # standalone examples. Because the Coin yaml instructions don't allow us to remove + # -make examples from from the configure args, we instead read a variable that only Coin sets. + if(QT_INTERNAL_CI_NO_BUILD_IN_TREE_EXAMPLES) + set(QT_BUILD_EXAMPLES OFF CACHE BOOL "Build Qt examples" FORCE) + endif() + + if(QT_BUILD_STANDALONE_EXAMPLES) + # BuildInternals might have set it to OFF on initial configuration. So force it to ON when + # building standalone examples. + set(QT_BUILD_EXAMPLES ON CACHE BOOL "Build Qt examples" FORCE) + + # Also force the examples to be built as part of the default build target. + set(QT_BUILD_EXAMPLES_BY_DEFAULT ON CACHE BOOL + "Should examples be built as part of the default 'all' target." FORCE) + endif() + + option(QT_DEPLOY_MINIMAL_EXAMPLES + "Deploy minimal subset of examples to save time and space" OFF) + + # FIXME: Support prefix builds as well QTBUG-96232 + # We don't want to enable EP examples with -debug-and-release because starting with CMake 3.24 + # ExternalProject_Add ends up creating build rules twice, once for each configuration, in the + # same build dir, which ends up causing various issues due to concurrent builds as well as + # clobbered CMakeCache.txt and ninja files. + if(QT_WILL_INSTALL OR QT_FEATURE_debug_and_release) + set(_qt_build_examples_as_external OFF) + else() + set(_qt_build_examples_as_external ON) + endif() + option(QT_BUILD_EXAMPLES_AS_EXTERNAL "Should examples be built as ExternalProjects." + ${_qt_build_examples_as_external}) + unset(_qt_build_examples_as_external) +endmacro() + +macro(qt_internal_set_qt_host_path) + ## Path used to find host tools, either when cross-compiling or just when using the tools from + ## a different host build. + set(QT_HOST_PATH "$ENV{QT_HOST_PATH}" CACHE PATH + "Installed Qt host directory path, used for cross compiling.") +endmacro() + +macro(qt_internal_setup_build_docs) + option(QT_BUILD_DOCS "Generate Qt documentation targets" ON) +endmacro() + +macro(qt_internal_set_use_ccache) + option(QT_USE_CCACHE "Enable the use of ccache") + if(QT_USE_CCACHE) + find_program(CCACHE_PROGRAM ccache) + if(CCACHE_PROGRAM) + set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}") + set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}") + set(CMAKE_OBJC_COMPILER_LAUNCHER "${CCACHE_PROGRAM}") + set(CMAKE_OBJCXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}") + else() + message(FATAL_ERROR "Ccache use was requested, but the program was not found.") + endif() + endif() +endmacro() + +macro(qt_internal_set_unity_build) + option(QT_UNITY_BUILD "Enable unity (jumbo) build") + set(QT_UNITY_BUILD_BATCH_SIZE "32" CACHE STRING "Unity build batch size") + if(QT_UNITY_BUILD) + set(CMAKE_UNITY_BUILD ON) + set(CMAKE_UNITY_BUILD_BATCH_SIZE "${QT_UNITY_BUILD_BATCH_SIZE}") + endif() +endmacro() + +macro(qt_internal_set_allow_symlink_in_paths) + option(QT_ALLOW_SYMLINK_IN_PATHS "Allows symlinks in paths." OFF) +endmacro() + +macro(qt_internal_set_qt_allow_download) + option(QT_ALLOW_DOWNLOAD "Allows files to be downloaded when building Qt." OFF) +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildPathsHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildPathsHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4d05f86fbb45cb1428209a46363efd2301dfafe6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildPathsHelpers.cmake @@ -0,0 +1,256 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +macro(qt_internal_setup_default_install_prefix) + # Detect non-prefix builds: either when the qtbase install prefix is set to the binary dir + # or when a developer build is explicitly enabled and no install prefix (or staging prefix) + # is specified. + # This detection only happens when building qtbase, and later is propagated via the generated + # QtBuildInternalsExtra.cmake file. + if(PROJECT_NAME STREQUAL "QtBase" AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + # Handle both FEATURE_ and QT_FEATURE_ cases when they are specified on the command line + # explicitly. It's possible for one to be set, but not the other, because + # qtbase/configure.cmake is not processed by this point. + if((FEATURE_developer_build + OR QT_FEATURE_developer_build + OR FEATURE_no_prefix + OR QT_FEATURE_no_prefix + ) + AND NOT CMAKE_STAGING_PREFIX) + # Handle non-prefix builds by setting the CMake install prefix to point to qtbase's + # build dir. While building another repo (like qtsvg) the CMAKE_PREFIX_PATH should + # be set on the command line to point to the qtbase build dir. + set(__qt_default_prefix "${QtBase_BINARY_DIR}") + else() + if(CMAKE_HOST_WIN32) + set(__qt_default_prefix "C:/Qt/") + else() + set(__qt_default_prefix "/usr/local/") + endif() + string(APPEND __qt_default_prefix + "Qt-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}") + endif() + set(CMAKE_INSTALL_PREFIX ${__qt_default_prefix} CACHE PATH + "Install path prefix, prepended onto install directories." FORCE) + unset(__qt_default_prefix) + endif() + if(CMAKE_STAGING_PREFIX) + set(__qt_prefix "${CMAKE_STAGING_PREFIX}") + else() + set(__qt_prefix "${CMAKE_INSTALL_PREFIX}") + endif() + if(__qt_prefix STREQUAL QtBase_BINARY_DIR) + set(__qt_will_install_value OFF) + else() + set(__qt_will_install_value ON) + endif() + set(QT_WILL_INSTALL ${__qt_will_install_value} CACHE BOOL + "Boolean indicating if doing a Qt prefix build (vs non-prefix build)." FORCE) + unset(__qt_prefix) + unset(__qt_will_install_value) + endif() +endmacro() + +function(qt_internal_setup_build_and_install_paths) + # Compute the values of QT_BUILD_DIR, QT_INSTALL_DIR, QT_CONFIG_BUILD_DIR, QT_CONFIG_INSTALL_DIR + # taking into account whether the current build is a prefix build or a non-prefix build, + # and whether it is a superbuild or non-superbuild. + # A third case is when another module or standalone tests/examples are built against a + # super-built Qt. + # The layout for the third case is the same as for non-superbuilds. + # + # These values should be prepended to file paths in commands or properties, + # in order to correctly place generated Config files, generated Targets files, + # executables / libraries, when copying / installing files, etc. + # + # The build dir variables will always be absolute paths. + # The QT_INSTALL_DIR variable will have a relative path in a prefix build, + # which means that it can be empty, so use qt_join_path to prevent accidental absolute paths. + if(QT_SUPERBUILD) + # In this case, we always copy all the build products in qtbase/{bin,lib,...} + if(QT_WILL_INSTALL) + set(QT_BUILD_DIR "${QtBase_BINARY_DIR}") + set(QT_INSTALL_DIR "") + else() + if("${CMAKE_STAGING_PREFIX}" STREQUAL "") + set(QT_BUILD_DIR "${QtBase_BINARY_DIR}") + set(QT_INSTALL_DIR "${QtBase_BINARY_DIR}") + else() + set(QT_BUILD_DIR "${CMAKE_STAGING_PREFIX}") + set(QT_INSTALL_DIR "${CMAKE_STAGING_PREFIX}") + endif() + endif() + else() + if(QT_WILL_INSTALL) + # In the usual prefix build case, the build dir is the current module build dir, + # and the install dir is the prefix, so we don't set it. + set(QT_BUILD_DIR "${CMAKE_BINARY_DIR}") + set(QT_INSTALL_DIR "") + else() + # When doing a non-prefix build, both the build dir and install dir are the same, + # pointing to the qtbase build dir. + set(QT_BUILD_DIR "${QT_STAGING_PREFIX}") + set(QT_INSTALL_DIR "${QT_BUILD_DIR}") + endif() + endif() + + set(__config_path_part "${INSTALL_LIBDIR}/cmake") + set(QT_CONFIG_BUILD_DIR "${QT_BUILD_DIR}/${__config_path_part}") + set(QT_CONFIG_INSTALL_DIR "${QT_INSTALL_DIR}") + if(QT_CONFIG_INSTALL_DIR) + string(APPEND QT_CONFIG_INSTALL_DIR "/") + endif() + string(APPEND QT_CONFIG_INSTALL_DIR ${__config_path_part}) + + set(QT_BUILD_DIR "${QT_BUILD_DIR}" PARENT_SCOPE) + set(QT_INSTALL_DIR "${QT_INSTALL_DIR}" PARENT_SCOPE) + set(QT_CONFIG_BUILD_DIR "${QT_CONFIG_BUILD_DIR}" PARENT_SCOPE) + set(QT_CONFIG_INSTALL_DIR "${QT_CONFIG_INSTALL_DIR}" PARENT_SCOPE) +endfunction() + +function(qt_configure_process_path name default docstring) + # Values are computed once for qtbase, and then exported and reused for other projects. + if(NOT PROJECT_NAME STREQUAL "QtBase") + return() + endif() + + # No value provided, set the default. + # Make sure to process the paths even for the defaults to ensure we have canonicalized paths + # on the first configure run and thus don't regenerate qconfig.cpp on a subsequent + # configure run when the paths might become different if we didn't do it on first run. + # e.g. './plugins' would get turned to 'plugins'. + if(NOT DEFINED "${name}") + set("${name}" "${default}") + endif() + + get_filename_component(given_path_as_abs "${${name}}" ABSOLUTE BASE_DIR + "${CMAKE_INSTALL_PREFIX}") + file(RELATIVE_PATH rel_path "${CMAKE_INSTALL_PREFIX}" + "${given_path_as_abs}") + + # If absolute path given, check that it's inside the prefix (error out if not). + # If relative path given, it's relative to the install prefix (rather than the binary dir, + # which is what qmake does for some reason). + # In both cases, store the value as a relative path, unless we're processing INSTALL_SYSCONFDIR + # which should stay abslute. + if("${rel_path}" STREQUAL "") + # file(RELATIVE_PATH) returns an empty string if the given absolute paths are equal, + # so manually set it to '.' + set(new_value ".") + elseif(rel_path MATCHES "^\.\./") + # INSTALL_SYSCONFDIR is allowed to be outside the prefix. + if(NOT name STREQUAL "INSTALL_SYSCONFDIR") + message(FATAL_ERROR + "Path component '${name}' is outside computed install prefix: ${rel_path} ") + endif() + # Keep the absolute path. + set(new_value "${${name}}") + else() + # Use the canonicalized path. + set(new_value "${rel_path}") + endif() + + set("${name}" "${new_value}" CACHE STRING "${docstring}" FORCE) +endfunction() + +macro(qt_internal_setup_configure_install_paths) + # Install locations: + qt_configure_process_path(INSTALL_BINDIR "bin" "Executables [PREFIX/bin]") + qt_configure_process_path(INSTALL_INCLUDEDIR "include" "Header files [PREFIX/include]") + qt_configure_process_path(INSTALL_LIBDIR "lib" "Libraries [PREFIX/lib]") + qt_configure_process_path(INSTALL_MKSPECSDIR "mkspecs" "Mkspecs files [PREFIX/mkspecs]") + qt_configure_process_path(INSTALL_ARCHDATADIR "." "Arch-dependent data [PREFIX]") + qt_configure_process_path(INSTALL_PLUGINSDIR + "${INSTALL_ARCHDATADIR}/plugins" + "Plugins [ARCHDATADIR/plugins]") + + if(NOT INSTALL_MKSPECSDIR MATCHES "(^|/)mkspecs") + message(FATAL_ERROR "INSTALL_MKSPECSDIR must end with '/mkspecs'") + endif() + + if (WIN32) + set(_default_libexec "${INSTALL_ARCHDATADIR}/bin") + else() + set(_default_libexec "${INSTALL_ARCHDATADIR}/libexec") + endif() + + qt_configure_process_path( + INSTALL_LIBEXECDIR + "${_default_libexec}" + "Helper programs [ARCHDATADIR/bin on Windows, ARCHDATADIR/libexec otherwise]") + qt_configure_process_path(INSTALL_QMLDIR + "${INSTALL_ARCHDATADIR}/qml" + "QML imports [ARCHDATADIR/qml]") + qt_configure_process_path(INSTALL_DATADIR "." "Arch-independent data [PREFIX]") + qt_configure_process_path(INSTALL_DOCDIR "${INSTALL_DATADIR}/doc" "Documentation [DATADIR/doc]") + qt_configure_process_path(INSTALL_TRANSLATIONSDIR "${INSTALL_DATADIR}/translations" + "Translations [DATADIR/translations]") + if(APPLE) + set(QT_DEFAULT_SYS_CONF_DIR "/Library/Preferences/Qt") + else() + set(QT_DEFAULT_SYS_CONF_DIR "etc/xdg") + endif() + qt_configure_process_path( + INSTALL_SYSCONFDIR + "${QT_DEFAULT_SYS_CONF_DIR}" + "Settings used by Qt programs [PREFIX/etc/xdg]/[/Library/Preferences/Qt]") + qt_configure_process_path(INSTALL_EXAMPLESDIR "examples" "Examples [PREFIX/examples]") + qt_configure_process_path(INSTALL_TESTSDIR "tests" "Tests [PREFIX/tests]") + qt_configure_process_path(INSTALL_DESCRIPTIONSDIR + "${INSTALL_ARCHDATADIR}/modules" + "Module description files directory") + qt_configure_process_path(INSTALL_SBOMDIR "${INSTALL_ARCHDATADIR}/sbom" + "SBOM [PREFIX/sbom]") +endmacro() + +macro(qt_internal_set_cmake_install_libdir) + # Ensure that GNUInstallDirs's CMAKE_INSTALL_LIBDIR points to the same lib dir that Qt was + # configured with. Currently this is important for QML plugins, which embed an rpath based + # on that value. + set(CMAKE_INSTALL_LIBDIR "${INSTALL_LIBDIR}") +endmacro() + +macro(qt_internal_set_qt_cmake_dir) + set(QT_CMAKE_DIR "${CMAKE_CURRENT_LIST_DIR}") +endmacro() + +macro(qt_internal_set_qt_apple_support_files_path) + # This is analogous to what we have in QtConfig.cmake.in. It's copied here so that iOS + # tests can be built in tree. + if(APPLE) + if(NOT CMAKE_SYSTEM_NAME OR CMAKE_SYSTEM_NAME STREQUAL "Darwin") + set(__qt_internal_cmake_apple_support_files_path "${QT_CMAKE_DIR}/macos") + elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS") + set(__qt_internal_cmake_apple_support_files_path "${QT_CMAKE_DIR}/ios") + elseif(CMAKE_SYSTEM_NAME STREQUAL "visionOS") + set(__qt_internal_cmake_apple_support_files_path "${QT_CMAKE_DIR}/visionos") + endif() + endif() +endmacro() + +macro(qt_internal_set_qt_staging_prefix) + if(NOT "${CMAKE_STAGING_PREFIX}" STREQUAL "") + set(QT_STAGING_PREFIX "${CMAKE_STAGING_PREFIX}") + else() + set(QT_STAGING_PREFIX "${CMAKE_INSTALL_PREFIX}") + endif() +endmacro() + +macro(qt_internal_setup_paths_and_prefixes) + qt_internal_setup_configure_install_paths() + + qt_internal_set_qt_staging_prefix() + + # Depends on QT_STAGING_PREFIX being set. + qt_internal_setup_build_and_install_paths() + + qt_get_relocatable_install_prefix(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX) + + # Depends on INSTALL_LIBDIR being set. + qt_internal_set_cmake_install_libdir() + + qt_internal_set_qt_cmake_dir() + + qt_internal_set_qt_apple_support_files_path() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildRepoExamplesHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildRepoExamplesHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..21d44f4928a944ac7764b9f744fc82b1819f5847 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildRepoExamplesHelpers.cmake @@ -0,0 +1,690 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +macro(qt_examples_build_begin) + set(options EXTERNAL_BUILD) + set(singleOpts "") + set(multiOpts DEPENDS) + + cmake_parse_arguments(arg "${options}" "${singleOpts}" "${multiOpts}" ${ARGN}) + + # Examples are not unity-ready. + set(CMAKE_UNITY_BUILD OFF) + + # Skip running deployment steps when the developer asked to deploy a minimal subset of examples. + # Each example can then decide whether it wants to be deployed as part of the minimal subset + # by unsetting the QT_INTERNAL_SKIP_DEPLOYMENT variable before its qt_internal_add_example call. + # This will be used by our CI. + if(NOT DEFINED QT_INTERNAL_SKIP_DEPLOYMENT AND QT_DEPLOY_MINIMAL_EXAMPLES) + set(QT_INTERNAL_SKIP_DEPLOYMENT TRUE) + endif() + + # Use by qt_internal_add_example. + set(QT_EXAMPLE_BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") + + if(QT_BUILD_STANDALONE_EXAMPLES) + # Find all qt packages, so that the various if(QT_FEATURE_foo) add_subdirectory() + # conditions have correct values, regardless whether we will use ExternalProjects or not. + qt_internal_find_standalone_parts_config_files() + endif() + + string(TOLOWER ${PROJECT_NAME} project_name_lower) + + if(arg_EXTERNAL_BUILD AND QT_BUILD_EXAMPLES_AS_EXTERNAL) + # Examples will be built using ExternalProject. + # We depend on all plugins built as part of the current repo as well as current repo's + # dependencies plugins, to prevent opportunities for + # weird errors associated with loading out-of-date plugins from + # unrelated Qt modules. + # We also depend on all targets from this repo's src and tools subdirectories + # to ensure that we've built anything that a find_package() call within + # an example might use. Projects can add further dependencies if needed, + # but that should rarely be necessary. + set(QT_EXAMPLE_DEPENDENCIES ${qt_repo_plugins_recursive} ${arg_DEPENDS}) + + if(TARGET ${qt_repo_targets_name}_src) + list(APPEND QT_EXAMPLE_DEPENDENCIES ${qt_repo_targets_name}_src_for_examples) + endif() + + if(TARGET ${qt_repo_targets_name}_tools) + list(APPEND QT_EXAMPLE_DEPENDENCIES ${qt_repo_targets_name}_tools) + endif() + + set(QT_IS_EXTERNAL_EXAMPLES_BUILD TRUE) + + if(NOT TARGET examples) + if(QT_BUILD_EXAMPLES_BY_DEFAULT) + add_custom_target(examples ALL) + else() + add_custom_target(examples) + endif() + endif() + if(NOT TARGET examples_${project_name_lower}) + add_custom_target(examples_${project_name_lower}) + add_dependencies(examples examples_${project_name_lower}) + endif() + + include(ExternalProject) + else() + # This repo has not yet been updated to build examples in a separate + # build from this main build, or we can't use that arrangement yet. + # Build them directly as part of the main build instead for backward + # compatibility. + if(NOT BUILD_SHARED_LIBS) + # Ordinarily, it would be an error to call return() from within a + # macro(), but in this case we specifically want to return from the + # caller's scope if we are doing a static build and the project + # isn't building examples in a separate build from the main build. + # Configuring static builds requires tools that are not available + # until build time. + return() + endif() + + if(NOT QT_BUILD_EXAMPLES_BY_DEFAULT) + set_directory_properties(PROPERTIES EXCLUDE_FROM_ALL TRUE) + endif() + endif() + + # TODO: Change this to TRUE when all examples in all repos are ported to use + # qt_internal_add_example. + # We shouldn't need to call qt_internal_set_up_build_dir_package_paths when + # QT_IS_EXTERNAL_EXAMPLES_BUILD is TRUE. + # Due to not all examples being ported, if we don't + # call qt_internal_set_up_build_dir_package_paths -> set(QT_NO_CREATE_TARGETS TRUE) we'll get + # CMake configuration errors saying we redefine Qt targets because we both build them and find + # them as part of find_package. + set(__qt_all_examples_ported_to_external_projects FALSE) + + # 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. + # Prepending to CMAKE_PREFIX_PATH helps find the initial Qt6Config.cmake. + # Prepending to QT_BUILD_CMAKE_PREFIX_PATH helps find components of Qt6, because those + # find_package calls use NO_DEFAULT_PATH, and thus CMAKE_PREFIX_PATH is ignored. + # Prepending to CMAKE_FIND_ROOT_PATH ensures the components are found while cross-compiling + # without setting CMAKE_FIND_ROOT_PATH_MODE_PACKAGE to BOTH. + if(NOT QT_IS_EXTERNAL_EXAMPLES_BUILD OR NOT __qt_all_examples_ported_to_external_projects) + qt_internal_set_up_build_dir_package_paths() + list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_BUILD_DIR}") + list(PREPEND QT_BUILD_CMAKE_PREFIX_PATH "${QT_BUILD_DIR}/${INSTALL_LIBDIR}/cmake") + endif() + + # Because CMAKE_INSTALL_RPATH is empty by default in the repo project, examples need to have + # it set here, so they can run when installed. + # This means that installed examples are not relocatable at the moment. We would need to + # annotate where each example is installed to, to be able to derive a relative rpath, and it + # seems there's no way to query such information from CMake itself. + set(CMAKE_INSTALL_RPATH "${_default_install_rpath}") + + install(CODE " +# Backup CMAKE_INSTALL_PREFIX because we're going to change it in each example subdirectory +# and restore it after all examples are processed so that QtFooToolsAdditionalTargetInfo.cmake +# files are installed into the original install prefix. +set(_qt_internal_examples_cmake_install_prefix_backup \"\${CMAKE_INSTALL_PREFIX}\") +") + + # Backup the DESTDIR and unset it, so that example installation is not affected by DESTDIR. + # This is activated by our CI when QT_INTERNAL_EXAMPLES_INSTALL_PREFIX is set. + if(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX) + set(_qt_examples_should_unset_destdir TRUE) + else() + set(_qt_examples_should_unset_destdir FALSE) + endif() + + set_property(GLOBAL PROPERTY + _qt_examples_should_unset_destdir_${project_name_lower} + "${_qt_examples_should_unset_destdir}") + if(_qt_examples_should_unset_destdir) + install(CODE " + # Temporarily unset DESTDIR while examples are being installed. + set(_qt_internal_examples_destdir_backup \"\$ENV{DESTDIR}\") + unset(ENV{DESTDIR}) +") + endif() + + unset(_qt_examples_should_unset_destdir) + unset(project_name_lower) +endmacro() + +macro(qt_examples_build_end) + # We use AUTOMOC/UIC/RCC in the examples. When the examples are part of the + # main build rather than being built in their own separate project, make + # sure we do not fail on a fresh Qt build (e.g. the moc binary won't exist + # yet because it is created at build time). + + _qt_internal_collect_buildsystem_targets(targets + "${CMAKE_CURRENT_SOURCE_DIR}" EXCLUDE UTILITY ALIAS) + + 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() + set_target_properties(${target} PROPERTIES UNITY_BUILD OFF) + endforeach() + + install(CODE " +# Restore backed up CMAKE_INSTALL_PREFIX. +set(CMAKE_INSTALL_PREFIX \"\${_qt_internal_examples_cmake_install_prefix_backup}\") +") + + set(CMAKE_UNITY_BUILD ${QT_UNITY_BUILD}) + + string(TOLOWER ${PROJECT_NAME} project_name_lower) + get_property(_qt_examples_should_unset_destdir + GLOBAL PROPERTY _qt_examples_should_unset_destdir_${project_name_lower}) + + if(_qt_examples_should_unset_destdir) + install(CODE " + # Restore the DESTDIR env var after examples have been installed. + set(ENV{DESTDIR} \"\${_qt_internal_examples_destdir_backup}\") + unset(_qt_internal_examples_destdir_backup) +") + endif() + + unset(_qt_examples_should_unset_destdir) + unset(project_name_lower) +endmacro() + +# Allows building an example either as an ExternalProject or in-tree with the Qt build. +# Also allows installing the example sources. +function(qt_internal_add_example subdir) + # Don't show warnings for examples that were added via qt_internal_add_example. + # Those that are added via add_subdirectory will see the warning, due to the parent scope + # having the variable set to TRUE. + if(QT_FEATURE_developer_build AND NOT QT_NO_WARN_ABOUT_EXAMPLE_ADD_SUBDIRECTORY_WARNING) + set(QT_WARN_ABOUT_EXAMPLE_ADD_SUBDIRECTORY FALSE) + endif() + + # Pre-compute unique example name based on the subdir, in case of target name clashes. + qt_internal_get_example_unique_name(unique_example_name "${subdir}") + + # QT_INTERNAL_NO_CONFIGURE_EXAMPLES is not meant to be used by Qt builders, it's here for faster + # testing of the source installation code path for build system engineers. + if(NOT QT_INTERNAL_NO_CONFIGURE_EXAMPLES) + if(NOT QT_IS_EXTERNAL_EXAMPLES_BUILD) + qt_internal_add_example_in_tree("${subdir}") + else() + qt_internal_add_example_external_project("${subdir}" + NAME "${unique_example_name}") + endif() + endif() + + if(QT_INSTALL_EXAMPLES_SOURCES) + string(TOLOWER ${PROJECT_NAME} project_name_lower) + + qt_internal_install_example_sources("${subdir}" + NAME "${unique_example_name}" + REPO_NAME "${project_name_lower}") + endif() +endfunction() + +# Gets the install prefix where an example should be installed. +# Used for computing the final installation path. +function(qt_internal_get_example_install_prefix out_var) + # Allow customizing the installation path of the examples. Will be used in CI. + if(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX) + set(qt_example_install_prefix "${QT_INTERNAL_EXAMPLES_INSTALL_PREFIX}") + elseif(QT_BUILD_STANDALONE_EXAMPLES) + # TODO: We might need to reset and pipe through an empty CMAKE_STAGING_PREFIX if we ever + # try to run standalone examples in the CI when cross-compiling, similar how it's done in + # qt_internal_set_up_fake_standalone_parts_install_prefix. + qt_internal_get_fake_standalone_install_prefix(qt_example_install_prefix) + else() + set(qt_example_install_prefix "${CMAKE_INSTALL_PREFIX}/${INSTALL_EXAMPLESDIR}") + endif() + file(TO_CMAKE_PATH "${qt_example_install_prefix}" qt_example_install_prefix) + set(${out_var} "${qt_example_install_prefix}" PARENT_SCOPE) +endfunction() + +# Gets the install prefix where an example's sources should be installed. +# Used for computing the final installation path. +function(qt_internal_get_examples_sources_install_prefix out_var) + # Allow customizing the installation path of the examples source specifically. + if(QT_INTERNAL_EXAMPLES_SOURCES_INSTALL_PREFIX) + set(qt_example_install_prefix "${QT_INTERNAL_EXAMPLES_SOURCES_INSTALL_PREFIX}") + else() + qt_internal_get_example_install_prefix(qt_example_install_prefix) + endif() + file(TO_CMAKE_PATH "${qt_example_install_prefix}" qt_example_install_prefix) + set(${out_var} "${qt_example_install_prefix}" PARENT_SCOPE) +endfunction() + +# Gets the relative path of an example, relative to the current repo's examples source dir. +# QT_EXAMPLE_BASE_DIR is meant to be already set in a parent scope. +function(qt_internal_get_example_rel_path out_var subdir) + file(RELATIVE_PATH example_rel_path + "${QT_EXAMPLE_BASE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/${subdir}") + set(${out_var} "${example_rel_path}" PARENT_SCOPE) +endfunction() + +# Gets the install path where an example should be installed. +function(qt_internal_get_example_install_path out_var subdir) + qt_internal_get_example_install_prefix(qt_example_install_prefix) + qt_internal_get_example_rel_path(example_rel_path "${subdir}") + set(example_install_path "${qt_example_install_prefix}/${example_rel_path}") + + set(${out_var} "${example_install_path}" PARENT_SCOPE) +endfunction() + +# Gets the install path where an example's sources should be installed. +function(qt_internal_get_examples_sources_install_path out_var subdir) + qt_internal_get_examples_sources_install_prefix(qt_example_install_prefix) + qt_internal_get_example_rel_path(example_rel_path "${subdir}") + set(example_install_path "${qt_example_install_prefix}/${example_rel_path}") + + set(${out_var} "${example_install_path}" PARENT_SCOPE) +endfunction() + +# Get the unique name of an example project based on its subdir or explicitly given name. +# Makes the name unique by appending a short sha1 hash of the relative path of the example +# if a target of the same name already exist. +function(qt_internal_get_example_unique_name out_var subdir) + qt_internal_get_example_rel_path(example_rel_path "${subdir}") + + set(name "${subdir}") + + # qtdeclarative has calls like qt_internal_add_example(imagine/automotive) + # so passing a nested subdirectory. Custom targets (and thus ExternalProjects) can't contain + # slashes, so extract the last part of the path to be used as a name. + if(name MATCHES "/") + string(REPLACE "/" ";" exploded_path "${name}") + list(POP_BACK exploded_path last_dir) + if(NOT last_dir) + message(FATAL_ERROR "Example subdirectory must have a name.") + else() + set(name "${last_dir}") + endif() + endif() + + # Likely a clash with an example subdir ExternalProject custom target of the same name in a + # top-level build. + if(TARGET "${name}") + string(SHA1 rel_path_hash "${example_rel_path}") + string(SUBSTRING "${rel_path_hash}" 0 4 short_hash) + set(name "${name}-${short_hash}") + endif() + + set(${out_var} "${name}" PARENT_SCOPE) +endfunction() + +# Use old non-ExternalProject approach, aka build in-tree with the Qt build. +function(qt_internal_add_example_in_tree subdir) + # Unset the default CMAKE_INSTALL_PREFIX that's generated in + # ${CMAKE_CURRENT_BINARY_DIR}/cmake_install.cmake + # so we can override it with a different value in + # ${CMAKE_CURRENT_BINARY_DIR}/${subdir}/cmake_install.cmake + # + install(CODE " +# Unset the CMAKE_INSTALL_PREFIX in the current cmake_install.cmake file so that it can be +# overridden in the included add_subdirectory-specific cmake_install.cmake files instead. +# Also unset the deployment prefix, so it can be recomputed for each example subdirectory. +unset(CMAKE_INSTALL_PREFIX) +unset(QT_DEPLOY_PREFIX) +") + + # Override the install prefix in the subdir cmake_install.cmake, so that + # relative install(TARGETS DESTINATION) calls in example projects install where we tell them to. + qt_internal_get_example_install_path(example_install_path "${subdir}") + set(CMAKE_INSTALL_PREFIX "${example_install_path}") + + # Make sure unclean example projects have their INSTALL_EXAMPLEDIR set to "." + # Won't have any effect on example projects that don't use INSTALL_EXAMPLEDIR. + # This plus the install prefix above takes care of installing examples where we want them to + # be installed, while allowing us to remove INSTALL_EXAMPLEDIR code in each example + # incrementally. + # TODO: Remove once all repositories use qt_internal_add_example instead of add_subdirectory. + set(QT_INTERNAL_SET_EXAMPLE_INSTALL_DIR_TO_DOT ON) + + add_subdirectory(${subdir}) +endfunction() + +function(qt_internal_add_example_external_project subdir) + set(options "") + set(singleOpts NAME) + set(multiOpts "") + + cmake_parse_arguments(PARSE_ARGV 1 arg "${options}" "${singleOpts}" "${multiOpts}") + + _qt_internal_get_build_vars_for_external_projects( + CMAKE_DIR_VAR qt_cmake_dir + PREFIXES_VAR qt_prefixes + ADDITIONAL_PACKAGES_PREFIXES_VAR qt_additional_packages_prefixes + ) + + list(APPEND QT_ADDITIONAL_PACKAGES_PREFIX_PATH "${qt_additional_packages_prefixes}") + + set(vars_to_pass_if_defined) + set(var_defs) + if(QT_HOST_PATH OR CMAKE_CROSSCOMPILING) + list(APPEND var_defs + -DCMAKE_TOOLCHAIN_FILE:FILEPATH=${qt_cmake_dir}/qt.toolchain.cmake + ) + else() + list(PREPEND CMAKE_PREFIX_PATH ${qt_prefixes}) + + # Setting CMAKE_SYSTEM_NAME affects CMAKE_CROSSCOMPILING, even if it is + # set to the same as the host, so it should only be set if it is different. + # See https://gitlab.kitware.com/cmake/cmake/-/issues/21744 + if(NOT DEFINED CMAKE_TOOLCHAIN_FILE AND + NOT CMAKE_SYSTEM_NAME STREQUAL CMAKE_HOST_SYSTEM_NAME) + list(APPEND vars_to_pass_if_defined CMAKE_SYSTEM_NAME:STRING) + endif() + endif() + + # We we need to augment the CMAKE_MODULE_PATH with the current repo cmake build dir, to find + # files like FindWrapBundledFooConfigExtra.cmake. + set(module_paths "${qt_prefixes}") + list(TRANSFORM module_paths APPEND "/${INSTALL_LIBDIR}/cmake/${QT_CMAKE_EXPORT_NAMESPACE}") + list(APPEND CMAKE_MODULE_PATH ${module_paths}) + + # Pass additional paths where qml plugin config files should be included by Qt6QmlPlugins.cmake. + # This is needed in prefix builds, where the cmake files are not installed yet. + set(glob_prefixes "${qt_prefixes}") + list(TRANSFORM glob_prefixes APPEND "/${INSTALL_LIBDIR}/cmake/${QT_CMAKE_EXPORT_NAMESPACE}Qml") + + set(qml_plugin_cmake_config_file_glob_prefixes "") + foreach(glob_prefix IN LISTS glob_prefixes) + if(EXISTS "${glob_prefix}") + list(APPEND qml_plugin_cmake_config_file_glob_prefixes "${glob_prefix}") + endif() + endforeach() + + if(qml_plugin_cmake_config_file_glob_prefixes) + set(QT_ADDITIONAL_QML_PLUGIN_GLOB_PREFIXES ${qml_plugin_cmake_config_file_glob_prefixes}) + endif() + + # In multi-config mode by default we exclude building tools for configs other than the main one. + # Trying to build an example in a non-default config using the non-installed + # QtFooConfig.cmake files would error out saying moc is not found. + # Make sure to build examples only with the main config. + # When users build an example against an installed Qt they won't have this problem because + # the generated non-main QtFooTargets-$.cmake file is empty and doesn't advertise + # a tool that is not there. + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(CMAKE_CONFIGURATION_TYPES "${QT_MULTI_CONFIG_FIRST_CONFIG}") + endif() + + # We need to pass the modified CXX flags of the parent project so that using sccache works + # properly and doesn't error out due to concurrent access to the pdb files. + # See qt_internal_set_up_config_optimizations_like_in_qmake, "/Zi" "/Z7". + if(MSVC AND QT_FEATURE_msvc_obj_debug_info) + qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages) + set(configs RELWITHDEBINFO DEBUG) + foreach(lang ${enabled_languages}) + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + list(APPEND vars_to_pass_if_defined "${flag_var_name}:STRING") + endforeach() + endforeach() + endif() + + # When cross-compiling for a qemu target in our CI, we source an environment script + # that sets environment variables like CC and CXX. These are parsed by CMake on initial + # configuration to populate the cache vars CMAKE_${lang}_COMPILER. + # If the environment variable specified not only the compiler path, but also a list of flags + # to pass to the compiler, CMake parses those out into a separate CMAKE_${lang}_COMPILER_ARG1 + # cache variable. In such a case, we want to ensure that the external project also sees those + # flags. + # Unfortunately we can't do that by simply forwarding CMAKE_${lang}_COMPILER_ARG1 to the EP + # because it breaks the compiler identification try_compile call, it simply doesn't consider + # the cache var. From what I could gather, it's a limitation of try_compile and the list + # of variables it considers for forwarding. + # To fix this case, we ensure not to pass either cache variable, and let the external project + # and its compiler identification try_compile project pick up the compiler and the flags + # from the environment variables instead. + foreach(lang_as_env_var CC CXX OBJC OBJCXX) + if(lang_as_env_var STREQUAL "CC") + set(lang_as_cache_var "C") + else() + set(lang_as_cache_var "${lang_as_env_var}") + endif() + set(lang_env_value "$ENV{${lang_as_env_var}}") + if(lang_env_value + AND CMAKE_${lang_as_cache_var}_COMPILER + AND CMAKE_${lang_as_cache_var}_COMPILER_ARG1) + # The compiler environment variable is set and specifies a list of extra flags, don't + # forward the compiler cache vars and rely on the environment variable to be picked up + # instead. + else() + list(APPEND vars_to_pass_if_defined "CMAKE_${lang_as_cache_var}_COMPILER:STRING") + endif() + endforeach() + unset(lang_as_env_var) + unset(lang_as_cache_var) + unset(lang_env_value) + + list(APPEND vars_to_pass_if_defined + CMAKE_BUILD_TYPE:STRING + CMAKE_CONFIGURATION_TYPES:STRING + CMAKE_PREFIX_PATH:STRING + QT_BUILD_CMAKE_PREFIX_PATH:STRING + QT_ADDITIONAL_PACKAGES_PREFIX_PATH:STRING + QT_ADDITIONAL_QML_PLUGIN_GLOB_PREFIXES:STRING + QT_INTERNAL_SKIP_DEPLOYMENT:BOOL + CMAKE_FIND_ROOT_PATH:STRING + CMAKE_MODULE_PATH:STRING + BUILD_SHARED_LIBS:BOOL + CMAKE_OSX_ARCHITECTURES:STRING + CMAKE_OSX_DEPLOYMENT_TARGET:STRING + CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED:BOOL + CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH:BOOL + CMAKE_C_COMPILER_LAUNCHER:STRING + CMAKE_CXX_COMPILER_LAUNCHER:STRING + CMAKE_OBJC_COMPILER_LAUNCHER:STRING + CMAKE_OBJCXX_COMPILER_LAUNCHER:STRING + ) + + # QT_EXAMPLE_CMAKE_VARS_TO_PASS can be set by specific repos to pass any additional required + # CMake cache variables. + # One use case is passing locations of 3rd party package locations like Protobuf via _ROOT + # variables. + set(extra_vars_var_name "") + if(QT_EXAMPLE_CMAKE_VARS_TO_PASS) + set(extra_vars_var_name "QT_EXAMPLE_CMAKE_VARS_TO_PASS") + endif() + foreach(var_with_type IN LISTS vars_to_pass_if_defined ${extra_vars_var_name}) + string(REPLACE ":" ";" key_as_list "${var_with_type}") + list(GET key_as_list 0 var) + if(NOT DEFINED ${var}) + continue() + endif() + + # Preserve lists + string(REPLACE ";" "$" varForGenex "${${var}}") + + list(APPEND var_defs -D${var_with_type}=${varForGenex}) + endforeach() + + if(QT_INTERNAL_VERBOSE_EXAMPLES) + list(APPEND var_defs -DCMAKE_MESSAGE_LOG_LEVEL:STRING=DEBUG) + list(APPEND var_defs -DCMAKE_AUTOGEN_VERBOSE:BOOL=TRUE) + endif() + + set(deps "") + list(REMOVE_DUPLICATES QT_EXAMPLE_DEPENDENCIES) + foreach(dep IN LISTS QT_EXAMPLE_DEPENDENCIES) + if(TARGET ${dep}) + list(APPEND deps ${dep}) + endif() + endforeach() + + set(independent_args) + cmake_policy(PUSH) + if(POLICY CMP0114) + set(independent_args INDEPENDENT TRUE) + cmake_policy(SET CMP0114 NEW) + endif() + + # The USES_TERMINAL_BUILD setting forces the build step to the console pool + # when using Ninja. This has two benefits: + # + # - You see build output as it is generated instead of at the end of the + # build step. + # - Only one task can use the console pool at a time, so it effectively + # serializes all example build steps, thereby preventing CPU + # over-commitment. + # + # If the loss of interactivity is not so important, one can allow CPU + # over-commitment for Ninja builds. This may result in better throughput, + # but is not allowed by default because it can make a machine almost + # unusable while a compilation is running. + set(terminal_args USES_TERMINAL_BUILD TRUE) + if(CMAKE_GENERATOR MATCHES "Ninja") + option(QT_BUILD_EXAMPLES_WITH_CPU_OVERCOMMIT + "Allow CPU over-commitment when building examples (Ninja only)" + ) + if(QT_BUILD_EXAMPLES_WITH_CPU_OVERCOMMIT) + set(terminal_args) + endif() + endif() + + # QT_EXAMPLE_INSTALL_MARKER + # The goal is to install each example project into a directory that keeps the example source dir + # hierarchy, without polluting the example projects with dirty INSTALL_EXAMPLEDIR and + # INSTALL_EXAMPLESDIR usage. + # E.g. ensure qtbase/examples/widgets/widgets/wiggly is installed to + # $qt_example_install_prefix/examples/widgets/widgets/wiggly/wiggly.exe + # $qt_example_install_prefix defaults to ${CMAKE_INSTALL_PREFIX}/${INSTALL_EXAMPLEDIR} + # but can also be set to a custom location. + # This needs to work both: + # - when using ExternalProject to build examples + # - when examples are built in-tree as part of Qt (no ExternalProject). + # The reason we want to support the latter is for nicer IDE integration: a can developer can + # work with a Qt repo and its examples using the same build dir. + # + # In both case we have to ensure examples are not accidentally installed to $qt_prefix/bin or + # similar. + # + # Example projects installation matrix. + # 1) ExternalProject + unclean example install rules (INSTALL_EXAMPLEDIR is set) => + # use _qt_internal_override_example_install_dir_to_dot + ExternalProject_Add's INSTALL_DIR + # using relative_dir from QT_EXAMPLE_BASE_DIR to example_source_dir + # + # 2) ExternalProject + clean example install rules => + # use ExternalProject_Add's INSTALL_DIR using relative_dir from QT_EXAMPLE_BASE_DIR to + # example_source_dir, _qt_internal_override_example_install_dir_to_dot would be a no-op + # + # 3) in-tree + unclean example install rules (INSTALL_EXAMPLEDIR is set) + # + + # 4) in-tree + clean example install rules => + # ensure CMAKE_INSTALL_PREFIX is unset in parent cmake_install.cmake file, set non-cache + # CMAKE_INSTALL_PREFIX using relative_dir from QT_EXAMPLE_BASE_DIR to + # example_source_dir, use _qt_internal_override_example_install_dir_to_dot to ensure + # INSTALL_EXAMPLEDIR does not interfere. + + qt_internal_get_example_install_path(example_install_path "${subdir}") + + set(ep_binary_dir "${CMAKE_CURRENT_BINARY_DIR}/${subdir}") + + set(build_command "") + if(QT_INTERNAL_VERBOSE_EXAMPLES AND CMAKE_GENERATOR MATCHES "Ninja") + set(build_command BUILD_COMMAND "${CMAKE_COMMAND}" --build "." -- -v) + endif() + + ExternalProject_Add(${arg_NAME} + EXCLUDE_FROM_ALL TRUE + SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${subdir}" + PREFIX "${CMAKE_CURRENT_BINARY_DIR}/${subdir}-ep" + STAMP_DIR "${CMAKE_CURRENT_BINARY_DIR}/${subdir}-ep/stamp" + BINARY_DIR "${ep_binary_dir}" + INSTALL_DIR "${example_install_path}" + INSTALL_COMMAND "" + ${build_command} + TEST_COMMAND "" + DEPENDS ${deps} + CMAKE_CACHE_ARGS ${var_defs} + -DCMAKE_INSTALL_PREFIX:STRING= + -DQT_INTERNAL_SET_EXAMPLE_INSTALL_DIR_TO_DOT:BOOL=TRUE + ${terminal_args} + ) + + # Install the examples when the the user runs 'make install', and not at build time (which is + # the default for ExternalProjects). + install(CODE "\ +# Install example from inside ExternalProject into the main build's install prefix. +execute_process( + COMMAND + \"${CMAKE_COMMAND}\" --build \"${ep_binary_dir}\" --target install +) +") + + # Force configure step to re-run after we configure the main project + set(reconfigure_check_file ${CMAKE_CURRENT_BINARY_DIR}/reconfigure_${arg_NAME}.txt) + file(TOUCH ${reconfigure_check_file}) + ExternalProject_Add_Step(${arg_NAME} reconfigure-check + DEPENDERS configure + DEPENDS ${reconfigure_check_file} + ${independent_args} + ) + + # Create an apk external project step and custom target that invokes the apk target + # within the external project. + # Make the global apk target depend on that custom target. + if(ANDROID) + ExternalProject_Add_Step(${arg_NAME} apk + COMMAND ${CMAKE_COMMAND} --build --target apk + DEPENDEES configure + EXCLUDE_FROM_MAIN YES + ${terminal_args} + ) + ExternalProject_Add_StepTargets(${arg_NAME} apk) + + if(TARGET apk) + add_dependencies(apk ${arg_NAME}-apk) + endif() + endif() + + cmake_policy(POP) + + string(TOLOWER ${PROJECT_NAME} project_name_lower) + add_dependencies(examples_${project_name_lower} ${arg_NAME}) + +endfunction() + +function(qt_internal_install_example_sources subdir) + set(options "") + set(single_args NAME REPO_NAME) + set(multi_args "") + + cmake_parse_arguments(PARSE_ARGV 1 arg "${options}" "${single_args}" "${multi_args}") + + qt_internal_get_examples_sources_install_path(example_install_path "${subdir}") + + # The trailing slash is important to avoid duplicate nested directory names. + set(example_source_dir "${subdir}/") + + # Allow controlling whether sources should be part of the default install target. + if(QT_INSTALL_EXAMPLES_SOURCES_BY_DEFAULT) + set(exclude_from_all "") + else() + set(exclude_from_all "EXCLUDE_FROM_ALL") + endif() + + # Create an install component for all example sources. Can also be part of the default + # install target if EXCLUDE_FROM_ALL is not passed. + install( + DIRECTORY "${example_source_dir}" + DESTINATION "${example_install_path}" + COMPONENT "examples_sources" + USE_SOURCE_PERMISSIONS + ${exclude_from_all} + ) + + # Also create a specific install component just for this repo's examples. + install( + DIRECTORY "${example_source_dir}" + DESTINATION "${example_install_path}" + COMPONENT "examples_sources_${arg_REPO_NAME}" + USE_SOURCE_PERMISSIONS + EXCLUDE_FROM_ALL + ) + + # Also create a specific install component just for the current example's sources. + install( + DIRECTORY "${example_source_dir}" + DESTINATION "${example_install_path}" + COMPONENT "examples_sources_${arg_NAME}" + USE_SOURCE_PERMISSIONS + EXCLUDE_FROM_ALL + ) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildRepoHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildRepoHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e20c418ec011cf86822b5c9527f43e10c75f57cc --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildRepoHelpers.cmake @@ -0,0 +1,1141 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Macros and functions for building Qt submodules + +# The macro sets all the necessary pre-conditions and setup consistent environment for building +# the Qt repository. It has to be called right after the find_package(Qt6 COMPONENTS BuildInternals) +# call. Otherwise we cannot make sure that all the required policies will be applied to the Qt +# components that are involved in build procedure. +macro(qt_internal_project_setup) + # Check for the minimum CMake version. + qt_internal_require_suitable_cmake_version() + qt_internal_upgrade_cmake_policies() +endmacro() + +macro(qt_build_internals_set_up_private_api) + # TODO: this call needs to be removed once all repositories got the qtbase update + qt_internal_project_setup() + + # Qt specific setup common for all modules: + include(QtSetup) + + # 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() + +# add toplevel targets for each subdirectory, e.g. qtbase_src +function(qt_build_internals_add_toplevel_targets qt_repo_targets_name) + set(qt_repo_target_all "") + get_directory_property(directories DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" SUBDIRECTORIES) + foreach(directory IN LISTS directories) + set(qt_repo_targets "") + get_filename_component(qt_repo_target_basename ${directory} NAME) + _qt_internal_collect_buildsystem_targets(qt_repo_targets "${directory}" EXCLUDE UTILITY) + if (qt_repo_targets) + set(qt_repo_target_name "${qt_repo_targets_name}_${qt_repo_target_basename}") + message(DEBUG "${qt_repo_target_name} depends on ${qt_repo_targets}") + add_custom_target("${qt_repo_target_name}" + COMMENT "Building everything in ${qt_repo_targets_name}/${qt_repo_target_basename}") + add_dependencies("${qt_repo_target_name}" ${qt_repo_targets}) + list(APPEND qt_repo_target_all "${qt_repo_target_name}") + + # Create special dependency target for External Project examples excluding targets + # marked as skipped. + if(qt_repo_target_basename STREQUAL "src") + set(qt_repo_target_name + "${qt_repo_targets_name}_${qt_repo_target_basename}_for_examples") + add_custom_target("${qt_repo_target_name}") + + set(unskipped_targets "") + foreach(target IN LISTS qt_repo_targets) + if(TARGET "${target}") + qt_internal_is_target_skipped_for_examples("${target}" is_skipped) + if(NOT is_skipped) + list(APPEND unskipped_targets "${target}") + endif() + endif() + endforeach() + if(unskipped_targets) + add_dependencies("${qt_repo_target_name}" ${unskipped_targets}) + endif() + endif() + endif() + + endforeach() + if (qt_repo_target_all) + # Note qt_repo_targets_name is different from qt_repo_target_name that is used above. + add_custom_target("${qt_repo_targets_name}" + COMMENT "Building everything in ${qt_repo_targets_name}") + add_dependencies("${qt_repo_targets_name}" ${qt_repo_target_all}) + message(DEBUG "${qt_repo_targets_name} depends on ${qt_repo_target_all}") + endif() +endfunction() + +macro(qt_enable_cmake_languages) + set(__qt_required_language_list C CXX) + set(__qt_platform_required_language_list ) + + if(APPLE) + list(APPEND __qt_platform_required_language_list OBJC OBJCXX) + endif() + + foreach(__qt_lang ${__qt_required_language_list}) + enable_language(${__qt_lang}) + endforeach() + + foreach(__qt_lang ${__qt_platform_required_language_list}) + enable_language(${__qt_lang}) + endforeach() + + # The qtbase call is handled in qtbase/CMakeLists.txt. + # This call is used for projects other than qtbase, including for other project's standalone + # tests/examples. + # Because the function uses QT_FEATURE_foo values, it's important that find_package(Qt6Core) is + # called before this function. but that's usually the case for Qt repos. + if(NOT PROJECT_NAME STREQUAL "QtBase") + qt_internal_set_up_config_optimizations_like_in_qmake() + endif() +endmacro() + +# Minimum setup required to have any CMakeList.txt build as as a standalone +# project after importing BuildInternals +macro(qt_prepare_standalone_project) + qt_set_up_build_internals_paths() + qt_build_internals_set_up_private_api() + qt_enable_cmake_languages() +endmacro() + +# Define a repo target set, and store accompanying information. +# +# A repo target set is a subset of targets in a Qt module repository. To build a repo target set, +# set QT_BUILD_SINGLE_REPO_TARGET_SET to the name of the repo target set. +# +# This function is to be called in the top-level project file of a repository, +# before qt_internal_prepare_single_repo_target_set_build() +# +# This function stores information in variables of the parent scope. +# +# Positional Arguments: +# name - The name of this repo target set. +# +# Named Arguments: +# DEPENDS - List of Qt6 COMPONENTS that are build dependencies of this repo target set. +function(qt_internal_define_repo_target_set name) + set(oneValueArgs DEPENDS) + set(prefix QT_REPO_TARGET_SET_) + cmake_parse_arguments(${prefix}${name} "" ${oneValueArgs} "" ${ARGN}) + foreach(arg IN LISTS oneValueArgs) + set(${prefix}${name}_${arg} ${${prefix}${name}_${arg}} PARENT_SCOPE) + endforeach() + set(QT_REPO_KNOWN_TARGET_SETS "${QT_REPO_KNOWN_TARGET_SETS};${name}" PARENT_SCOPE) +endfunction() + +# Setup a single repo target set build if QT_BUILD_SINGLE_REPO_TARGET_SET is defined. +# +# This macro must be called in the top-level project file of the repository after all repo target +# sets have been defined. +macro(qt_internal_prepare_single_repo_target_set_build) + if(DEFINED QT_BUILD_SINGLE_REPO_TARGET_SET) + if(NOT QT_BUILD_SINGLE_REPO_TARGET_SET IN_LIST QT_REPO_KNOWN_TARGET_SETS) + message(FATAL_ERROR + "Repo target set '${QT_BUILD_SINGLE_REPO_TARGET_SET}' is undefined.") + endif() + message(STATUS + "Preparing single repo target set build of ${QT_BUILD_SINGLE_REPO_TARGET_SET}") + if (NOT "${QT_REPO_TARGET_SET_${QT_BUILD_SINGLE_REPO_TARGET_SET}_DEPENDS}" STREQUAL "") + find_package(${INSTALL_CMAKE_NAMESPACE} ${PROJECT_VERSION} CONFIG REQUIRED + COMPONENTS ${QT_REPO_TARGET_SET_${QT_BUILD_SINGLE_REPO_TARGET_SET}_DEPENDS}) + endif() + endif() +endmacro() + +# There are three necessary copies of this macro in +# qtbase/cmake/QtBaseHelpers.cmake +# qtbase/cmake/QtBaseTopLevelHelpers.cmake +# qtbase/cmake/QtBuildRepoHelpers.cmake +macro(qt_internal_setup_standalone_parts) + # A generic marker for any kind of standalone builds, either tests or examples. + if(NOT DEFINED QT_INTERNAL_BUILD_STANDALONE_PARTS + AND (QT_BUILD_STANDALONE_TESTS OR QT_BUILD_STANDALONE_EXAMPLES)) + set(QT_INTERNAL_BUILD_STANDALONE_PARTS TRUE CACHE INTERNAL + "Whether standalone tests or examples are being built") + endif() +endmacro() + +macro(qt_internal_setup_global_doc_targets) + # Add global docs targets that will work both for per-repo builds, and super builds. + if(NOT TARGET docs AND QT_BUILD_DOCS) + add_custom_target(docs) + add_custom_target(prepare_docs) + add_custom_target(generate_docs) + add_custom_target(html_docs) + add_custom_target(qch_docs) + add_custom_target(install_html_docs) + add_custom_target(install_qch_docs) + add_custom_target(install_docs) + add_dependencies(html_docs generate_docs) + add_dependencies(docs html_docs qch_docs) + add_dependencies(install_docs install_html_docs install_qch_docs) + endif() + + if(QT_BUILD_DOCS) + set(qt_docs_target_name docs_${project_name_lower}) + set(qt_docs_prepare_target_name prepare_docs_${project_name_lower}) + set(qt_docs_generate_target_name generate_docs_${project_name_lower}) + set(qt_docs_html_target_name html_docs_${project_name_lower}) + set(qt_docs_qch_target_name qch_docs_${project_name_lower}) + set(qt_docs_install_html_target_name install_html_docs_${project_name_lower}) + set(qt_docs_install_qch_target_name install_qch_docs_${project_name_lower}) + set(qt_docs_install_target_name install_docs_${project_name_lower}) + + add_custom_target(${qt_docs_target_name}) + add_custom_target(${qt_docs_prepare_target_name}) + add_custom_target(${qt_docs_generate_target_name}) + add_custom_target(${qt_docs_qch_target_name}) + add_custom_target(${qt_docs_html_target_name}) + add_custom_target(${qt_docs_install_html_target_name}) + add_custom_target(${qt_docs_install_qch_target_name}) + add_custom_target(${qt_docs_install_target_name}) + + add_dependencies(${qt_docs_generate_target_name} ${qt_docs_prepare_target_name}) + add_dependencies(${qt_docs_html_target_name} ${qt_docs_generate_target_name}) + add_dependencies(${qt_docs_target_name} + ${qt_docs_html_target_name} ${qt_docs_qch_target_name}) + add_dependencies(${qt_docs_install_target_name} + ${qt_docs_install_html_target_name} ${qt_docs_install_qch_target_name}) + + # Make top-level prepare_docs target depend on the repository-level + # prepare_docs_ target. + add_dependencies(prepare_docs ${qt_docs_prepare_target_name}) + + # Make top-level install_*_docs targets depend on the repository-level + # install_*_docs targets. + add_dependencies(install_html_docs ${qt_docs_install_html_target_name}) + add_dependencies(install_qch_docs ${qt_docs_install_qch_target_name}) + endif() +endmacro() + +macro(qt_build_repo_begin) + qt_internal_setup_standalone_parts() + + set(QT_INTERNAL_REPO_POST_PROCESS_CALLED FALSE) + list(APPEND CMAKE_MESSAGE_CONTEXT "${PROJECT_NAME}") + + qt_build_internals_set_up_private_api() + + # Prevent installation in non-prefix builds. + # We need to associate targets with export names, and that is only possible to do with the + # install(TARGETS) command. But in a non-prefix build, we don't want to install anything. + # To make sure that developers don't accidentally run make install, add bail out code to + # cmake_install.cmake. + if(NOT QT_WILL_INSTALL) + # In a top-level build, print a message only in qtbase, which is the first repository. + if(NOT QT_SUPERBUILD OR (PROJECT_NAME STREQUAL "QtBase")) + install(CODE [[message(FATAL_ERROR + "Qt was configured as non-prefix build. " + "Installation is not supported for this arrangement.")]]) + endif() + + install(CODE [[return()]]) + endif() + + qt_enable_cmake_languages() + + qt_internal_generate_binary_strip_wrapper() + + if(NOT TARGET sync_headers) + add_custom_target(sync_headers) + endif() + + # The special target that we use to sync 3rd-party headers before the gn run when building + # qtwebengine in top-level builds. + if(NOT TARGET thirdparty_sync_headers) + add_custom_target(thirdparty_sync_headers) + endif() + + # Add global qt_plugins, qpa_plugins and qpa_default_plugins convenience custom targets. + # Internal executables will add a dependency on the qpa_default_plugins target, + # so that building and running a test ensures it won't fail at runtime due to a missing qpa + # plugin. + if(NOT TARGET qt_plugins) + add_custom_target(qt_plugins) + add_custom_target(qpa_plugins) + add_custom_target(qpa_default_plugins) + endif() + + string(TOLOWER ${PROJECT_NAME} project_name_lower) + + # Target to build all plugins that are part of the current repo. + set(qt_repo_plugins "qt_plugins_${project_name_lower}") + if(NOT TARGET ${qt_repo_plugins}) + add_custom_target(${qt_repo_plugins}) + endif() + + # Target to build all plugins that are part of the current repo and the current repo's + # dependencies plugins. Used for external project example dependencies. + set(qt_repo_plugins_recursive "${qt_repo_plugins}_recursive") + if(NOT TARGET ${qt_repo_plugins_recursive}) + add_custom_target(${qt_repo_plugins_recursive}) + add_dependencies(${qt_repo_plugins_recursive} "${qt_repo_plugins}") + endif() + + qt_internal_read_repo_dependencies(qt_repo_deps "${PROJECT_SOURCE_DIR}") + if(qt_repo_deps) + set_property(GLOBAL PROPERTY _qt_repo_deps_${project_name_lower} ${qt_repo_deps}) + foreach(qt_repo_dep IN LISTS qt_repo_deps) + if(TARGET qt_plugins_${qt_repo_dep}) + message(DEBUG + "${qt_repo_plugins_recursive} depends on qt_plugins_${qt_repo_dep}") + add_dependencies(${qt_repo_plugins_recursive} "qt_plugins_${qt_repo_dep}") + endif() + endforeach() + endif() + + set(qt_repo_targets_name ${project_name_lower}) + + qt_internal_setup_global_doc_targets() + + # Add host_tools meta target, so that developrs can easily build only tools and their + # dependencies when working in qtbase. + if(NOT TARGET host_tools) + add_custom_target(host_tools) + add_custom_target(bootstrap_tools) + add_custom_target(doc_tools) + + # TODO: Investigate complexity of installing tools for shared builds. + # Currently installing host tools without libraries only really makes sense for static + # builds. Tracking dependencies for shared builds is more involved. + if(NOT BUILD_SHARED_LIBS) + add_custom_target(install_tools + COMMAND ${CMAKE_COMMAND} + --install ${CMAKE_BINARY_DIR} --component host_tools + ) + add_custom_target(install_tools_stripped + COMMAND ${CMAKE_COMMAND} + --install ${CMAKE_BINARY_DIR} --component host_tools --strip + ) + + add_custom_target(install_doc_tools + COMMAND ${CMAKE_COMMAND} + --install ${CMAKE_BINARY_DIR} --component doc_tools + ) + add_custom_target(install_doc_tools_stripped + COMMAND ${CMAKE_COMMAND} + --install ${CMAKE_BINARY_DIR} --component doc_tools --strip + ) + + if(NOT QT_INTERNAL_NO_INSTALL_TOOLS_BUILD_DEPS) + add_dependencies(install_tools host_tools) + add_dependencies(install_tools_stripped host_tools) + add_dependencies(install_doc_tools doc_tools) + add_dependencies(install_doc_tools_stripped doc_tools) + endif() + endif() + endif() + + # Add benchmark meta target. It's collection of all benchmarks added/registered by + # 'qt_internal_add_benchmark' helper. + if(NOT TARGET benchmark) + add_custom_target(benchmark) + endif() + + if(QT_INTERNAL_SYNCED_MODULES) + set_property(GLOBAL PROPERTY _qt_synced_modules ${QT_INTERNAL_SYNCED_MODULES}) + endif() + + _qt_internal_sbom_begin_project( + INSTALL_PREFIX "${QT_STAGING_PREFIX}" + INSTALL_SBOM_DIR "${INSTALL_SBOMDIR}" + QT_CPE + ) +endmacro() + +# Runs delayed actions on some of the Qt targets. +# Can be called either explicitly or as part of qt_build_repo_end(). +macro(qt_build_repo_post_process) + if(NOT QT_INTERNAL_REPO_POST_PROCESS_CALLED) + set(QT_INTERNAL_REPO_POST_PROCESS_CALLED TRUE) + if(NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + include(QtPostProcess) + endif() + endif() +endmacro() + +macro(qt_build_repo_end) + if(NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + qt_build_repo_post_process() + + # Install the repo-specific cmake find modules. + qt_path_join(__qt_repo_install_dir ${QT_CONFIG_INSTALL_DIR} ${INSTALL_CMAKE_NAMESPACE}) + qt_path_join(__qt_repo_build_dir ${QT_CONFIG_BUILD_DIR} ${INSTALL_CMAKE_NAMESPACE}) + + if(NOT PROJECT_NAME STREQUAL "QtBase") + if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + qt_copy_or_install(DIRECTORY cmake/ + DESTINATION "${__qt_repo_install_dir}" + FILES_MATCHING PATTERN "Find*.cmake" + ) + if(QT_SUPERBUILD AND QT_WILL_INSTALL) + file(COPY cmake/ + DESTINATION "${__qt_repo_build_dir}" + FILES_MATCHING PATTERN "Find*.cmake" + ) + endif() + endif() + endif() + + if(NOT QT_SUPERBUILD) + qt_print_feature_summary() + endif() + endif() + + qt_build_internals_add_toplevel_targets(${qt_repo_targets_name}) + + qt_internal_show_extra_ide_sources() + + if(NOT QT_SUPERBUILD) + qt_print_build_instructions() + endif() + + get_property(synced_modules GLOBAL PROPERTY _qt_synced_modules) + if(synced_modules) + set(QT_INTERNAL_SYNCED_MODULES ${synced_modules} CACHE INTERNAL + "List of the synced modules. Prevents running syncqt.cpp after the first configuring.") + endif() + + if(NOT QT_SUPERBUILD) + qt_internal_save_previously_visited_packages() + endif() + + if(QT_INTERNAL_FRESH_REQUESTED) + set(QT_INTERNAL_FRESH_REQUESTED "FALSE" CACHE INTERNAL "") + endif() + + _qt_internal_sbom_end_project() + + if(NOT QT_SUPERBUILD) + qt_internal_qt_configure_end() + endif() + + list(POP_BACK CMAKE_MESSAGE_CONTEXT) +endmacro() + +function(qt_internal_show_extra_ide_sources) + if(CMAKE_VERSION VERSION_LESS 3.20) + set(ide_sources_default OFF) + else() + set(ide_sources_default ON) + endif() + + option(QT_SHOW_EXTRA_IDE_SOURCES "Generate CMake targets exposing non-source files to IDEs" ${ide_sources_default}) + if(CMAKE_VERSION VERSION_LESS 3.20 AND QT_SHOW_EXTRA_IDE_SOURCES) + message(WARNING "QT_SHOW_EXTRA_IDE_SOURCES requires cmake-3.20") + return() + endif() + + if(NOT QT_SHOW_EXTRA_IDE_SOURCES) + return() + endif() + + # coin + set(coin_target_name ${qt_repo_targets_name}_coin_files) + file(GLOB_RECURSE coin_files LIST_DIRECTORIES false FOLLOW_SYMLINKS coin/*) + if(coin_files) + source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}/coin" FILES ${coin_files}) + add_custom_target(${coin_target_name} SOURCES ${coin_files}) + endif() + + # config.test + set(config_tests_target_name ${qt_repo_targets_name}_config_tests) + file(GLOB_RECURSE config_tests_file LIST_DIRECTORIES false FOLLOW_SYMLINKS config.tests/*) + if(config_tests_file) + source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}/config.tests" FILES ${config_tests_file}) + add_custom_target(${config_tests_target_name} SOURCES ${config_tests_file}) + endif() + + # cmake + set(cmake_target_name ${qt_repo_targets_name}_cmake_files) + file(GLOB_RECURSE cmake_files LIST_DIRECTORIES false FOLLOW_SYMLINKS + cmake/* + configure.cmake + qt_cmdline.cmake + .cmake.conf + *.cmake + *.cmake.in) + foreach(cmake_file IN LISTS cmake_files) + if(NOT ((cmake_file IN_LIST coin_files) OR (file IN_LIST config_tests_files))) + list(APPEND cmake_target_files ${cmake_file}) + endif() + endforeach() + + if(cmake_target_files) + source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${cmake_target_files}) + add_custom_target(${cmake_target_name} SOURCES ${cmake_target_files}) + endif() + + # licenses + set(licenses_target_name ${qt_repo_targets_name}_licenses) + file(GLOB licenses_files LIST_DIRECTORIES false LICENSES/*) + if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/licenseRule.json") + list(APPEND licenses_files "${CMAKE_CURRENT_SOURCE_DIR}/licenseRule.json") + endif() + if(licenses_files) + source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${licenses_files}) + add_custom_target(${licenses_target_name} SOURCES ${licenses_files}) + endif() + + # changelogs + set(changelogs_target_name ${qt_repo_targets_name}_changelogs) + file(GLOB change_logs_files LIST_DIRECTORIES false dist/*) + if(change_logs_files) + source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}/dist" FILES ${change_logs_files}) + add_custom_target(${changelogs_target_name} SOURCES ${change_logs_files}) + endif() + + # extra files + set(target_name ${qt_repo_targets_name}_extra_files) + add_custom_target(${target_name}) + + set(recursive_glob_patterns + ${QT_BUILD_EXTRA_IDE_FILE_RECURSIVE_PATTERNS} + ) + set(simple_glob_patterns + .gitattributes + .gitignore + .tag + config_help.txt + ${QT_BUILD_EXTRA_IDE_FILE_PATTERNS} + ) + + if(recursive_glob_patterns) + file(GLOB_RECURSE files LIST_DIRECTORIES false FOLLOW_SYMLINKS ${recursive_glob_patterns}) + if(files) + source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${files}) + target_sources(${target_name} PRIVATE ${files}) + endif() + endif() + + file(GLOB files LIST_DIRECTORIES false ${simple_glob_patterns}) + if(files) + source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${files}) + target_sources(${target_name} PRIVATE ${files}) + endif() +endfunction() + + +# Function called either at the end of per-repo configuration, or at the end of configuration of +# a super build. +# At the moment it is called before examples are configured in a per-repo build. We might want +# to change that at some point if needed. +function(qt_internal_qt_configure_end) + # If Qt is configued via the configure script, remove the marker variable, so that any future + # reconfigurations that are done by calling cmake directly don't trigger configure specific + # logic. + if(QT_INTERNAL_CALLED_FROM_CONFIGURE) + unset(QT_INTERNAL_CALLED_FROM_CONFIGURE CACHE) + endif() +endfunction() + +macro(qt_build_repo) + qt_build_repo_begin(${ARGN}) + + qt_build_repo_impl_find_package_tests() + qt_build_repo_impl_src() + qt_build_repo_impl_tools() + + qt_build_repo_post_process() + qt_build_repo_impl_tests() + + qt_build_repo_end() + + qt_build_repo_impl_examples() +endmacro() + +macro(qt_build_repo_impl_find_package_tests) + # 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(QT_BUILD_TESTS AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + # When looking for the Test package, do it using the Qt6 package version, in case if + # PROJECT_VERSION is following a different versioning scheme. + if(Qt6_VERSION) + set(_qt_build_repo_impl_find_package_tests_version "${Qt6_VERSION}") + else() + set(_qt_build_repo_impl_find_package_tests_version "${PROJECT_VERSION}") + endif() + + find_package(Qt6 + "${_qt_build_repo_impl_find_package_tests_version}" + CONFIG REQUIRED COMPONENTS Test) + unset(_qt_build_repo_impl_find_package_tests_version) + endif() +endmacro() + +macro(qt_build_repo_impl_src) + if(NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/CMakeLists.txt") + add_subdirectory(src) + endif() + endif() + if(QT_FEATURE_lttng AND NOT TARGET LTTng::UST) + qt_find_package(LTTngUST PROVIDED_TARGETS LTTng::UST + MODULE_NAME global QMAKE_LIB lttng-ust) + endif() +endmacro() + +macro(qt_build_repo_impl_tools) + if(NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tools/CMakeLists.txt") + add_subdirectory(tools) + endif() + endif() +endmacro() + +macro(qt_build_repo_impl_tests) + if((QT_BUILD_TESTS OR QT_BUILD_STANDALONE_TESTS) + AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt") + if(QT_BUILD_STANDALONE_EXAMPLES) + message(FATAL_ERROR + "Can't build both standalone tests and standalone examples at once.") + endif() + string(TOLOWER "${PROJECT_NAME}" __qt_repo_project_name_lowercase) + option(QT_BUILD_TESTS_PROJECT_${__qt_repo_project_name_lowercase} + "Configure tests for project ${__qt_repo_project_name_lowercase}" TRUE) + + if (QT_BUILD_TESTS_PROJECT_${__qt_repo_project_name_lowercase}) + add_subdirectory(tests) + if(NOT QT_BUILD_TESTS_BY_DEFAULT) + set_property(DIRECTORY tests PROPERTY EXCLUDE_FROM_ALL TRUE) + endif() + endif() + unset(__qt_repo_project_name_lowercase) + endif() +endmacro() + +macro(qt_build_repo_impl_examples) + if((QT_BUILD_EXAMPLES OR QT_BUILD_STANDALONE_EXAMPLES) + AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/examples/CMakeLists.txt") + if(QT_BUILD_STANDALONE_TESTS) + message(FATAL_ERROR + "Can't build both standalone tests and standalone examples at once.") + endif() + + message(STATUS "Configuring examples.") + + string(TOLOWER "${PROJECT_NAME}" __qt_repo_project_name_lowercase) + option(QT_BUILD_EXAMPLES_PROJECT_${__qt_repo_project_name_lowercase} + "Configure examples for project ${__qt_repo_project_name_lowercase}" TRUE) + if(QT_BUILD_EXAMPLES_PROJECT_${__qt_repo_project_name_lowercase}) + + # Set this before any examples subdirectories are added, to warn about examples that are + # added via add_subdirectory() calls instead of qt_internal_add_example(). + if(QT_FEATURE_developer_build + AND NOT QT_NO_WARN_ABOUT_EXAMPLE_ADD_SUBDIRECTORY_WARNING) + set(QT_WARN_ABOUT_EXAMPLE_ADD_SUBDIRECTORY TRUE) + endif() + + add_subdirectory(examples) + endif() + unset(__qt_repo_project_name_lowercase) + 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() + +function(qt_get_standalone_parts_config_files_path out_var) + # TODO: Rename this to StandaloneParts in some future Qt version, if it confuses people too + # much. Currently not renamed, not to break distro installation scripts that might exclude + # the files. + set(dir_name "StandaloneTests") + + set(path_suffix "${INSTALL_LIBDIR}/cmake/${INSTALL_CMAKE_NAMESPACE}BuildInternals/${dir_name}") + + # Each repo's standalone parts might be configured with a unique CMAKE_STAGING_PREFIX, + # different from any previous one, and it might not coincide with where the BuildInternals + # config file is. + if(QT_WILL_INSTALL AND CMAKE_STAGING_PREFIX) + qt_path_join(path "${CMAKE_STAGING_PREFIX}" "${path_suffix}") + else() + qt_path_join(path "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}" "${path_suffix}") + endif() + + set("${out_var}" "${path}" PARENT_SCOPE) +endfunction() + +function(qt_internal_get_standalone_parts_config_file_name out_var) + # When doing a "single repo target set" build (like in qtscxqml) ensure we use a unique tests + # config file for each repo target set. Using the PROJECT_NAME only is not enough because + # the same file will be overridden with different content on each repo set install. + set(tests_config_file_name "${PROJECT_NAME}") + + if(QT_BUILD_SINGLE_REPO_TARGET_SET) + string(APPEND tests_config_file_name "RepoSet${QT_BUILD_SINGLE_REPO_TARGET_SET}") + endif() + + # TODO: Rename this to StandalonePartsConfig.cmake in some future Qt version, if it confuses + # people too much. Currently not renamed, not to break distro installation scripts that might + # exclude # the files. + string(APPEND tests_config_file_name "TestsConfig.cmake") + + set(${out_var} "${tests_config_file_name}" PARENT_SCOPE) +endfunction() + +macro(qt_internal_find_standalone_test_config_file) + if(QT_INTERNAL_BUILD_STANDALONE_PARTS) + # Of course we always need the test module as well. + # When looking for the Test package, do it using the Qt6 package version, in case if + # PROJECT_VERSION is following a different versioning scheme. + if(Qt6_VERSION) + set(_qt_build_tests_package_version "${Qt6_VERSION}") + else() + set(_qt_build_tests_package_version "${PROJECT_VERSION}") + endif() + find_package(Qt6 "${_qt_build_tests_package_version}" CONFIG REQUIRED COMPONENTS Test) + unset(_qt_build_tests_package_version) + endif() +endmacro() + +# Used by standalone tests and standalone non-ExternalProject examples to find all installed qt +# packages. +macro(qt_internal_find_standalone_parts_config_files) + if(QT_INTERNAL_BUILD_STANDALONE_PARTS) + # Find location of TestsConfig.cmake. These contain the modules that need to be + # find_package'd when building tests or examples. + qt_get_standalone_parts_config_files_path(_qt_build_parts_install_prefix) + + qt_internal_get_standalone_parts_config_file_name(_qt_parts_config_file_name) + set(_qt_standalone_parts_config_file_path + "${_qt_build_parts_install_prefix}/${_qt_parts_config_file_name}") + include("${_qt_standalone_parts_config_file_path}" + OPTIONAL + RESULT_VARIABLE _qt_standalone_parts_included) + if(NOT _qt_standalone_parts_included) + message(DEBUG + "Standalone parts config file not included because it does not exist: " + "${_qt_standalone_parts_config_file_path}" + ) + else() + message(DEBUG + "Standalone parts config file included successfully: " + "${_qt_standalone_parts_config_file_path}" + ) + endif() + + unset(_qt_standalone_parts_config_file_path) + unset(_qt_standalone_parts_included) + unset(_qt_parts_config_file_name) + endif() +endmacro() + +macro(qt_build_tests) + # Tests are not unity-ready. + set(CMAKE_UNITY_BUILD OFF) + + # Prepending to QT_BUILD_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(PREPEND CMAKE_FIND_ROOT_PATH "${QT_BUILD_DIR}") + list(PREPEND QT_BUILD_CMAKE_PREFIX_PATH "${QT_BUILD_DIR}/${INSTALL_LIBDIR}/cmake") + + qt_internal_find_standalone_parts_config_files() + qt_internal_find_standalone_test_config_file() + + if(QT_BUILD_STANDALONE_TESTS) + # Set language standards after finding Core, because that's when the relevant + # feature variables are available, and the call in QtSetup is too early when building + # standalone tests, because Core was not find_package()'d yet. + qt_set_language_standards() + + # Set up fake standalone parts install prefix, so we don't pollute the Qt install + # prefix with tests. + qt_internal_set_up_fake_standalone_parts_install_prefix() + else() + if(ANDROID) + # When building in-tree tests we need to specify the QT_ANDROID_ABIS list. Since we + # build Qt for the single ABI, build tests for this ABI only. + set(QT_ANDROID_ABIS "${CMAKE_ANDROID_ARCH_ABI}") + endif() + endif() + + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/auto/CMakeLists.txt") + add_subdirectory(auto) + endif() + if(NOT QT_BUILD_MINIMAL_STATIC_TESTS AND NOT QT_BUILD_MINIMAL_ANDROID_MULTI_ABI_TESTS) + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/baseline/CMakeLists.txt") + add_subdirectory(baseline) + 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" AND QT_BUILD_MANUAL_TESTS) + add_subdirectory(manual) + # Adding this logic to all tests impacts the configure time ~3sec in addition. We still + # might want this in the future for other test types since currently we have a moderate + # subset of tests that require manual initialization of autotools. + _qt_internal_collect_buildsystem_targets(targets + "${CMAKE_CURRENT_SOURCE_DIR}/manual" EXCLUDE UTILITY ALIAS) + 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() + endif() + endif() + + if(NOT QT_SUPERBUILD) + # In a super build, we don't want to finalize the batch blacklist at the end of each repo, + # but rather once at the end of the top-level configuration. + qt_internal_finalize_test_batch_blacklist() + endif() + + set(CMAKE_UNITY_BUILD ${QT_UNITY_BUILD}) +endmacro() + +function(qt_compute_relative_path_from_cmake_config_dir_to_prefix) + # Compute the reverse relative path from the CMake config dir to the install prefix. + # This is used in QtBuildInternalsExtras to create a relocatable relative install prefix path. + # This path is used for finding syncqt and other things, regardless of initial install prefix + # (e.g installed Qt was archived and unpacked to a different path on a different machine). + # + # This is meant to be called only once when configuring qtbase. + # + # Similar code exists in Qt6CoreConfigExtras.cmake.in and src/corelib/CMakeLists.txt which + # might not be needed anymore. + if(CMAKE_STAGING_PREFIX) + set(__qt_prefix "${CMAKE_STAGING_PREFIX}") + else() + set(__qt_prefix "${CMAKE_INSTALL_PREFIX}") + endif() + + if(QT_WILL_INSTALL) + get_filename_component(clean_config_prefix + "${__qt_prefix}/${QT_CONFIG_INSTALL_DIR}" ABSOLUTE) + else() + get_filename_component(clean_config_prefix "${QT_CONFIG_BUILD_DIR}" ABSOLUTE) + endif() + file(RELATIVE_PATH + qt_path_from_cmake_config_dir_to_prefix + "${clean_config_prefix}" "${__qt_prefix}") + set(qt_path_from_cmake_config_dir_to_prefix "${qt_path_from_cmake_config_dir_to_prefix}" + PARENT_SCOPE) +endfunction() + +function(qt_get_relocatable_install_prefix out_var) + # We need to compute it only once while building qtbase. Afterwards it's loaded from + # QtBuildInternalsExtras.cmake. + if(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX) + return() + endif() + # The QtBuildInternalsExtras value is dynamically computed, whereas the initial qtbase + # configuration uses an absolute path. + set(${out_var} "${CMAKE_INSTALL_PREFIX}" PARENT_SCOPE) +endfunction() + +function(qt_internal_get_fake_standalone_install_prefix out_var) + set(new_install_prefix "${CMAKE_BINARY_DIR}/fake_prefix") + set(${out_var} "${new_install_prefix}" PARENT_SCOPE) +endfunction() + +function(qt_internal_set_up_fake_standalone_parts_install_prefix) + # Set a fake local (non-cache) CMAKE_INSTALL_PREFIX. + # Needed for standalone tests, we don't want to accidentally install a test into the Qt prefix. + # Allow opt-out, if a user knows what they're doing. + if(QT_NO_FAKE_STANDALONE_TESTS_INSTALL_PREFIX) + return() + endif() + qt_internal_get_fake_standalone_install_prefix(new_install_prefix) + + # It's IMPORTANT that this is not a cache variable. Otherwise + # qt_get_standalone_parts_config_files_path() will not work on re-configuration. + message(STATUS + "Setting local standalone test install prefix (non-cached) to '${new_install_prefix}'.") + set(CMAKE_INSTALL_PREFIX "${new_install_prefix}" PARENT_SCOPE) + + # We also need to clear the staging prefix if it's set, otherwise CMake will modify any computed + # rpaths containing the staging prefix to point to the new fake prefix, which is not what we + # want. This replacement is done in cmComputeLinkInformation::GetRPath(). + # + # By clearing the staging prefix for the standalone tests, any detected link time + # rpaths will be embedded as-is, which will point to the place where Qt was installed (aka + # the staging prefix). + if(DEFINED CMAKE_STAGING_PREFIX) + message(STATUS "Clearing local standalone test staging prefix (non-cached).") + set(CMAKE_STAGING_PREFIX "" PARENT_SCOPE) + endif() +endfunction() + +# Meant to be called when configuring examples as part of the main build tree (unless standalone +# examples are being built), as well as for CMake tests (tests that call CMake to try and build +# CMake applications). +macro(qt_internal_set_up_build_dir_package_paths) + list(PREPEND CMAKE_PREFIX_PATH "${QT_BUILD_DIR}/${INSTALL_LIBDIR}/cmake") + + # Make sure the CMake config files do not recreate the already-existing targets. + if(NOT QT_BUILD_STANDALONE_EXAMPLES) + set(QT_NO_CREATE_TARGETS TRUE) + endif() +endmacro() + +function(qt_internal_static_link_order_test) + # The CMake versions greater than 3.21 take care about the resource object files order in a + # linker line, it's expected that all object files are located at the beginning of the linker + # line. + # No need to run the test. + if(CMAKE_VERSION VERSION_LESS 3.21) + __qt_internal_check_link_order_matters(link_order_matters) + if(link_order_matters) + set(summary_message "no") + else() + set(summary_message "yes") + endif() + else() + set(summary_message "yes") + endif() + qt_configure_add_summary_entry(TYPE "message" + ARGS "Linker can resolve circular dependencies" + MESSAGE "${summary_message}" + ) +endfunction() + +function(qt_internal_check_cmp0099_available) + # Don't care about CMP0099 in CMake versions greater than or equal to 3.21 + if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.21) + return() + endif() + + __qt_internal_check_cmp0099_available(result) + if(result) + set(summary_message "yes") + else() + set(summary_message "no") + endif() + qt_configure_add_summary_entry(TYPE "message" + ARGS "CMake policy CMP0099 is supported" + MESSAGE "${summary_message}" + ) +endfunction() + +function(qt_internal_run_common_config_tests) + qt_configure_add_summary_section(NAME "Common build options") + qt_internal_static_link_order_test() + qt_internal_check_cmp0099_available() + qt_configure_end_summary_section() +endfunction() + +# It is used in QtWebEngine to replace the REALPATH with ABSOLUTE path, which is +# useful for building Qt in Homebrew. +function(qt_internal_get_filename_path_mode out_var) + set(mode REALPATH) + if(APPLE AND QT_ALLOW_SYMLINK_IN_PATHS) + set(mode ABSOLUTE) + endif() + set(${out_var} ${mode} PARENT_SCOPE) +endfunction() + +macro(qt_internal_setup_platform_support_variables) + # 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) +endmacro() + +function(qt_build_internals_set_up_system_prefixes) + if(APPLE AND NOT FEATURE_pkg_config) + # Remove /usr/local and other paths like that which CMake considers as system prefixes on + # darwin platforms. CMake considers them as system prefixes, but in qmake / Qt land we only + # consider the SDK path as a system prefix. + # 3rd party libraries in these locations should not be picked up when building Qt, + # unless opted-in via the pkg-config feature, which in turn will disable this behavior. + # + # Note that we can't remove /usr as a system prefix path, because many programs won't be + # found then (e.g. perl). + set(QT_CMAKE_SYSTEM_PREFIX_PATH_BACKUP "${CMAKE_SYSTEM_PREFIX_PATH}" PARENT_SCOPE) + set(QT_CMAKE_SYSTEM_FRAMEWORK_PATH_BACKUP "${CMAKE_SYSTEM_FRAMEWORK_PATH}" PARENT_SCOPE) + + list(REMOVE_ITEM CMAKE_SYSTEM_PREFIX_PATH + "/usr/local" # Homebrew + "/opt/homebrew" # Apple Silicon Homebrew + "/usr/X11R6" + "/usr/pkg" + "/opt" + "/sw" # Fink + "/opt/local" # MacPorts + ) + if(_CMAKE_INSTALL_DIR) + list(REMOVE_ITEM CMAKE_SYSTEM_PREFIX_PATH "${_CMAKE_INSTALL_DIR}") + endif() + list(REMOVE_ITEM CMAKE_SYSTEM_FRAMEWORK_PATH "~/Library/Frameworks") + set(CMAKE_SYSTEM_PREFIX_PATH "${CMAKE_SYSTEM_PREFIX_PATH}" PARENT_SCOPE) + set(CMAKE_SYSTEM_FRAMEWORK_PATH "${CMAKE_SYSTEM_FRAMEWORK_PATH}" PARENT_SCOPE) + + # Also tell qt_find_package() not to use PATH when looking for packages. + # We can't simply set CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH to OFF because that will break + # find_program(), and for instance ccache won't be found. + # That's why we set a different variable which is used by qt_find_package. + set(QT_NO_USE_FIND_PACKAGE_SYSTEM_ENVIRONMENT_PATH "ON" PARENT_SCOPE) + endif() +endfunction() + +function(qt_build_internals_disable_pkg_config_if_needed) + # pkg-config should not be used by default on Darwin and Windows platforms (and QNX), as defined + # in the qtbase/configure.json. Unfortunately by the time the feature is evaluated there are + # already a few find_package() calls that try to use the FindPkgConfig module. + # Thus, we have to duplicate the condition logic here and disable pkg-config for those platforms + # by default. + # We also need to check if the pkg-config executable exists, to mirror the condition test in + # configure.json. We do that by trying to find the executable ourselves, and not delegating to + # the FindPkgConfig module because that has more unwanted side-effects. + # + # Note that on macOS, if the pkg-config feature is enabled by the user explicitly, we will also + # tell CMake to consider paths like /usr/local (Homebrew) as system paths when looking for + # packages. + # We have to do that because disabling these paths but keeping pkg-config + # enabled won't enable finding all system libraries via pkg-config alone, many libraries can + # only be found via FooConfig.cmake files which means /usr/local should be in the system prefix + # path. + + set(pkg_config_enabled ON) + qt_build_internals_find_pkg_config_executable() + + if(APPLE OR WIN32 OR QNX OR ANDROID OR WASM OR (NOT PKG_CONFIG_EXECUTABLE)) + set(pkg_config_enabled OFF) + endif() + + # If user explicitly specified a value for the feature, honor it, even if it might break + # the build. + if(DEFINED FEATURE_pkg_config) + if(FEATURE_pkg_config) + set(pkg_config_enabled ON) + else() + set(pkg_config_enabled OFF) + endif() + endif() + + set(FEATURE_pkg_config "${pkg_config_enabled}" CACHE STRING "Using pkg-config") + if(NOT pkg_config_enabled) + qt_build_internals_disable_pkg_config() + else() + unset(PKG_CONFIG_EXECUTABLE CACHE) + endif() +endfunction() + +# This is a copy of the first few lines in FindPkgConfig.cmake. +function(qt_build_internals_find_pkg_config_executable) + # find pkg-config, use PKG_CONFIG if set + if((NOT PKG_CONFIG_EXECUTABLE) AND (NOT "$ENV{PKG_CONFIG}" STREQUAL "")) + set(PKG_CONFIG_EXECUTABLE "$ENV{PKG_CONFIG}" CACHE FILEPATH "pkg-config executable") + endif() + find_program(PKG_CONFIG_EXECUTABLE NAMES pkg-config DOC "pkg-config executable") + mark_as_advanced(PKG_CONFIG_EXECUTABLE) +endfunction() + +function(qt_build_internals_disable_pkg_config) + # Disable pkg-config by setting an empty executable path. There's no documented way to + # mark the package as not found, but we can force all pkg_check_modules calls to do nothing + # by setting the variable to an empty value. + set(PKG_CONFIG_EXECUTABLE "" CACHE STRING "Disabled pkg-config usage." FORCE) +endfunction() + +macro(qt_build_internals_find_pkg_config) + # Find package config once before any system prefix modifications. + find_package(PkgConfig QUIET) +endmacro() + + +macro(qt_internal_setup_pkg_config_and_system_prefixes) + if(NOT QT_BUILD_INTERNALS_SKIP_PKG_CONFIG_ADJUSTMENT) + qt_build_internals_disable_pkg_config_if_needed() + endif() + + if(NOT QT_BUILD_INTERNALS_SKIP_FIND_PKG_CONFIG) + qt_build_internals_find_pkg_config() + endif() + + if(NOT QT_BUILD_INTERNALS_SKIP_SYSTEM_PREFIX_ADJUSTMENT) + qt_build_internals_set_up_system_prefixes() + endif() +endmacro() + +macro(qt_internal_setup_standalone_test_when_called_as_a_find_package_component) + if ("STANDALONE_TEST" IN_LIST Qt6BuildInternals_FIND_COMPONENTS) + include(${CMAKE_CURRENT_LIST_DIR}/QtStandaloneTestTemplateProject/Main.cmake) + if (NOT PROJECT_VERSION_MAJOR) + get_property(_qt_major_version TARGET ${QT_CMAKE_EXPORT_NAMESPACE}::Core PROPERTY INTERFACE_QT_MAJOR_VERSION) + set(PROJECT_VERSION ${Qt${_qt_major_version}Core_VERSION}) + + string(REPLACE "." ";" _qt_core_version_list ${PROJECT_VERSION}) + list(GET _qt_core_version_list 0 PROJECT_VERSION_MAJOR) + list(GET _qt_core_version_list 1 PROJECT_VERSION_MINOR) + list(GET _qt_core_version_list 2 PROJECT_VERSION_PATCH) + endif() + endif() +endmacro() + +macro(qt_internal_setup_build_internals) + qt_internal_set_qt_repo_dependencies() + qt_internal_setup_platform_support_variables() + qt_internal_setup_pkg_config_and_system_prefixes() + qt_internal_setup_standalone_test_when_called_as_a_find_package_component() +endmacro() + +# Recursively reads the dependencies section from dependencies.yaml in ${repo_dir} and returns the +# list of dependencies, including transitive ones, in out_var. +# +# The returned dependencies are topologically sorted. +# +# Example output for qtdeclarative: +# qtbase;qtimageformats;qtlanguageserver;qtshadertools;qtsvg +# +function(qt_internal_read_repo_dependencies out_var repo_dir) + set(seen ${ARGN}) + set(dependencies "") + set(in_dependencies_section FALSE) + set(dependencies_file "${repo_dir}/dependencies.yaml") + if(EXISTS "${dependencies_file}") + file(STRINGS "${dependencies_file}" lines) + foreach(line IN LISTS lines) + if(line MATCHES "^([^ ]+):") + if(CMAKE_MATCH_1 STREQUAL "dependencies") + set(in_dependencies_section TRUE) + else() + set(in_dependencies_section FALSE) + endif() + elseif(in_dependencies_section AND line MATCHES "^ (.+):$") + set(dependency "${CMAKE_MATCH_1}") + set(dependency_repo_dir "${repo_dir}/${dependency}") + string(REGEX MATCH "[^/]+$" dependency "${dependency}") + if(NOT dependency IN_LIST seen) + qt_internal_read_repo_dependencies(subdeps "${dependency_repo_dir}" + ${seen} ${dependency}) + if(dependency MATCHES "^tqtc-(.+)") + set(dependency "${CMAKE_MATCH_1}") + endif() + list(APPEND dependencies ${subdeps} ${dependency}) + endif() + endif() + endforeach() + list(REMOVE_DUPLICATES dependencies) + endif() + set(${out_var} "${dependencies}" PARENT_SCOPE) +endfunction() + +macro(qt_internal_set_qt_repo_dependencies) + # The top-level check needs to happen because it's possible + # to configure a top-level build with a few repos and then configure another repo + # using qt-configure-module in a separate build dir, where QT_SUPERBUILD will not + # be set anymore. + if(DEFINED QT_REPO_MODULE_VERSION AND NOT DEFINED QT_REPO_DEPENDENCIES AND NOT QT_SUPERBUILD) + qt_internal_read_repo_dependencies(QT_REPO_DEPENDENCIES "${PROJECT_SOURCE_DIR}") + endif() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildStaticDocToolsScript.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildStaticDocToolsScript.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3b71bc121b0dc17c62d91dd7c2073f38da6eb011 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtBuildStaticDocToolsScript.cmake @@ -0,0 +1,252 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +cmake_minimum_required(VERSION 3.16) + +# Query the var name from the CMake cache or the environment or use a default value. +function(qt_internal_get_cmake_or_env_or_default out_var var_name_to_check default_value) + if(${var_name_to_check}) + set(value "${var_name_to_check}") + elseif(DEFINED ENV{${var_name_to_check}}) + set(value "$ENV{${var_name_to_check}}") + else() + set(value "${default_value}") + endif() + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +# Prepares paths for the cloning of the sources, the build and the installation. +function(qt_internal_prepare_build_paths) + set(current_dir "${CMAKE_CURRENT_BINARY_DIR}") + + qt_internal_get_cmake_or_env_or_default(working_dir + QT_CI_DOC_TOOLS_WORKING_DIR "${current_dir}/qdoc_build") + + qt_internal_get_cmake_or_env_or_default(qt_src_dir + QT_CI_DOC_TOOLS_SRC_DIR "${working_dir}/qt5") + + qt_internal_get_cmake_or_env_or_default(qt_build_dir + QT_CI_DOC_TOOLS_BUILD__DIR "${working_dir}/build") + + qt_internal_get_cmake_or_env_or_default(qt_installed_dir + QT_CI_DOC_TOOLS_INSTALL_DIR "${working_dir}/install") + + set(QT_DOC_TOOLS_WORKING_DIR "${working_dir}" PARENT_SCOPE) + set(QT_DOC_TOOLS_SRC_DIR "${qt_src_dir}" PARENT_SCOPE) + set(QT_DOC_TOOLS_BUILD_DIR "${qt_build_dir}" PARENT_SCOPE) + set(QT_DOC_TOOLS_INSTALL_DIR "${qt_installed_dir}" PARENT_SCOPE) +endfunction() + +# Gets the remote git base URL for qt repositories. +function(qt_internal_get_repo_base_url out_var) + # This Coin CI git daemon IP is set in all CI jobs. + # Prefer using it when available, to avoid general network issues. + # Sample value: QT_COIN_GIT_DAEMON=10.215.0.212:9418 + qt_internal_get_cmake_or_env_or_default(coin_git_ip_port QT_COIN_GIT_DAEMON "") + + # Allow opting out of using the coin git daemon. + qt_internal_get_cmake_or_env_or_default(skip_coin_git QT_DOC_TOOLS_SKIP_COIN_GIT_DAEMON FALSE) + + # Allow override of the default remote. + qt_internal_get_cmake_or_env_or_default(git_remote QT_CI_DOC_TOOLS_GIT_REMOTE "") + + if(coin_git_ip_port AND NOT skip_coin_git) + set(value "git://${coin_git_ip_port}/qt-project") + elseif(git_remote) + set(value "${git_remote}") + else() + set(value "https://code.qt.io") + endif() + + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +# Clones qt5.git into the specified src directory. +function(qt_internal_clone_qt5) + file(MAKE_DIRECTORY "${QT_DOC_TOOLS_SRC_DIR}") + + qt_internal_get_repo_base_url(remote_url) + execute_process( + COMMAND git clone "${remote_url}/qt/qt5.git" "${QT_DOC_TOOLS_SRC_DIR}" + COMMAND_ECHO STDOUT + WORKING_DIRECTORY "${QT_DOC_TOOLS_WORKING_DIR}" + RESULT_VARIABLE result + ERROR_VARIABLE proc_err + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(result) + message(WARNING "Cloning qt5.git sources failed. Output: ${result}") + endif() + + # Allow pinning the qt5.git sha1 or any other git ref, based on a cmake var or env var. + qt_internal_get_cmake_or_env_or_default(super_repo_ref + QT_CI_DOC_TOOLS_TOP_LEVEL_PIN_GIT_REF "dev") + + # Allow using the branch that the Coin CI sets, as an opt-in. + qt_internal_get_cmake_or_env_or_default(use_ci_branch + QT_CI_DOC_TOOLS_USE_CI_TOP_LEVEL_BRANCH "OFF") + qt_internal_get_cmake_or_env_or_default(ci_branch + TESTED_MODULE_BRANCH_COIN "") + + if(use_ci_branch AND ci_branch) + set(super_repo_ref "${ci_branch}") + endif() + + execute_process( + COMMAND git checkout "${super_repo_ref}" + COMMAND_ECHO STDOUT + WORKING_DIRECTORY "${QT_DOC_TOOLS_SRC_DIR}" + RESULT_VARIABLE result + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(result) + message(FATAL_ERROR + "Checking out qt5.git '${super_repo_ref}' ref failed. Output: ${result}") + endif() +endfunction() + +# Checks out qttools to the dev branch (or other specified ref) and syncs its submodule +# dependencies according to qttools dependencies.yaml file. +function(qt_internal_sync_to_qttools) + execute_process( + COMMAND + git submodule update + --init + --recursive + --progress + --depth 1 + qttools + + # TODO: Remove these once the sync-to script is taught to automatically clone these. + qtbase + qtshadertools + qtdeclarative + qtsvg + qtimageformats + qtactiveqt + qtlanguageserver + + COMMAND_ECHO STDOUT + WORKING_DIRECTORY "${QT_DOC_TOOLS_SRC_DIR}" + RESULT_VARIABLE result + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(result) + message(FATAL_ERROR "Cloning qttools submodule failed. Output: ${result}") + endif() + + # Allow pinning the qttools sha1 or any other git ref, based on a cmake var or env var. + qt_internal_get_cmake_or_env_or_default(qttools_sync_to_ref QT_CI_DOC_TOOLS_PIN_GIT_REF "dev") + + execute_process( + COMMAND + ${CMAKE_COMMAND} + -DSYNC_TO_MODULE=qttools + "-DSYNC_TO_BRANCH=${qttools_sync_to_ref}" + -DSHOW_PROGRESS=1 + -DVERBOSE=1 + -P cmake/QtSynchronizeRepo.cmake + --log-level=DEBUG + COMMAND_ECHO STDOUT + WORKING_DIRECTORY "${QT_DOC_TOOLS_SRC_DIR}" + RESULT_VARIABLE result + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(result) + message(FATAL_ERROR "Syncing qttools submodule dependencies failed: Output: ${result}") + endif() +endfunction() + +# Configures a top-level static qt build for the checked out qt5.git sources. +function(qt_internal_configure_qt) + file(MAKE_DIRECTORY "${QT_DOC_TOOLS_BUILD_DIR}") + file(MAKE_DIRECTORY "${QT_DOC_TOOLS_INSTALL_DIR}") + + # Get the common CI args, to set the sccache args, etc. + qt_internal_get_cmake_or_env_or_default(ci_common_cmake_args COMMON_CMAKE_ARGS "") + if(ci_common_cmake_args) + separate_arguments(ci_common_cmake_args NATIVE_COMMAND ${ci_common_cmake_args}) + endif() + + execute_process( + COMMAND + "${QT_DOC_TOOLS_SRC_DIR}/configure" + -release + -static + -prefix "${QT_DOC_TOOLS_INSTALL_DIR}" + # Skip optional dependencies we don't need to build. + -skip qtactiveqt,qtimageformats,qtlanguageserver,qtsvg + -- + -DWARNINGS_ARE_ERRORS=OFF + --log-level STATUS + --fresh + -GNinja + ${ci_common_cmake_args} + + COMMAND_ECHO STDOUT + WORKING_DIRECTORY "${QT_DOC_TOOLS_BUILD_DIR}" + RESULT_VARIABLE result + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(result) + message(FATAL_ERROR "Configuring top-level qt5.git build failed. Output: ${result}") + endif() +endfunction() + +# Builds the main doc tools in a configured qt5.git build. +function(qt_internal_build_tools) + execute_process( + COMMAND + cmake + --build . + --verbose + --parallel + --target + qdoc + qtattributionsscanner + qdbusxml2cpp + qdbuscpp2xml + qvkgen + COMMAND_ECHO STDOUT + WORKING_DIRECTORY "${QT_DOC_TOOLS_BUILD_DIR}" + RESULT_VARIABLE result + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(result) + message(FATAL_ERROR "Failed to build doc tools. Output: ${result}") + endif() +endfunction() + +# Installs the built doc tools. +function(qt_internal_install_tools) + execute_process( + COMMAND + cmake + --build . + --target + # TODO: Replace with ninja install_doc_tools_stripped once it lands. + qttools/src/qdoc/qdoc/install/strip + qttools/src/qtattributionsscanner/install/strip + qtbase/src/tools/qdbusxml2cpp/install/strip + qtbase/src/tools/qdbuscpp2xml/install/strip + qtbase/src/tools/qvkgen/install/strip + COMMAND_ECHO STDOUT + WORKING_DIRECTORY "${QT_DOC_TOOLS_BUILD_DIR}" + RESULT_VARIABLE result + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(result) + message(FATAL_ERROR "Failed to install doc tools. Output: ${result}") + endif() +endfunction() + +function(qt_internal_run_script) + qt_internal_prepare_build_paths() + qt_internal_clone_qt5() + qt_internal_sync_to_qttools() + qt_internal_configure_qt() + qt_internal_build_tools() + qt_internal_install_tools() +endfunction() + +qt_internal_run_script() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakeHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakeHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0e340b8be1ada5dddfa947769fac4ed5eb01d887 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakeHelpers.cmake @@ -0,0 +1,176 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# The common implementation of qt_configure_file functionality. +macro(qt_configure_file_impl) + if(NOT arg_OUTPUT) + message(FATAL_ERROR "No output file provided to qt_configure_file.") + endif() + + # We use this check for the cases when the specified CONTENT is empty. The value of arg_CONTENT + # is undefined, but we still want to create a file with empty content. + if(NOT "CONTENT" IN_LIST arg_KEYWORDS_MISSING_VALUES) + if(arg_INPUT) + message(WARNING "Both CONTENT and INPUT are specified. CONTENT will be used to generate" + " output") + endif() + set(template_name "QtFileConfigure.txt.in") + # When building qtbase, use the source template file. + # Otherwise use the installed file (basically wherever Qt6 package is found). + # This should work for non-prefix and superbuilds as well. + if(QtBase_SOURCE_DIR) + set(input_file "${QtBase_SOURCE_DIR}/cmake/${template_name}") + else() + set(input_file "${_qt_6_config_cmake_dir}/${template_name}") + endif() + set(__qt_file_configure_content "${arg_CONTENT}") + elseif(arg_INPUT) + set(input_file "${arg_INPUT}") + else() + message(FATAL_ERROR "No input value provided to qt_configure_file.") + endif() + + configure_file("${input_file}" "${arg_OUTPUT}" @ONLY) +endmacro() + +# qt_configure_file(OUTPUT output-file ) +# input-file is relative to ${CMAKE_CURRENT_SOURCE_DIR} +# output-file is relative to ${CMAKE_CURRENT_BINARY_DIR} +# +# This function is similar to file(GENERATE OUTPUT) except it writes the content +# to the file at configure time, rather than at generate time. +# +# TODO: Once we require 3.18+, this can use file(CONFIGURE) in its implementation, +# or maybe its usage can be replaced by file(CONFIGURE). Until then, it uses +# configure_file() with a generic input file as source, when used with the CONTENT +# signature. +function(qt_configure_file) + cmake_parse_arguments(PARSE_ARGV 0 arg "" "OUTPUT;INPUT;CONTENT" "") + qt_configure_file_impl() +endfunction() + +# A version of cmake_parse_arguments that makes sure all arguments are processed and errors out +# with a message about ${type} having received unknown arguments. +# +# TODO: Remove when all usage of qt_parse_all_arguments were replaced by +# cmake_parse_all_arguments(PARSEARGV) instances +macro(qt_parse_all_arguments result type flags options multiopts) + cmake_parse_arguments(${result} "${flags}" "${options}" "${multiopts}" ${ARGN}) + if(DEFINED ${result}_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown arguments were passed to ${type} (${${result}_UNPARSED_ARGUMENTS}).") + endif() +endmacro() + +# Print all variables defined in the current scope. +macro(qt_debug_print_variables) + cmake_parse_arguments(__arg "DEDUP" "" "MATCH;IGNORE" ${ARGN}) + message("Known Variables:") + get_cmake_property(__variableNames VARIABLES) + list (SORT __variableNames) + if (__arg_DEDUP) + list(REMOVE_DUPLICATES __variableNames) + endif() + + foreach(__var ${__variableNames}) + set(__ignore OFF) + foreach(__i ${__arg_IGNORE}) + if(__var MATCHES "${__i}") + set(__ignore ON) + break() + endif() + endforeach() + + if (__ignore) + continue() + endif() + + set(__show OFF) + foreach(__i ${__arg_MATCH}) + if(__var MATCHES "${__i}") + set(__show ON) + break() + endif() + endforeach() + + if (__show) + message(" ${__var}=${${__var}}.") + endif() + endforeach() +endmacro() + +macro(assert) + if (${ARGN}) + else() + message(FATAL_ERROR "ASSERT: ${ARGN}.") + endif() +endmacro() + +# Takes a list of path components and joins them into one path separated by forward slashes "/", +# and saves the path in out_var. +function(qt_path_join out_var) + _qt_internal_path_join(path ${ARGN}) + set(${out_var} ${path} PARENT_SCOPE) +endfunction() + +function(qt_remove_args out_var) + _qt_internal_remove_args(result ${ARGN}) + set(${out_var} "${result}" PARENT_SCOPE) +endfunction() + +# Creates a regular expression that exactly matches the given string +# Found in https://gitlab.kitware.com/cmake/cmake/issues/18580 +function(qt_re_escape out_var str) + string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" regex "${str}") + set(${out_var} ${regex} PARENT_SCOPE) +endfunction() + +# Input: string +# Output: regex string to match the string case insensitively +# Example: "Release" -> "^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$" +# +# Regular expressions like this are used in cmake_install.cmake files for case-insensitive string +# comparison. +function(qt_create_case_insensitive_regex out_var input) + set(result "^(") + string(LENGTH "${input}" n) + math(EXPR n "${n} - 1") + foreach(i RANGE 0 ${n}) + string(SUBSTRING "${input}" ${i} 1 c) + string(TOUPPER "${c}" uc) + string(TOLOWER "${c}" lc) + string(APPEND result "[${uc}${lc}]") + endforeach() + string(APPEND result ")$") + set(${out_var} "${result}" PARENT_SCOPE) +endfunction() + +# Gets a target property, and returns "" if the property was not found +function(qt_internal_get_target_property out_var target property) + get_target_property(result "${target}" "${property}") + if("${result}" STREQUAL "result-NOTFOUND") + set(result "") + endif() + set(${out_var} "${result}" PARENT_SCOPE) +endfunction() + +# Creates a wrapper ConfigVersion.cmake file to be loaded by find_package when checking for +# compatible versions. It expects a ConfigVersionImpl.cmake file in the same directory which will +# be included to do the regular version checks. +# The version check result might be overridden by the wrapper. +# package_name is used by the content of the wrapper file to include the basic package version file. +# example: Qt6Gui +# out_path should be the build path where the write the file. +function(qt_internal_write_qt_package_version_file package_name out_path) + set(extra_code "") + + # Need to check for FEATURE_developer_build as well, because QT_FEATURE_developer_build is not + # yet available when configuring the file for the BuildInternals package. + if(FEATURE_developer_build OR QT_FEATURE_developer_build) + string(APPEND extra_code " +# Disabling version check because Qt was configured with -developer-build. +set(__qt_disable_package_version_check TRUE) +set(__qt_disable_package_version_check_due_to_developer_build TRUE)") + endif() + + configure_file("${QT_CMAKE_DIR}/QtCMakePackageVersionFile.cmake.in" "${out_path}" @ONLY) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakePackageVersionFile.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakePackageVersionFile.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..ca1155fb87cf5027b960926fe1b8aa925de3bbf8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakePackageVersionFile.cmake.in @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/@package_name@ConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin +@extra_code@ +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakeVersionHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakeVersionHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7ec50700b7887457c6bcf597e4f63ad1c6d35245 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCMakeVersionHelpers.cmake @@ -0,0 +1,236 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Returns the minimum supported CMake version required to /build/ Qt as originally advertised by Qt. +function(qt_internal_get_supported_min_cmake_version_for_building_qt out_var) + if(NOT DEFINED BUILD_SHARED_LIBS) + message(FATAL_ERROR "BUILD_SHARED_LIBS is needed to decide the minimum CMake version. " + "It should have been set by this point.") + endif() + + # First check if a value is already set in QtBuildInternalsExtras.cmake, which means we're + # building a repo other than qtbase and the minimum version was already recorded. + if(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT) + set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT}") + + # We're building qtbase so the values come from .cmake.conf. + elseif(APPLE) + set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_APPLE}") + elseif(BUILD_SHARED_LIBS) + set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_SHARED}") + else() + set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_STATIC}") + endif() + + set(${out_var} "${supported_version}" PARENT_SCOPE) +endfunction() + +# Returns the minimum supported CMake version required to /use/ Qt as originally advertised by Qt. +function(qt_internal_get_supported_min_cmake_version_for_using_qt out_var) + if(NOT DEFINED BUILD_SHARED_LIBS) + message(FATAL_ERROR "BUILD_SHARED_LIBS is needed to decide the minimum CMake version. " + "It should have been set by this point.") + endif() + + if(APPLE) + set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_APPLE}") + elseif(BUILD_SHARED_LIBS) + set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_SHARED}") + else() + set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_STATIC}") + endif() + + set(${out_var} "${supported_version}" PARENT_SCOPE) +endfunction() + +# Returns the computed minimum supported CMake version required to /build/ Qt. +function(qt_internal_get_computed_min_cmake_version_for_building_qt out_var) + # An explicit override for those that take it upon themselves to fix the build system + # when using a CMake version lower than the one officially supported. + # Also useful for build testing locally with different minimum versions to observe different + # policy behaviors. + if(QT_FORCE_MIN_CMAKE_VERSION_FOR_BUILDING_QT) + set(computed_min_version "${QT_FORCE_MIN_CMAKE_VERSION_FOR_BUILDING_QT}") + + # Set in QtBuildInternalsExtras.cmake, which means it was already computed as part of qtbase + # configuration. + elseif(QT_COMPUTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT) + set(computed_min_version "${QT_COMPUTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT}") + + # No override was given and the version was not computed before, thus initialize with the + # default minimum. + else() + qt_internal_get_supported_min_cmake_version_for_building_qt(min_supported_version) + set(computed_min_version "${min_supported_version}") + endif() + set(${out_var} "${computed_min_version}" PARENT_SCOPE) +endfunction() + +# Returns the computed minimum supported CMake version required to /use/ Qt. +function(qt_internal_get_computed_min_cmake_version_for_using_qt out_var) + # Allow overriding the required minimum CMake version for user projects, without forcing + # each project developer to have to override it manually. + if(QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT) + set(computed_min_version "${QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT}") + + # No override was given, thus initialize with the default minimum. + else() + qt_internal_get_supported_min_cmake_version_for_using_qt(min_supported_version) + set(computed_min_version "${min_supported_version}") + endif() + set(${out_var} "${computed_min_version}" PARENT_SCOPE) +endfunction() + +# Returns the oldest CMake version for which NEW policies should be enabled. +# It can be older than the minimum supported or computed CMake version, as it +# is only used for policy settings. The currently running CMake must not be +# older than this version though (doing so will result in an error). +function(qt_internal_get_min_new_policy_cmake_version out_var) + # QT_MIN_NEW_POLICY_CMAKE_VERSION is set either in .cmake.conf or in + # QtBuildInternalsExtras.cmake when building a child repo. + set(lower_version "${QT_MIN_NEW_POLICY_CMAKE_VERSION}") + set(${out_var} "${lower_version}" PARENT_SCOPE) +endfunction() + +# Returns the latest CMake version for which NEW policies should be enabled. +# This cannot be less than the minimum CMake policy version or we will end up +# specifying a version range with the max less than the min. +function(qt_internal_get_max_new_policy_cmake_version out_var) + # QT_MAX_NEW_POLICY_CMAKE_VERSION is set either in .cmake.conf or in + # QtBuildInternalsExtras.cmake when building a child repo. + set(upper_version "${QT_MAX_NEW_POLICY_CMAKE_VERSION}") + qt_internal_get_min_new_policy_cmake_version(lower_version) + if(upper_version VERSION_LESS lower_version) + set(upper_version ${lower_version}) + endif() + set(${out_var} "${upper_version}" PARENT_SCOPE) +endfunction() + +function(qt_internal_check_and_warn_about_unsuitable_cmake_version) + # Don't show the warnings multiple times in a top-level build. + get_cmake_property(check_done _qt_unsuitable_cmake_version_check_done) + if(check_done) + return() + endif() + set_property(GLOBAL PROPERTY _qt_unsuitable_cmake_version_check_done TRUE) + + qt_internal_warn_if_min_cmake_version_not_met() + qt_internal_warn_about_buggy_cmake_versions() +endfunction() + +# Function to be used in downstream repos (like qtsvg) to require a minimum CMake version and warn +# about unsuitable cmake versions. +# +# Such repos don't have the required version information at cmake_minimum_required() time, that's +# why we provide this function to be called at a time when the info is available. +function(qt_internal_require_suitable_cmake_version) + qt_internal_check_and_warn_about_unsuitable_cmake_version() + qt_internal_get_computed_min_cmake_version_for_building_qt(computed_min_version) + + if(CMAKE_VERSION VERSION_LESS computed_min_version) + set(major_minor "${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}") + message(FATAL_ERROR + "CMake ${computed_min_version} or higher is required. " + "You are running version ${CMAKE_VERSION} " + "\nQt requires newer CMake features to build correctly. You can lower the minimum " + "required version by passing " + "-DQT_FORCE_MIN_CMAKE_VERSION_FOR_BUILDING_QT=${major_minor} when configuring Qt. " + "Building Qt with this CMake version is not officially supported. Use at your own risk." + ) + endif() +endfunction() + +function(qt_internal_warn_if_min_cmake_version_not_met) + qt_internal_get_supported_min_cmake_version_for_building_qt(min_supported_version) + qt_internal_get_computed_min_cmake_version_for_building_qt(computed_min_version) + + if(NOT min_supported_version STREQUAL computed_min_version + AND computed_min_version VERSION_LESS min_supported_version) + message(WARNING + "The minimum required CMake version to build Qt is: '${min_supported_version}'. " + "You have explicitly chosen to require a lower minimum CMake version: '${computed_min_version}'. " + "Building Qt with this CMake version is not officially supported. Use at your own risk.") + endif() +endfunction() + +function(qt_internal_warn_about_buggy_cmake_versions) + set(unsuitable_versions "") + + # Touching a library's source file causes unnecessary rebuilding of unrelated targets. + # https://gitlab.kitware.com/cmake/cmake/-/issues/21020 + list(APPEND unsuitable_versions "3.18.0") + + # Ninja Multi-Config race condition overrides response files of different configurations + # https://gitlab.kitware.com/cmake/cmake/-/issues/20961 + # https://gitlab.kitware.com/cmake/cmake/-/issues/21050 (follow up issue) + list(APPEND unsuitable_versions "3.18.1") + + # AUTOMOC dependencies are not properly created when using Ninja Multi-Config. + # https://gitlab.kitware.com/cmake/cmake/-/issues/21118 + # + # Also until 3.18.2 inclusive, AUTOMOC dependencies are out-of-date if a previously header + # disappears (for example when upgrading a compiler) + # https://gitlab.kitware.com/cmake/cmake/-/issues/21136 + # + # Also multi-arch PCH doesn't work on iOS. Can't quite find the original upstream CMake issue + # but the Qt one was detected at https://codereview.qt-project.org/c/qt/qt5/+/310947 + # And a follow up issue regarding PCH and -fembed-bitcode failing. + # https://gitlab.kitware.com/cmake/cmake/-/issues/21163 + list(APPEND unsuitable_versions "3.18.2") + + # Cyclic dependencies are created when mixing AUTOMOC/AUTOUIC with sources + # that have their SKIP_MOC or SKIP_UIC source file properties set to true. + # https://gitlab.kitware.com/cmake/cmake/-/issues/21977 + list(APPEND unsuitable_versions "3.20.0") + + # AUTOMOC can crash or hang when using a Qt that supports moc depfiles. + # Issues reported on Windows with Ninja and Makefiles, but it could be happening + # on other platforms too. + # https://gitlab.kitware.com/cmake/cmake/-/issues/22014 + list(APPEND unsuitable_versions "3.20.1") + + # Cyclic dependencies can happen when the AUTOMOC / AUTOUIC include directory is added as a + # target include directory. + # https://gitlab.kitware.com/cmake/cmake/-/merge_requests/6380 + # https://gitlab.kitware.com/cmake/cmake/-/merge_requests/6359 + # https://gitlab.kitware.com/cmake/cmake/-/issues/16776 + list(APPEND unsuitable_versions "3.21.0") + + # Changing a C++ source file can trigger rebuilds of a lot of other source files that might + # include AUTOGEN'ed headers or sources. + # https://gitlab.kitware.com/cmake/cmake/-/issues/22531 + # Fixed in 3.21.2. + list(APPEND unsuitable_versions "3.21.1") + + foreach(unsuitable_version ${unsuitable_versions}) + if(CMAKE_VERSION VERSION_EQUAL unsuitable_version) + message(WARNING + "The CMake version you are using is known to cause issues when building Qt. " + "Please upgrade to a newer version. " + "CMake version used: '${unsuitable_version}'") + endif() + endforeach() + + # Ninja Multi-Config was introduced in 3.17, but we recommend 3.18. + set(min_nmc_cmake_version "3.18.3") + if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config" + AND CMAKE_VERSION VERSION_LESS ${min_nmc_cmake_version}) + message(WARNING + "You are using CMake ${CMAKE_VERSION} with the Ninja Multi-Config generator. " + "This combination is unsupported. " + "Please upgrade to at least CMake ${min_nmc_cmake_version}. ") + endif() +endfunction() + +# Used to upgrade policies only when building Qt repositories. +# +# Functions don't have their own policy scope, so the policy settings modified +# here will be those of the caller's policy scope. Note that these settings +# will only apply to functions and macros defined after this function is called, +# but not to any that are already defined. Ordinary CMake code not inside a +# function or macro will be affected by these policy settings too. +function(qt_internal_upgrade_cmake_policies) + qt_internal_get_computed_min_cmake_version_for_building_qt(lower_version) + qt_internal_get_max_new_policy_cmake_version(upper_version) + cmake_minimum_required(VERSION ${lower_version}...${upper_version}) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCompilerFlags.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCompilerFlags.cmake new file mode 100644 index 0000000000000000000000000000000000000000..69277c99b79877efd7b2425dd14c81341b6c2149 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCompilerFlags.cmake @@ -0,0 +1,39 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Enable compiler warnings by default. All compilers except MSVC support -Wall -Wextra +# +# You can disable the warnings for specific targets (for instance containing 3rd party code) +# by calling qt_disable_warnings(target). This will set the QT_COMPILE_OPTIONS_DISABLE_WARNINGS +# property checked below, and is equivalent to qmake's CONFIG += warn_off. + +set(_qt_compiler_warning_flags_on "") +set(_qt_compiler_warning_flags_off -w) + +if (MSVC) + list(APPEND _qt_compiler_warning_flags_on /W3) +else() + if(CMAKE_CXX_COMPILER_ID STREQUAL "GHS") # There is no -Wextra flag for GHS compiler. + list(APPEND _qt_compiler_warning_flags_on -Wall) + else() + list(APPEND _qt_compiler_warning_flags_on -Wall -Wextra) + endif() +endif() + +set(_qt_compiler_warning_flags_condition + "$>") +set(_qt_compiler_warning_flags_genex + "$") + +set(_qt_compiler_warning_flags_language_condition + "$") +set(_qt_compiler_warning_flags_language_conditional_genex + "$<${_qt_compiler_warning_flags_language_condition}:${_qt_compiler_warning_flags_genex}>") + + +# Need to replace semicolons so that the list is not wrongly expanded in the add_compile_options +# call. +string(REPLACE ";" "$" + _qt_compiler_warning_flags_language_conditional_genex + "${_qt_compiler_warning_flags_language_conditional_genex}") +add_compile_options(${_qt_compiler_warning_flags_language_conditional_genex}) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCompilerOptimization.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCompilerOptimization.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9627810cee3d1e676bdc0a670dd016a6586d8fe8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCompilerOptimization.cmake @@ -0,0 +1,138 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if (MSVC) + if (QT_64BIT) + # SSE2 is mandatory on 64-bit mode, so skip the option. It triggers: + # cl : Command line warning D9002 : ignoring unknown option '-arch:SSE2' + set(QT_CFLAGS_SSE2 "") + else() + set(QT_CFLAGS_SSE2 "-arch:SSE2") + endif() + set(QT_CFLAGS_SSE3 "${QT_CFLAGS_SSE2}") + set(QT_CFLAGS_SSSE3 "${QT_CFLAGS_SSE2}") + set(QT_CFLAGS_SSE4_1 "${QT_CFLAGS_SSE2}") + set(QT_CFLAGS_SSE4_2 "${QT_CFLAGS_SSE2}") + set(QT_CFLAGS_AESNI "${QT_CFLAGS_SSE2}") + set(QT_CFLAGS_SHANI "${QT_CFLAGS_SSE2}") + + set(QT_CFLAGS_AVX "-arch:AVX") + set(QT_CFLAGS_AVX2 "-arch:AVX2") + set(QT_CFLAGS_F16C "-arch:AVX") + set(QT_CFLAGS_RDRND "") + set(QT_CFLAGS_RDSEED "") + set(QT_CFLAGS_AVX512F "-arch:AVX512") + set(QT_CFLAGS_AVX512ER "-arch:AVX512") + set(QT_CFLAGS_AVX512CD "-arch:AVX512") + set(QT_CFLAGS_AVX512PF "-arch:AVX512") + set(QT_CFLAGS_AVX512DQ "-arch:AVX512") + set(QT_CFLAGS_AVX512BW "-arch:AVX512") + set(QT_CFLAGS_AVX512VL "-arch:AVX512") + set(QT_CFLAGS_AVX512IFMA "-arch:AVX512") + set(QT_CFLAGS_AVX512VBMI "-arch:AVX512") + set(QT_CFLAGS_AVX512VBMI2 "-arch:AVX512") + set(QT_CFLAGS_VAES "") +endif() + +if(GCC OR CLANG OR QCC) + set(__prefix) + if(MSVC AND CLANG) + set(__prefix "/clang:") + endif() + set(QT_CFLAGS_SSE2 "${__prefix}-msse2") + set(QT_CFLAGS_SSE3 "${__prefix}-msse3") + set(QT_CFLAGS_SSSE3 "${__prefix}-mssse3") + set(QT_CFLAGS_SSE4_1 "${__prefix}-msse4.1") + set(QT_CFLAGS_SSE4_2 "${__prefix}-msse4.2") + set(QT_CFLAGS_F16C "${__prefix}-mf16c") + set(QT_CFLAGS_RDRND "${__prefix}-mrdrnd") + set(QT_CFLAGS_RDSEED "${__prefix}-mrdseed") + set(QT_CFLAGS_AVX "${__prefix}-mavx") + set(QT_CFLAGS_AVX2 "${__prefix}-mavx2") + set(QT_CFLAGS_ARCH_HASWELL "${__prefix}-march=haswell") + set(QT_CFLAGS_AVX512F "${__prefix}-mavx512f") + set(QT_CFLAGS_AVX512ER "${__prefix}-mavx512er") + set(QT_CFLAGS_AVX512CD "${__prefix}-mavx512cd") + set(QT_CFLAGS_AVX512PF "${__prefix}-mavx512pf") + set(QT_CFLAGS_AVX512DQ "${__prefix}-mavx512dq") + set(QT_CFLAGS_AVX512BW "${__prefix}-mavx512bw") + set(QT_CFLAGS_AVX512VL "${__prefix}-mavx512vl") + set(QT_CFLAGS_AVX512IFMA "${__prefix}-mavx512ifma") + set(QT_CFLAGS_AVX512VBMI "${__prefix}-mavx512vbmi") + set(QT_CFLAGS_AVX512VBMI2 "${__prefix}-mavx512vbmi2") + set(QT_CFLAGS_AESNI "${__prefix}-maes") + set(QT_CFLAGS_SHANI "${__prefix}-msha") + set(QT_CFLAGS_VAES "${__prefix}-mvaes") + if(NOT UIKIT AND NOT QT_64BIT) + set(QT_CFLAGS_NEON "${__prefix}-mfpu=neon") + endif() + set(QT_CFLAGS_MIPS_DSP "${__prefix}-mdsp") + set(QT_CFLAGS_MIPS_DSPR2 "${__prefix}-mdspr2") + unset(__prefix) +endif() + +# Fall through is important, so that more specific flags that might be missing are set by the +# previous base cases. +# This mirrors qmake's mkspecs QMAKE_CFLAGS_OPTIMIZE assignments (mostly). +# +# TODO: Missing mkspecs flags we don't handle below: win32-clang-g++, win32-clang-msvc, rtems-base +# +# gcc and clang base +if(GCC OR CLANG) + set(QT_CFLAGS_OPTIMIZE "-O2") + set(QT_CFLAGS_OPTIMIZE_FULL "-O3") + set(QT_CFLAGS_OPTIMIZE_DEBUG "-Og") + set(QT_CFLAGS_OPTIMIZE_SIZE "-Os") + + if(CLANG) + set(QT_CFLAGS_OPTIMIZE_SIZE "-Oz") + endif() +endif() + +# Flags that CMake might set, aka flags the compiler would see as valid values. +if(GCC OR CLANG OR QCC) + set(QT_CFLAGS_OPTIMIZE_VALID_VALUES "-O0" "-O1" "-O2" "-O3" "-Os" "-Oz") +endif() + + +# Windows MSVC +if(MSVC) + set(QT_CFLAGS_OPTIMIZE "-O2") + if(NOT CLANG) + # -Ob3 was introduced in Visual Studio 2019 version 16.0 + # However clang-cl can't recognize it. + string(APPEND QT_CFLAGS_OPTIMIZE " -Ob3 ") + endif() + set(QT_CFLAGS_OPTIMIZE_DEBUG "-Od") + set(QT_CFLAGS_OPTIMIZE_SIZE "-O1") + set(QT_CFLAGS_OPTIMIZE_VALID_VALUES "/O2" "/O1" "/Od" "/Ob0" "/Ob1" "/Ob2" "/Ob3" "/O0" "-O0") + + if(CLANG) + set(QT_CFLAGS_OPTIMIZE_FULL "/clang:-O3") + set(QT_CFLAGS_OPTIMIZE_SIZE "/clang:-Oz") + endif() +endif() + +# Android Clang +if(CLANG AND ANDROID) + if(QT_FEATURE_ltcg) + # When using LTCG, the linker cannot cope with -Oz. See QTBUG-89472 for details. + set(QT_CFLAGS_OPTIMIZE "-O2") + set(QT_CFLAGS_OPTIMIZE_FULL "-O3") + else() + set(QT_CFLAGS_OPTIMIZE "-Oz") + set(QT_CFLAGS_OPTIMIZE_FULL "-Oz") + endif() +endif() + +# qcc +if (QCC) + set(QT_CFLAGS_OPTIMIZE "-O2") + set(QT_CFLAGS_OPTIMIZE_FULL "-O3") +endif() + +# Emscripten Clang +if(WASM) + set(QT_CFLAGS_OPTIMIZE_DEBUG "-O2 -g") # -Og is not supported + set(QT_CFLAGS_SSE2 "-O2 -msimd128 -msse -msse2") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtConfigDependencies.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtConfigDependencies.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..3b64a40e112a7234033cbfe33a56a22bc028629d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtConfigDependencies.cmake.in @@ -0,0 +1,33 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(@INSTALL_CMAKE_NAMESPACE@_FOUND FALSE) + +if(DEFINED QT_REQUIRE_HOST_PATH_CHECK) + set(__qt_platform_requires_host_info_package "${QT_REQUIRE_HOST_PATH_CHECK}") +elseif(DEFINED ENV{QT_REQUIRE_HOST_PATH_CHECK}) + set(__qt_platform_requires_host_info_package "$ENV{QT_REQUIRE_HOST_PATH_CHECK}") +else() + set(__qt_platform_requires_host_info_package "@platform_requires_host_info_package@") +endif() +set(__qt_platform_initial_qt_host_path "@qt_host_path_absolute@") +set(__qt_platform_initial_qt_host_path_cmake_dir "@qt_host_path_cmake_dir_absolute@") + +_qt_internal_setup_qt_host_path( + "${__qt_platform_requires_host_info_package}" + "${__qt_platform_initial_qt_host_path}" + "${__qt_platform_initial_qt_host_path_cmake_dir}") +_qt_internal_find_host_info_package(${__qt_platform_requires_host_info_package}) + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_third_party_deps "@third_party_deps@") +@third_party_deps_extra_info@ +@third_party_extra@ + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +_qt_internal_find_third_party_dependencies(@INSTALL_CMAKE_NAMESPACE@ __qt_third_party_deps) + +set(@INSTALL_CMAKE_NAMESPACE@_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtConfigureTimeExecutableCMakeLists.txt.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtConfigureTimeExecutableCMakeLists.txt.in new file mode 100644 index 0000000000000000000000000000000000000000..0b980338d5a007f974b589ae343c5aa5a6379dce --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtConfigureTimeExecutableCMakeLists.txt.in @@ -0,0 +1,26 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +cmake_minimum_required(VERSION 3.16) + +project(@configure_time_target@ LANGUAGES CXX) + +set(packages "@packages@") +set(defines @defines@) +set(compile_options @compile_options@) +set(link_options @link_options@) +set(output_directory @output_directory@) + +foreach(package IN LISTS packages) + find_package(${package} REQUIRED) +endforeach() + +add_executable(@configure_time_target@ @win32@ @macosx_bundle@ @sources@) +set_target_properties(@configure_time_target@ PROPERTIES + INCLUDE_DIRECTORIES "@include_directories@" + RUNTIME_OUTPUT_DIRECTORY "${output_directory}" +) + +target_compile_options(@configure_time_target@ PRIVATE ${compile_options}) +target_compile_definitions(@configure_time_target@ PRIVATE ${defines}) +target_link_options(@configure_time_target@ PRIVATE ${link_options}) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCopyFileIfDifferent.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCopyFileIfDifferent.cmake new file mode 100644 index 0000000000000000000000000000000000000000..60932cbbc874cd53d608900f7279db79f3340370 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtCopyFileIfDifferent.cmake @@ -0,0 +1,18 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# copy_if_different works incorrect in Windows if file size if bigger than 2GB. +# See https://gitlab.kitware.com/cmake/cmake/-/issues/23052 and QTBUG-99491 for details. + +cmake_minimum_required(VERSION 3.16) + +set(copy_strategy "copy_if_different") +if(CMAKE_HOST_WIN32) + file(SIZE "${SRC_FILE_PATH}" size) + # If file size is bigger than 2GB copy it unconditionally + if(size GREATER_EQUAL 2147483648) + set(copy_strategy "copy") + endif() +endif() + +execute_process(COMMAND ${CMAKE_COMMAND} -E ${copy_strategy} "${SRC_FILE_PATH}" "${DST_FILE_PATH}") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDbusHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDbusHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9515fa852ef547d67974739df466217380b082a5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDbusHelpers.cmake @@ -0,0 +1,82 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# helper to set up a qdbusxml2cpp rule +function(qt_create_qdbusxml2cpp_command target infile) + cmake_parse_arguments(PARSE_ARGV 2 arg + "ADAPTOR;INTERFACE" + "BASENAME" + "FLAGS") + _qt_internal_validate_all_args_are_parsed(arg) + + if((arg_ADAPTOR AND arg_INTERFACE) OR (NOT arg_ADAPTOR AND NOT arg_INTERFACE)) + message(FATAL_ERROR "qt_create_dbusxml2cpp_command needs either ADAPTOR or INTERFACE.") + endif() + + set(option "-a") + set(type "adaptor") + if (arg_INTERFACE) + set(option "-p") + set(type "interface") + endif() + + if ("${arg_BASENAME}" STREQUAL "") + get_filename_component(file_dir "${infile}" DIRECTORY) + get_filename_component(file_name "${infile}" NAME_WLE) + get_filename_component(file_ext "${infile}" LAST_EXT) + + if("${file_ext}" STREQUAL ".xml") + else() + message(FATAL_ERROR "DBUS ${type} input file is not xml.") + endif() + + # use last part of io.qt.something.xml! + get_filename_component(file_ext "${file_name}" LAST_EXT) + if("x${file_ext}" STREQUAL "x") + else() + string(SUBSTRING "${file_ext}" 1 -1 file_name) # cut of leading '.' + endif() + + string(TOLOWER "${file_name}" file_name) + set(file_name "${file_name}_${type}") + else() + set(file_name ${arg_BASENAME}) + endif() + + # Use absolute file path for the source file and set the current working directory to the + # current binary directory, because setting an absolute path for the header:source combo option + # does not work. Splitting on ":" breaks inside the dbus tool when running on Windows + # due to ":" being contained in the drive path (e.g C:\foo.h:C:\foo.cpp). + get_filename_component(absolute_in_file_path "${infile}" ABSOLUTE) + + set(header_file "${file_name}.h") + set(source_file "${file_name}.cpp") + + set(header_file_full "${CMAKE_CURRENT_BINARY_DIR}/${file_name}.h") + set(source_file_full "${CMAKE_CURRENT_BINARY_DIR}/${file_name}.cpp") + + if(QT_OPTIONAL_TOOLS_PATH) + if(CMAKE_HOST_WIN32) + set(executable_suffix ".exe") + else() + set(executable_suffix "") + endif() + set(tool_path + "${QT_OPTIONAL_TOOLS_PATH}/${INSTALL_BINDIR}/qdbusxml2cpp${executable_suffix}") + else() + set(tool_path "${QT_CMAKE_EXPORT_NAMESPACE}::qdbusxml2cpp") + endif() + + add_custom_command(OUTPUT "${header_file_full}" "${source_file_full}" + COMMAND ${tool_path} ${arg_FLAGS} "${option}" + "${header_file}:${source_file}" "${absolute_in_file_path}" + DEPENDS "${absolute_in_file_path}" ${tool_path} + WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" + COMMAND_EXPAND_LISTS + VERBATIM) + + target_sources("${target}" PRIVATE + "${header_file_full}" + "${source_file_full}" + ) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDeferredDependenciesHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDeferredDependenciesHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d4cc3ecfb09ee552bde5caec72fd15791c09e7e6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDeferredDependenciesHelpers.cmake @@ -0,0 +1,31 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Defers the connection 'dependent' -> 'dependency' +# +# The actual connection can be made by calling qt_internal_add_deferred_dependencies. +# +function(qt_internal_defer_dependency dependent dependency) + set_property(GLOBAL APPEND PROPERTY QT_DEFERRED_DEPENDENCIES ${doc_target} ${tool_target}) +endfunction() + +# Adds dependencies between targets that have been deferred by calling qt_internal_defer_dependency. +# +# This function checks whether the connection can be made (the dependency target exists). +# If the connection cannot be made, the deferred connection is left in the global property. +# Potentially, some later call to qt_internal_add_deferred_dependencies will add it. +# +function(qt_internal_add_deferred_dependencies) + unset(unknown_deps) + get_property(deferred_deps GLOBAL PROPERTY QT_DEFERRED_DEPENDENCIES) + while(deferred_deps) + list(POP_FRONT deferred_deps dependent) + list(POP_FRONT deferred_deps dependency) + if (TARGET ${dependency}) + add_dependencies(${dependent} ${dependency}) + else() + list(APPEND unknown_deps ${dependent} ${dependency}) + endif() + endwhile() + set_property(GLOBAL PROPERTY QT_DEFERRED_DEPENDENCIES ${unknown_deps}) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDocsHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDocsHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fffe04e3c021be1797cb606811a75389ab5a9e2c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtDocsHelpers.cmake @@ -0,0 +1,301 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This function adds a dependency between a doc-generating target like 'generate_docs_Gui' +# and the necessary tool target like 'qdoc'. +# +# If the target is not yet existing, save the dependency connection in a global property. +# The dependency is then added near the end of the top-level build after all subdirectories have +# been handled. +function(qt_internal_add_doc_tool_dependency doc_target tool_name) + qt_get_tool_target_name(tool_target ${tool_name}) + if(TARGET ${tool_target}) + add_dependencies(${doc_target} ${tool_target}) + else() + qt_internal_defer_dependency(${doc_target} ${tool_target}) + endif() +endfunction() + +function(qt_internal_add_docs) + if(NOT QT_BUILD_DOCS) + return() + endif() + + if(${ARGC} EQUAL 1) + # Function called from old generated CMakeLists.txt that was missing the target parameter + return() + endif() + set(error_msg "qt_add_docs called with wrong number of arguments. ") + list(APPEND error_msg + "Should be qt_add_docs\(target_name qdocconf " + "\[INDEX_DIRECTORIES EXTRA_INDEX_DIRS_LIST_TO_ENABLE_QDOC_RESOLVE_LINKS\]\)") + if(NOT ${ARGC} GREATER_EQUAL 2) + message(FATAL_ERROR ${error_msg}) + return() + endif() + + set(target ${ARGV0}) + set(doc_project ${ARGV1}) + set(qdoc_extra_args "") + # Check if there are more than 2 arguments and pass them + # as extra --indexdir arguments to qdoc in prepare and + # generate phases. + if (${ARGC} GREATER 2) + # The INDEX_DIRECTORIES key should enable passing a list of index + # directories as extra command-line arguments to qdoc. + set(qdocExtraArgs "INDEX_DIRECTORIES;DEFINES") + cmake_parse_arguments(PARSE_ARGV 2 arg "" "" "${qdocExtraArgs}") + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR ${error_msg}) + return() + endif() + if(arg_INDEX_DIRECTORIES) + foreach(index_directory ${arg_INDEX_DIRECTORIES}) + list(APPEND qdoc_extra_args "--indexdir" ${index_directory}) + endforeach() + endif() + endif() + + + # If a target is not built (which can happen for tools when crosscompiling), we shouldn't try + # to generate docs. + if(NOT TARGET "${target}") + return() + endif() + + set(tool_dependencies_enabled TRUE) + if(NOT "${QT_HOST_PATH}" STREQUAL "") + set(tool_dependencies_enabled FALSE) + set(doc_tools_bin "${QT_HOST_PATH}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}") + set(doc_tools_libexec "${QT_HOST_PATH}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}") + elseif(NOT "${QT_OPTIONAL_TOOLS_PATH}" STREQUAL "") + set(tool_dependencies_enabled FALSE) + set(doc_tools_bin "${QT_OPTIONAL_TOOLS_PATH}/${INSTALL_BINDIR}") + set(doc_tools_libexec "${QT_OPTIONAL_TOOLS_PATH}/${INSTALL_LIBEXECDIR}") + elseif(QT_SUPERBUILD) + set(doc_tools_bin "${QtBase_BINARY_DIR}/${INSTALL_BINDIR}") + set(doc_tools_libexec "${QtBase_BINARY_DIR}/${INSTALL_LIBEXECDIR}") + else() + set(doc_tools_bin "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_BINDIR}") + set(doc_tools_libexec "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_LIBEXECDIR}") + endif() + + if(CMAKE_HOST_WIN32) + set(executable_suffix ".exe") + else() + set(executable_suffix "") + endif() + + set(qdoc_bin "${doc_tools_bin}/qdoc${executable_suffix}") + set(qtattributionsscanner_bin "${doc_tools_libexec}/qtattributionsscanner${executable_suffix}") + set(qhelpgenerator_bin "${doc_tools_libexec}/qhelpgenerator${executable_suffix}") + + get_target_property(target_type ${target} TYPE) + if (NOT target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(target_bin_dir ${target} BINARY_DIR) + get_target_property(target_source_dir ${target} SOURCE_DIR) + else() + set(target_bin_dir ${CMAKE_CURRENT_BINARY_DIR}) + set(target_source_dir ${CMAKE_CURRENT_SOURCE_DIR}) + endif() + set(doc_output_dir "${target_bin_dir}/.doc") + + # Generate include dir list + set(target_include_dirs_file "${doc_output_dir}/$/includes.txt") + + + set(prop_prefix "") + if(target_type STREQUAL "INTERFACE_LIBRARY") + set(prop_prefix "INTERFACE_") + endif() + set(include_path_prop "${prop_prefix}INCLUDE_DIRECTORIES") + + set(include_paths_property "$") + if (NOT target_type STREQUAL "UTILITY") + file(GENERATE + OUTPUT ${target_include_dirs_file} + CONTENT "$<$:-I$>" + ) + set(include_path_args "@${target_include_dirs_file}") + else() + set(include_path_args "") + endif() + + get_filename_component(doc_target "${doc_project}" NAME_WLE) + if (QT_WILL_INSTALL) + set(qdoc_output_dir "${CMAKE_BINARY_DIR}/${INSTALL_DOCDIR}/${doc_target}") + set(qdoc_qch_output_dir "${CMAKE_BINARY_DIR}/${INSTALL_DOCDIR}") + set(index_dir "${CMAKE_BINARY_DIR}/${INSTALL_DOCDIR}") + else() + set(qdoc_output_dir "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_DOCDIR}/${doc_target}") + set(qdoc_qch_output_dir "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_DOCDIR}") + set(index_dir "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_DOCDIR}") + endif() + + # qtattributionsscanner + add_custom_target(qattributionsscanner_${target} + COMMAND ${qtattributionsscanner_bin} + ${PROJECT_SOURCE_DIR} + --basedir "${PROJECT_SOURCE_DIR}/.." + --filter "QDocModule=${doc_target}" + -o "${target_bin_dir}/codeattributions.qdoc" + ) + + # prepare docs target + set(prepare_qdoc_args + -outputdir "${qdoc_output_dir}" + "${target_source_dir}/${doc_project}" + -prepare + -indexdir "${index_dir}" + -no-link-errors + "${include_path_args}" + ) + if(NOT QT_BUILD_ONLINE_DOCS) + list(PREPEND prepare_qdoc_args + -installdir "${QT_INSTALL_DIR}/${INSTALL_DOCDIR}" + ${qdoc_extra_args} + ) + endif() + + if(DEFINED ENV{QT_INSTALL_DOCS}) + set(qt_install_docs_env "$ENV{QT_INSTALL_DOCS}") + elseif(QT_SUPERBUILD OR "${PROJECT_NAME}" STREQUAL "QtBase") + set(qt_install_docs_env "${QtBase_BINARY_DIR}/${INSTALL_DOCDIR}") + else() + set(qt_install_docs_env "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_DOCDIR}") + endif() + + set(qdoc_env_args + "QT_INSTALL_DOCS=\"${qt_install_docs_env}\"" + "QT_VERSION=${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}" + "QT_VER=${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}" + "QT_VERSION_TAG=${PROJECT_VERSION_MAJOR}${PROJECT_VERSION_MINOR}${PROJECT_VERSION_PATCH}" + "BUILDDIR=${target_bin_dir}" + ) + if(arg_DEFINES) + foreach(define ${arg_DEFINES}) + list(APPEND qdoc_env_args "${define}") + endforeach() + endif() + + add_custom_target(prepare_docs_${target} + COMMAND ${CMAKE_COMMAND} -E env ${qdoc_env_args} + ${qdoc_bin} + ${prepare_qdoc_args} + ) + + add_dependencies(prepare_docs_${target} qattributionsscanner_${target}) + if(NOT TARGET sync_all_public_headers) + add_custom_target(sync_all_public_headers) + endif() + add_dependencies(prepare_docs_${target} sync_all_public_headers) + + # generate docs target + set(generate_qdoc_args + -outputdir "${qdoc_output_dir}" + "${target_source_dir}/${doc_project}" + -generate + -indexdir "${index_dir}" + "${include_path_args}" + ) + if(NOT QT_BUILD_ONLINE_DOCS) + list(PREPEND generate_qdoc_args + -installdir "${QT_INSTALL_DIR}/${INSTALL_DOCDIR}" + ${qdoc_extra_args} + ) + endif() + + foreach(target_prefix generate_top_level_docs generate_repo_docs generate_docs) + set(depends_arg "") + if(tool_dependencies_enabled) + set(depends_arg DEPENDS ${qdoc_bin}) + endif() + add_custom_target(${target_prefix}_${target} + ${depends_arg} + COMMAND ${CMAKE_COMMAND} -E env ${qdoc_env_args} ${qdoc_bin} ${generate_qdoc_args}) + endforeach() + + add_dependencies(generate_docs_${target} prepare_docs_${target}) + add_dependencies(generate_repo_docs_${target} ${qt_docs_prepare_target_name}) + add_dependencies(generate_top_level_docs_${target} prepare_docs) + add_dependencies(generate_docs generate_top_level_docs_${target}) + + # html docs target + add_custom_target(html_docs_${target}) + add_dependencies(html_docs_${target} generate_docs_${target}) + + # generate .qch + set(qch_file_name ${doc_target}.qch) + set(qch_file_path ${qdoc_qch_output_dir}/${qch_file_name}) + + foreach(target_prefix qch_top_level_docs qch_repo_docs qch_docs) + set(depends_arg "") + if(tool_dependencies_enabled) + set(depends_arg DEPENDS ${qhelpgenerator_bin}) + endif() + add_custom_target(${target_prefix}_${target} + ${depends_arg} + COMMAND ${qhelpgenerator_bin} + "${qdoc_output_dir}/${doc_target}.qhp" + -o "${qch_file_path}" + ) + endforeach() + add_dependencies(qch_docs_${target} generate_docs_${target}) + add_dependencies(qch_repo_docs_${target} ${qt_docs_generate_target_name}) + add_dependencies(qch_top_level_docs_${target} generate_docs) + add_dependencies(qch_docs qch_top_level_docs_${target}) + + if (QT_WILL_INSTALL) + install(DIRECTORY "${qdoc_output_dir}/" + DESTINATION "${INSTALL_DOCDIR}/${doc_target}" + COMPONENT _install_html_docs_${target} + EXCLUDE_FROM_ALL + ) + + add_custom_target(install_html_docs_${target} + COMMAND ${CMAKE_COMMAND} + --install "${CMAKE_BINARY_DIR}" + --component _install_html_docs_${target} + COMMENT "Installing html docs for target ${target}" + ) + + install(FILES "${qch_file_path}" + DESTINATION "${INSTALL_DOCDIR}" + COMPONENT _install_qch_docs_${target} + EXCLUDE_FROM_ALL + ) + + add_custom_target(install_qch_docs_${target} + COMMAND ${CMAKE_COMMAND} + --install "${CMAKE_BINARY_DIR}" + --component _install_qch_docs_${target} + COMMENT "Installing qch docs for target ${target}" + ) + + else() + # Don't need to do anything when not installing + add_custom_target(install_html_docs_${target}) + add_custom_target(install_qch_docs_${target}) + endif() + + add_custom_target(install_docs_${target}) + add_dependencies(install_docs_${target} install_html_docs_${target} install_qch_docs_${target}) + + add_custom_target(docs_${target}) + add_dependencies(docs_${target} html_docs_${target}) + add_dependencies(docs_${target} qch_docs_${target}) + + add_dependencies(${qt_docs_prepare_target_name} prepare_docs_${target}) + add_dependencies(${qt_docs_generate_target_name} generate_repo_docs_${target}) + add_dependencies(${qt_docs_qch_target_name} qch_repo_docs_${target}) + add_dependencies(${qt_docs_install_html_target_name} install_html_docs_${target}) + add_dependencies(${qt_docs_install_qch_target_name} install_qch_docs_${target}) + + # Make sure that the necessary tools are built when running, + # for example 'cmake --build . --target generate_docs'. + if(tool_dependencies_enabled) + qt_internal_add_doc_tool_dependency(qattributionsscanner_${target} qtattributionsscanner) + qt_internal_add_doc_tool_dependency(prepare_docs_${target} qdoc) + qt_internal_add_doc_tool_dependency(qch_docs_${target} qhelpgenerator) + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtExecutableHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtExecutableHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..683e551d9cca66f518505d12b296fc083cac9de2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtExecutableHelpers.cmake @@ -0,0 +1,465 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This function creates a CMake target for a generic console or GUI binary. +# Please consider to use a more specific version target like the one created +# by qt_add_test or qt_add_tool below. +# One-value Arguments: +# CORE_LIBRARY +# The argument accepts 'Bootstrap' or 'None' values. If the argument value is set to +# 'Bootstrap' the Qt::Bootstrap library is linked to the executable instead of Qt::Core. +# The 'None' value points that core library is not necessary and avoids linking neither +# Qt::Core or Qt::Bootstrap libraries. Otherwise the Qt::Core library will be publicly +# linked to the executable target by default. +function(qt_internal_add_executable name) + cmake_parse_arguments(PARSE_ARGV 1 arg + "${__qt_internal_add_executable_optional_args}" + "${__qt_internal_add_executable_single_args}" + "${__qt_internal_add_executable_multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if ("x${arg_OUTPUT_DIRECTORY}" STREQUAL "x") + set(arg_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_BINDIR}") + endif() + + get_filename_component(arg_OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}" + ABSOLUTE BASE_DIR "${QT_BUILD_DIR}") + + if ("x${arg_INSTALL_DIRECTORY}" STREQUAL "x") + set(arg_INSTALL_DIRECTORY "${INSTALL_BINDIR}") + endif() + + _qt_internal_create_executable(${name}) + qt_internal_mark_as_internal_target(${name}) + + set_target_properties(${name} PROPERTIES + _qt_is_test_executable ${arg_QT_TEST} + _qt_is_manual_test ${arg_QT_MANUAL_TEST} + ) + + if(ANDROID) + _qt_internal_android_executable_finalizer(${name}) + endif() + if(WASM) + qt_internal_wasm_add_finalizers(${name}) + endif() + + if(arg_QT_APP AND QT_FEATURE_debug_and_release AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.19.0") + set_property(TARGET "${name}" + PROPERTY EXCLUDE_FROM_ALL "$>") + endif() + + if (arg_VERSION) + if(arg_VERSION MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+") + # nothing to do + elseif(arg_VERSION MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+") + set(arg_VERSION "${arg_VERSION}.0") + elseif(arg_VERSION MATCHES "[0-9]+\\.[0-9]+") + set(arg_VERSION "${arg_VERSION}.0.0") + elseif (arg_VERSION MATCHES "[0-9]+") + set(arg_VERSION "${arg_VERSION}.0.0.0") + else() + message(FATAL_ERROR "Invalid version format") + endif() + endif() + + if(arg_DELAY_TARGET_INFO) + # Delay the setting of target info properties if requested. Needed for scope finalization + # of Qt apps. + set_target_properties("${name}" PROPERTIES + QT_DELAYED_TARGET_VERSION "${arg_VERSION}" + QT_DELAYED_TARGET_PRODUCT "${arg_TARGET_PRODUCT}" + QT_DELAYED_TARGET_DESCRIPTION "${arg_TARGET_DESCRIPTION}" + QT_DELAYED_TARGET_COMPANY "${arg_TARGET_COMPANY}" + QT_DELAYED_TARGET_COPYRIGHT "${arg_TARGET_COPYRIGHT}" + ) + else() + if(NOT arg_TARGET_DESCRIPTION) + set(arg_TARGET_DESCRIPTION "Qt ${name}") + endif() + qt_set_target_info_properties(${name} ${ARGN} + TARGET_DESCRIPTION ${arg_TARGET_DESCRIPTION} + TARGET_VERSION ${arg_VERSION}) + endif() + + if (WIN32 AND NOT arg_DELAY_RC) + _qt_internal_generate_win32_rc_file(${name}) + endif() + + qt_set_common_target_properties(${name}) + + qt_internal_add_repo_local_defines(${name}) + + if(ANDROID) + # The above call to qt_set_common_target_properties() sets the symbol + # visibility to hidden, but for Android, we need main() to not be hidden + # because it has to be loadable at runtime using dlopen(). + set_property(TARGET ${name} PROPERTY C_VISIBILITY_PRESET default) + set_property(TARGET ${name} PROPERTY CXX_VISIBILITY_PRESET default) + endif() + + qt_autogen_tools_initial_setup(${name}) + qt_skip_warnings_are_errors_when_repo_unclean("${name}") + + set(extra_libraries "") + if(arg_CORE_LIBRARY STREQUAL "Bootstrap") + list(APPEND extra_libraries ${QT_CMAKE_EXPORT_NAMESPACE}::Bootstrap) + elseif(NOT arg_CORE_LIBRARY STREQUAL "None") + list(APPEND extra_libraries ${QT_CMAKE_EXPORT_NAMESPACE}::Core) + endif() + + set(private_includes + "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_BINARY_DIR}" + ${arg_INCLUDE_DIRECTORIES} + ) + + if(arg_PUBLIC_LIBRARIES) + message(WARNING + "qt_internal_add_executable's PUBLIC_LIBRARIES option is deprecated, and will be " + "removed in a future Qt version. Use the LIBRARIES option instead.") + endif() + + if(arg_NO_UNITY_BUILD) + set(arg_NO_UNITY_BUILD "NO_UNITY_BUILD") + else() + set(arg_NO_UNITY_BUILD "") + endif() + + qt_internal_extend_target("${name}" + ${arg_NO_UNITY_BUILD} + SOURCES ${arg_SOURCES} + NO_PCH_SOURCES ${arg_NO_PCH_SOURCES} + NO_UNITY_BUILD_SOURCES ${arg_NO_UNITY_BUILD_SOURCES} + INCLUDE_DIRECTORIES ${private_includes} + DEFINES ${arg_DEFINES} + LIBRARIES + ${arg_LIBRARIES} + ${arg_PUBLIC_LIBRARIES} + Qt::PlatformCommonInternal + ${extra_libraries} + DBUS_ADAPTOR_SOURCES ${arg_DBUS_ADAPTOR_SOURCES} + DBUS_ADAPTOR_FLAGS ${arg_DBUS_ADAPTOR_FLAGS} + DBUS_INTERFACE_SOURCES ${arg_DBUS_INTERFACE_SOURCES} + DBUS_INTERFACE_FLAGS ${arg_DBUS_INTERFACE_FLAGS} + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS} + ) + set_target_properties("${name}" PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}" + LIBRARY_OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}" + WIN32_EXECUTABLE "${arg_GUI}" + MACOSX_BUNDLE "${arg_GUI}" + ) + + qt_internal_set_exceptions_flags("${name}" ${arg_EXCEPTIONS}) + + # Check if target needs to be excluded from all target. Also affects qt_install. + # Set by qt_exclude_tool_directories_from_default_target. + set(exclude_from_all FALSE) + if(__qt_exclude_tool_directories) + foreach(absolute_dir ${__qt_exclude_tool_directories}) + string(FIND "${CMAKE_CURRENT_SOURCE_DIR}" "${absolute_dir}" dir_starting_pos) + if(dir_starting_pos EQUAL 0) + set(exclude_from_all TRUE) + set_target_properties("${name}" PROPERTIES + EXCLUDE_FROM_ALL TRUE + _qt_internal_excluded_from_default_target TRUE + ) + break() + endif() + endforeach() + endif() + + if(NOT arg_NO_INSTALL) + set(additional_install_args "") + if(exclude_from_all) + list(APPEND additional_install_args EXCLUDE_FROM_ALL COMPONENT "ExcludedExecutables") + endif() + + qt_get_cmake_configurations(cmake_configs) + foreach(cmake_config ${cmake_configs}) + qt_get_install_target_default_args( + OUT_VAR install_targets_default_args + CMAKE_CONFIG "${cmake_config}" + ALL_CMAKE_CONFIGS ${cmake_configs} + RUNTIME "${arg_INSTALL_DIRECTORY}" + LIBRARY "${arg_INSTALL_DIRECTORY}" + BUNDLE "${arg_INSTALL_DIRECTORY}") + + # Make installation optional for targets that are not built by default in this config + if(NOT exclude_from_all AND arg_QT_APP AND QT_FEATURE_debug_and_release + AND NOT (cmake_config STREQUAL QT_MULTI_CONFIG_FIRST_CONFIG)) + set(install_optional_arg "OPTIONAL") + else() + unset(install_optional_arg) + endif() + + qt_install(TARGETS "${name}" + ${additional_install_args} # Needs to be before the DESTINATIONS. + ${install_optional_arg} + CONFIGURATIONS ${cmake_config} + ${install_targets_default_args}) + endforeach() + + if(NOT exclude_from_all AND arg_QT_APP AND QT_FEATURE_debug_and_release) + set(separate_debug_info_executable_arg "QT_EXECUTABLE") + else() + unset(separate_debug_info_executable_arg) + endif() + qt_enable_separate_debug_info(${name} "${arg_INSTALL_DIRECTORY}" + ${separate_debug_info_executable_arg} + ADDITIONAL_INSTALL_ARGS ${additional_install_args}) + qt_internal_install_pdb_files(${name} "${arg_INSTALL_DIRECTORY}") + endif() + + if(QT_GENERATE_SBOM) + set(sbom_args "") + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + ${__qt_internal_sbom_optional_args} + FORWARD_SINGLE + ${__qt_internal_sbom_single_args} + FORWARD_MULTI + ${__qt_internal_sbom_multi_args} + ) + + _qt_internal_extend_sbom(${name} ${sbom_args}) + endif() +endfunction() + +# This function compiles the target at configure time the very first time and creates the custom +# ${target}_build that re-runs compilation at build time if necessary. The resulting executable is +# imported under the provided target name. This function should only be used to compile tiny +# executables with system dependencies only. +# One-value Arguments: +# CMAKELISTS_TEMPLATE +# The CMakeLists.txt templated that is used to configure the project +# for an executable. By default the predefined template from the Qt installation is used. +# INSTALL_DIRECTORY +# installation directory of the executable. Ignored if NO_INSTALL is set. +# OUTPUT_NAME +# the output name of an executable +# CONFIG +# the name of configuration that tool needs to be build with. +# Multi-value Arguments: +# PACKAGES +# list of system packages are required to successfully build the project. +# INCLUDES +# list of include directories are required to successfully build the project. +# DEFINES +# list of definitions are required to successfully build the project. +# COMPILE_OPTIONS +# list of compiler options are required to successfully build the project. +# LINK_OPTIONS +# list of linker options are required to successfully build the project. +# SOURCES +# list of project sources. +# CMAKE_FLAGS +# specify flags of the form -DVAR:TYPE=VALUE to be passed to the cmake command-line used to +# drive the test build. +# Options: +# WIN32 +# reflects the corresponding add_executable argument. +# MACOSX_BUNDLE +# reflects the corresponding add_executable argument. +# NO_INSTALL +# avoids installing the tool. +function(qt_internal_add_configure_time_executable target) + set(one_value_args + CMAKELISTS_TEMPLATE + INSTALL_DIRECTORY + OUTPUT_NAME + CONFIG + ) + set(multi_value_args + PACKAGES + INCLUDES + DEFINES + COMPILE_OPTIONS + LINK_OPTIONS + SOURCES + CMAKE_FLAGS + ) + set(option_args WIN32 MACOSX_BUNDLE NO_INSTALL) + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" "${one_value_args}" "${multi_value_args}") + + set(target_binary_dir "${CMAKE_CURRENT_BINARY_DIR}/configure_time_bins") + if(arg_CONFIG) + set(CMAKE_TRY_COMPILE_CONFIGURATION "${arg_CONFIG}") + string(TOUPPER "_${arg_CONFIG}" config_suffix) + endif() + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config AND CMAKE_TRY_COMPILE_CONFIGURATION) + set(configuration_path "${CMAKE_TRY_COMPILE_CONFIGURATION}/") + set(config_build_arg "--config" "${CMAKE_TRY_COMPILE_CONFIGURATION}") + endif() + + set(configure_time_target "${target}") + if(arg_OUTPUT_NAME) + set(configure_time_target "${arg_OUTPUT_NAME}") + endif() + set(target_binary "${configure_time_target}${CMAKE_EXECUTABLE_SUFFIX}") + + set(install_dir "${INSTALL_BINDIR}") + if(arg_INSTALL_DIRECTORY) + set(install_dir "${arg_INSTALL_DIRECTORY}") + endif() + + set(output_directory_relative "${install_dir}") + set(output_directory "${QT_BUILD_DIR}/${install_dir}") + + set(target_binary_path_relative + "${output_directory_relative}/${configuration_path}${target_binary}") + set(target_binary_path + "${output_directory}/${configuration_path}${target_binary}") + + get_filename_component(target_binary_path "${target_binary_path}" ABSOLUTE) + + if(NOT DEFINED arg_SOURCES) + message(FATAL_ERROR "No SOURCES given to target: ${target}") + endif() + set(sources "${arg_SOURCES}") + + # Timestamp file is required because CMake ignores 'add_custom_command' if we use only the + # binary file as the OUTPUT. + set(timestamp_file "${target_binary_dir}/${target_binary}_timestamp") + add_custom_command(OUTPUT "${target_binary_path}" "${timestamp_file}" + COMMAND + ${CMAKE_COMMAND} --build "${target_binary_dir}" --clean-first ${config_build_arg} + COMMAND + ${CMAKE_COMMAND} -E touch "${timestamp_file}" + DEPENDS + ${sources} + COMMENT + "Compiling ${target}" + VERBATIM + ) + + add_custom_target(${target}_build ALL + DEPENDS + "${target_binary_path}" + "${timestamp_file}" + ) + + set(should_build_at_configure_time TRUE) + if(QT_INTERNAL_HAVE_CONFIGURE_TIME_${target} AND + EXISTS "${target_binary_path}" AND EXISTS "${timestamp_file}") + set(last_ts 0) + foreach(source IN LISTS sources) + file(TIMESTAMP "${source}" ts "%s") + if(${ts} GREATER ${last_ts}) + set(last_ts ${ts}) + endif() + endforeach() + + file(TIMESTAMP "${target_binary_path}" ts "%s") + if(${ts} GREATER_EQUAL ${last_ts}) + set(should_build_at_configure_time FALSE) + endif() + endif() + + set(cmake_flags_arg "") + if(arg_CMAKE_FLAGS) + set(cmake_flags_arg CMAKE_FLAGS "${arg_CMAKE_FLAGS}") + endif() + + qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages) + foreach(lang IN LISTS enabled_languages) + set(compiler_flags_var "CMAKE_${lang}_FLAGS") + list(APPEND cmake_flags_arg "-D${compiler_flags_var}:STRING=${${compiler_flags_var}}") + if(arg_CONFIG) + set(compiler_flags_var_config "${compiler_flags_var}${config_suffix}") + list(APPEND cmake_flags_arg + "-D${compiler_flags_var_config}:STRING=${${compiler_flags_var_config}}") + endif() + endforeach() + + qt_internal_get_target_link_types_for_flag_manipulation(target_link_types) + foreach(linker_type IN LISTS target_link_types) + set(linker_flags_var "CMAKE_${linker_type}_LINKER_FLAGS") + list(APPEND cmake_flags_arg "-D${linker_flags_var}:STRING=${${linker_flags_var}}") + if(arg_CONFIG) + set(linker_flags_var_config "${linker_flags_var}${config_suffix}") + list(APPEND cmake_flags_arg + "-D${linker_flags_var_config}:STRING=${${linker_flags_var_config}}") + endif() + endforeach() + + if(NOT "${QT_INTERNAL_CMAKE_FLAGS_CONFIGURE_TIME_TOOL_${target}}" STREQUAL "${cmake_flags_arg}") + set(should_build_at_configure_time TRUE) + endif() + + if(should_build_at_configure_time) + foreach(arg IN LISTS multi_value_args) + string(TOLOWER "${arg}" template_arg_name) + set(${template_arg_name} "") + if(DEFINED arg_${arg}) + set(${template_arg_name} "${arg_${arg}}") + endif() + endforeach() + + foreach(arg IN LISTS option_args) + string(TOLOWER "${arg}" template_arg_name) + set(${template_arg_name} "") + if(arg_${arg}) + set(${template_arg_name} "${arg}") + endif() + endforeach() + + file(MAKE_DIRECTORY "${target_binary_dir}") + set(template "${QT_CMAKE_DIR}/QtConfigureTimeExecutableCMakeLists.txt.in") + if(DEFINED arg_CMAKELISTS_TEMPLATE) + set(template "${arg_CMAKELISTS_TEMPLATE}") + endif() + + configure_file("${template}" "${target_binary_dir}/CMakeLists.txt" @ONLY) + + if(EXISTS "${target_binary_dir}/CMakeCache.txt") + file(REMOVE "${target_binary_dir}/CMakeCache.txt") + endif() + + try_compile(result + "${target_binary_dir}" + "${target_binary_dir}" + ${target} + ${cmake_flags_arg} + OUTPUT_VARIABLE try_compile_output + ) + + set(QT_INTERNAL_CMAKE_FLAGS_CONFIGURE_TIME_TOOL_${target} + "${cmake_flags_arg}" CACHE INTERNAL "") + + file(WRITE "${timestamp_file}" "") + set(QT_INTERNAL_HAVE_CONFIGURE_TIME_${target} ${result} CACHE INTERNAL + "Indicates that the configure-time target ${target} was built") + if(NOT result) + message(FATAL_ERROR "Unable to build ${target}: ${try_compile_output}") + endif() + endif() + + add_executable(${target} IMPORTED GLOBAL) + add_executable(${QT_CMAKE_EXPORT_NAMESPACE}::${target} ALIAS ${target}) + set_target_properties(${target} PROPERTIES + _qt_internal_configure_time_target TRUE + _qt_internal_configure_time_target_build_location "${target_binary_path_relative}" + IMPORTED_LOCATION "${target_binary_path}" + ) + + if(NOT arg_NO_INSTALL) + set_target_properties(${target} PROPERTIES + _qt_internal_configure_time_target_install_location + "${install_dir}/${target_binary}" + ) + qt_path_join(target_install_dir ${QT_INSTALL_DIR} ${install_dir}) + qt_install(PROGRAMS "${target_binary_path}" DESTINATION "${target_install_dir}") + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFeature.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFeature.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3433dedce2dab13cedb9293c0f0b73a398c9c031 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFeature.cmake @@ -0,0 +1,1424 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(CheckCXXCompilerFlag) + +function(qt_feature_module_begin) + cmake_parse_arguments(PARSE_ARGV 0 arg + "NO_MODULE;ONLY_EVALUATE_FEATURES" + "LIBRARY;PRIVATE_FILE;PUBLIC_FILE" + "PUBLIC_DEPENDENCIES;PRIVATE_DEPENDENCIES") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_ONLY_EVALUATE_FEATURES) + if ("${arg_LIBRARY}" STREQUAL "" AND (NOT ${arg_NO_MODULE})) + message(FATAL_ERROR + "qt_feature_begin_module needs a LIBRARY name! (or specify NO_MODULE)") + endif() + if ("${arg_PUBLIC_FILE}" STREQUAL "") + message(FATAL_ERROR "qt_feature_begin_module needs a PUBLIC_FILE name!") + endif() + if ("${arg_PRIVATE_FILE}" STREQUAL "") + message(FATAL_ERROR "qt_feature_begin_module needs a PRIVATE_FILE name!") + endif() + set(__QtFeature_only_evaluate_features OFF PARENT_SCOPE) + else() + set(__QtFeature_only_evaluate_features ON PARENT_SCOPE) + endif() + + set(__QtFeature_library "${arg_LIBRARY}" PARENT_SCOPE) + set(__QtFeature_public_features "" PARENT_SCOPE) + set(__QtFeature_private_features "" PARENT_SCOPE) + set(__QtFeature_internal_features "" PARENT_SCOPE) + + set(__QtFeature_private_file "${arg_PRIVATE_FILE}" PARENT_SCOPE) + set(__QtFeature_public_file "${arg_PUBLIC_FILE}" PARENT_SCOPE) + + set(__QtFeature_private_extra "" PARENT_SCOPE) + set(__QtFeature_public_extra "" PARENT_SCOPE) + + set(__QtFeature_config_definitions "" PARENT_SCOPE) + + set(__QtFeature_define_definitions "" PARENT_SCOPE) +endfunction() + +function(qt_feature feature) + set(original_name "${feature}") + qt_feature_normalize_name("${feature}" feature) + set_property(GLOBAL PROPERTY QT_FEATURE_ORIGINAL_NAME_${feature} "${original_name}") + + cmake_parse_arguments(PARSE_ARGV 1 arg + "PRIVATE;PUBLIC" + "LABEL;PURPOSE;SECTION" + "AUTODETECT;CONDITION;ENABLE;DISABLE;EMIT_IF") + _qt_internal_validate_all_args_are_parsed(arg) + + set(_QT_FEATURE_DEFINITION_${feature} ${ARGN} PARENT_SCOPE) + + # Register feature for future use: + if (arg_PUBLIC) + list(APPEND __QtFeature_public_features "${feature}") + endif() + if (arg_PRIVATE) + list(APPEND __QtFeature_private_features "${feature}") + endif() + if (NOT arg_PUBLIC AND NOT arg_PRIVATE) + list(APPEND __QtFeature_internal_features "${feature}") + endif() + + + set(__QtFeature_public_features ${__QtFeature_public_features} PARENT_SCOPE) + set(__QtFeature_private_features ${__QtFeature_private_features} PARENT_SCOPE) + set(__QtFeature_internal_features ${__QtFeature_internal_features} PARENT_SCOPE) +endfunction() + +function(qt_evaluate_to_boolean expressionVar) + if(${${expressionVar}}) + set(${expressionVar} ON PARENT_SCOPE) + else() + set(${expressionVar} OFF PARENT_SCOPE) + endif() +endfunction() + +function(qt_internal_evaluate_config_expression resultVar outIdx startIdx) + set(result "") + set(expression "${ARGN}") + list(LENGTH expression length) + + math(EXPR memberIdx "${startIdx} - 1") + math(EXPR length "${length}-1") + while(memberIdx LESS ${length}) + math(EXPR memberIdx "${memberIdx} + 1") + list(GET expression ${memberIdx} member) + + if("${member}" STREQUAL "(") + math(EXPR memberIdx "${memberIdx} + 1") + qt_internal_evaluate_config_expression(sub_result memberIdx ${memberIdx} ${expression}) + list(APPEND result ${sub_result}) + elseif("${member}" STREQUAL ")") + break() + elseif("${member}" STREQUAL "NOT") + list(APPEND result ${member}) + elseif("${member}" STREQUAL "AND") + qt_evaluate_to_boolean(result) + if(NOT ${result}) + break() + endif() + set(result "") + elseif("${member}" STREQUAL "OR") + qt_evaluate_to_boolean(result) + if(${result}) + break() + endif() + set(result "") + elseif("${member}" STREQUAL "STREQUAL" AND memberIdx LESS ${length}) + # Unfortunately the semantics for STREQUAL in if() are broken when the + # RHS is an empty string and the parameters to if are coming through a variable. + # So we expect people to write the empty string with single quotes and then we + # do the comparison manually here. + list(LENGTH result lhsIndex) + math(EXPR lhsIndex "${lhsIndex}-1") + list(GET result ${lhsIndex} lhs) + list(REMOVE_AT result ${lhsIndex}) + set(lhs "${${lhs}}") + + math(EXPR rhsIndex "${memberIdx}+1") + set(memberIdx ${rhsIndex}) + + list(GET expression ${rhsIndex} rhs) + # We can't pass through an empty string with double quotes through various + # stages of substitution, so instead it is represented using single quotes + # and resolve here. + string(REGEX REPLACE "'(.*)'" "\\1" rhs "${rhs}") + + string(COMPARE EQUAL "${lhs}" "${rhs}" stringCompareResult) + list(APPEND result ${stringCompareResult}) + else() + string(FIND "${member}" "QT_FEATURE_" idx) + if(idx EQUAL 0) + # Remove the QT_FEATURE_ prefix + string(SUBSTRING "${member}" 11 -1 feature) + qt_evaluate_feature(${feature}) + endif() + + list(APPEND result ${member}) + endif() + endwhile() + # The 'TARGET Gui' case is handled by qt_evaluate_to_boolean, by passing those tokens verbatim + # to if(). + + if("${result}" STREQUAL "") + set(result ON) + else() + qt_evaluate_to_boolean(result) + endif() + + # When in recursion, we must skip to the next closing parenthesis on nesting level 0. The outIdx + # must point to the matching closing parenthesis, and that's not the case if we're early exiting + # in AND/OR. + if(startIdx GREATER 0) + set(nestingLevel 1) + while(TRUE) + list(GET expression ${memberIdx} member) + if("${member}" STREQUAL ")") + math(EXPR nestingLevel "${nestingLevel} - 1") + if(nestingLevel EQUAL 0) + break() + endif() + elseif("${member}" STREQUAL "(") + math(EXPR nestingLevel "${nestingLevel} + 1") + endif() + math(EXPR memberIdx "${memberIdx} + 1") + endwhile() + endif() + + set(${outIdx} ${memberIdx} PARENT_SCOPE) + set(${resultVar} ${result} PARENT_SCOPE) +endfunction() + +function(qt_evaluate_config_expression resultVar) + qt_internal_evaluate_config_expression(result unused 0 ${ARGN}) + set("${resultVar}" "${result}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_get_feature_condition_keywords out_var) + set(keywords "EQUAL" "LESS" "LESS_EQUAL" "GREATER" "GREATER_EQUAL" "STREQUAL" "STRLESS" + "STRLESS_EQUAL" "STRGREATER" "STRGREATER_EQUAL" "VERSION_EQUAL" "VERSION_LESS" + "VERSION_LESS_EQUAL" "VERSION_GREATER" "VERSION_GREATER_EQUAL" "MATCHES" + "EXISTS" "COMMAND" "DEFINED" "NOT" "AND" "OR" "TARGET" "EXISTS" "IN_LIST" "(" ")") + set(${out_var} "${keywords}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_dump_expression_values expression_dump expression) + set(dump "") + set(skipNext FALSE) + set(isTargetExpression FALSE) + + _qt_internal_get_feature_condition_keywords(keywords) + + list(LENGTH expression length) + math(EXPR length "${length}-1") + + if(${length} LESS 0) + return() + endif() + + foreach(memberIdx RANGE ${length}) + if(${skipNext}) + set(skipNext FALSE) + continue() + endif() + + list(GET expression ${memberIdx} member) + if(NOT "${member}" IN_LIST keywords) + string(FIND "${member}" "QT_FEATURE_" idx) + if(idx EQUAL 0) + if(NOT DEFINED ${member}) + list(APPEND dump "${member} not evaluated") + else() + list(APPEND dump "${member} = \"${${member}}\"") + endif() + elseif(isTargetExpression) + set(targetExpression "TARGET;${member}") + if(${targetExpression}) + list(APPEND dump "TARGET ${member} found") + else() + list(APPEND dump "TARGET ${member} not found") + endif() + else() + list(APPEND dump "${member} = \"${${member}}\"") + endif() + set(isTargetExpression FALSE) + set(skipNext FALSE) + elseif("${member}" STREQUAL "TARGET") + set(isTargetExpression TRUE) + elseif("${member}" STREQUAL "STREQUAL") + set(skipNext TRUE) + else() + set(skipNext FALSE) + set(isTargetExpression FALSE) + endif() + endforeach() + string(JOIN "\n " ${expression_dump} ${dump}) + set(${expression_dump} "${${expression_dump}}" PARENT_SCOPE) +endfunction() + +# Stores the user provided value to FEATURE_${feature} if provided. +# If not provided, stores ${computed} instead. +# ${computed} is also stored when reconfiguring and the condition does not align with the user +# provided value. +# +function(qt_feature_check_and_save_user_provided_value + resultVar feature condition condition_expression computed label) + if (DEFINED "FEATURE_${feature}") + # Revisit new user provided value + set(user_value "${FEATURE_${feature}}") + string(TOUPPER "${user_value}" user_value_upper) + set(result "${user_value_upper}") + + # If ${feature} depends on another dirty feature, reset the ${feature} value to + # ${computed}. + get_property(dirty_build GLOBAL PROPERTY _qt_dirty_build) + if(dirty_build) + _qt_internal_feature_compute_feature_dependencies(deps "${feature}") + if(deps) + get_property(dirty_features GLOBAL PROPERTY _qt_dirty_features) + foreach(dirty_feature ${dirty_features}) + if(dirty_feature IN_LIST deps AND NOT "${result}" STREQUAL "${computed}") + set(result "${computed}") + message(WARNING + "Auto-resetting 'FEATURE_${feature}' from '${user_value_upper}' to " + "'${computed}', " + "because the dependent feature '${dirty_feature}' was marked dirty.") + + # Append ${feature} as a new dirty feature. + set_property(GLOBAL APPEND PROPERTY _qt_dirty_features "${feature}") + break() + endif() + endforeach() + endif() + + # If the build is marked as dirty and the feature doesn't meet its condition, + # reset its value to the computed one, which is likely OFF. + if(NOT condition AND result) + set(result "${computed}") + message(WARNING "Resetting 'FEATURE_${feature}' from '${user_value_upper}' to " + "'${computed}' because it doesn't meet its condition after reconfiguration. " + "Condition expression is: '${condition_expression}'") + endif() + endif() + + set(bool_values OFF NO FALSE N ON YES TRUE Y) + if ((result IN_LIST bool_values) OR (result GREATER_EQUAL 0)) + # All good! + else() + message(FATAL_ERROR + "Sanity check failed: FEATURE_${feature} has invalid value \"${result}\"!") + endif() + + # Fix-up user-provided values + set("FEATURE_${feature}" "${result}" CACHE BOOL "${label}" FORCE) + else() + # Initial setup: + set(result "${computed}") + set("FEATURE_${feature}" "${result}" CACHE BOOL "${label}") + endif() + + set("${resultVar}" "${result}" PARENT_SCOPE) +endfunction() + +# Saves the final user value to QT_FEATURE_${feature}, after checking that the condition is met. +macro(qt_feature_check_and_save_internal_value + feature saved_user_value condition label conditionExpression) + if(${saved_user_value}) + set(result ON) + else() + set(result OFF) + endif() + + if ((NOT condition) AND result) + _qt_internal_dump_expression_values(conditionDump "${conditionExpression}") + string(JOIN " " conditionString ${conditionExpression}) + qt_configure_add_report_error("Feature \"${feature}\": Forcing to \"${result}\" breaks its \ +condition:\n ${conditionString}\nCondition values dump:\n ${conditionDump}\n" RECORD_ON_FEATURE_EVALUATION) + endif() + + if (DEFINED "QT_FEATURE_${feature}") + message(FATAL_ERROR "Feature ${feature} is already defined when evaluating configure.cmake features for ${target}.") + endif() + set(QT_FEATURE_${feature} "${result}" CACHE INTERNAL "Qt feature: ${feature}") + + # Add feature to build feature collection + list(APPEND QT_KNOWN_FEATURES "${feature}") + set(QT_KNOWN_FEATURES "${QT_KNOWN_FEATURES}" CACHE INTERNAL "" FORCE) +endmacro() + +macro(_qt_internal_parse_feature_definition feature) + cmake_parse_arguments(arg + "PRIVATE;PUBLIC" + "LABEL;PURPOSE;SECTION;" + "AUTODETECT;CONDITION;ENABLE;DISABLE;EMIT_IF" + ${_QT_FEATURE_DEFINITION_${feature}}) +endmacro() + + +# The build system stores 2 CMake cache variables for each feature, to allow detecting value changes +# during subsequent reconfigurations. +# +# +# `FEATURE_foo` stores the user provided feature value for the current configuration run. +# It can be set directly by the user. +# +# If a value is not provided on initial configuration, the value will be auto-computed based on the +# various conditions of the feature. +# TODO: Document the various conditions and how they relate to each other. +# +# +# `QT_FEATURE_foo` stores the value of the feature from the previous configuration run. +# Its value is updated once with the newest user provided value after some checks are performed. +# +# This variable also serves as the main source of truth throughout the build system code to check +# if the feature is enabled, e.g. if(QT_FEATURE_foo) +# +# It is not meant to be set by the user. It is only modified by the build system. +# +# Comparing the values of QT_FEATURE_foo and FEATURE_foo, the build system can detect whether +# the user changed the value for a feature and thus recompute any dependent features. +# +function(qt_evaluate_feature feature) + # If the feature was already evaluated as dependency nothing to do here. + if(DEFINED "QT_FEATURE_${feature}") + return() + endif() + + if(NOT DEFINED _QT_FEATURE_DEFINITION_${feature}) + qt_debug_print_variables(DEDUP MATCH "^QT_FEATURE") + message(FATAL_ERROR "Attempting to evaluate feature ${feature} but its definition is missing. Either the feature does not exist or a dependency to the module that defines it is missing") + endif() + + _qt_internal_parse_feature_definition("${feature}") + + if("${arg_ENABLE}" STREQUAL "") + set(arg_ENABLE OFF) + endif() + + if("${arg_DISABLE}" STREQUAL "") + set(arg_DISABLE OFF) + endif() + + if("${arg_AUTODETECT}" STREQUAL "") + set(arg_AUTODETECT ON) + endif() + + if("${arg_CONDITION}" STREQUAL "") + set(condition ON) + else() + qt_evaluate_config_expression(condition ${arg_CONDITION}) + endif() + + qt_evaluate_config_expression(disable_result ${arg_DISABLE}) + qt_evaluate_config_expression(enable_result ${arg_ENABLE}) + qt_evaluate_config_expression(auto_detect ${arg_AUTODETECT}) + if(${disable_result}) + set(computed OFF) + elseif(${enable_result}) + set(computed ON) + elseif(${auto_detect}) + set(computed ${condition}) + else() + # feature not auto-detected and not explicitly enabled + set(computed OFF) + endif() + + if("${arg_EMIT_IF}" STREQUAL "") + set(emit_if ON) + else() + qt_evaluate_config_expression(emit_if ${arg_EMIT_IF}) + endif() + + # Warn about a feature which is not emitted, but the user explicitly provided a value for it. + if(NOT emit_if AND DEFINED FEATURE_${feature}) + set(msg "") + string(APPEND msg + "Feature ${feature} is insignificant in this configuration, " + "ignoring related command line option(s).") + qt_configure_add_report_entry(TYPE WARNING MESSAGE "${msg}") + + # Remove the cache entry so that the warning is not persisted and shown on every + # reconfiguration. + unset(FEATURE_${feature} CACHE) + endif() + + # Only save the user provided value if the feature was emitted. + if(emit_if) + qt_feature_check_and_save_user_provided_value( + saved_user_value + "${feature}" "${condition}" "${arg_CONDITION}" "${computed}" "${arg_LABEL}") + else() + # Make sure the feature internal value is OFF if not emitted. + set(saved_user_value OFF) + endif() + + qt_feature_check_and_save_internal_value( + "${feature}" "${saved_user_value}" "${condition}" "${arg_LABEL}" "${arg_CONDITION}") + + # Store each feature's label for summary info. + set(QT_FEATURE_LABEL_${feature} "${arg_LABEL}" CACHE INTERNAL "") +endfunction() + +# Collect feature names that ${feature} depends on, by inspecting the given expression. +function(_qt_internal_feature_extract_feature_dependencies_from_expression out_var expression) + list(LENGTH expression length) + math(EXPR length "${length}-1") + + if(length LESS 0) + set(${out_var} "" PARENT_SCOPE) + return() + endif() + + set(deps "") + + foreach(memberIdx RANGE ${length}) + list(GET expression ${memberIdx} member) + if(member MATCHES "^QT_FEATURE_(.+)") + list(APPEND deps "${CMAKE_MATCH_1}") + endif() + endforeach() + set(${out_var} "${deps}" PARENT_SCOPE) +endfunction() + +# Collect feature names that ${feature} depends on, based on feature names that appear +# in the ${feature}'s condition expressions. +function(_qt_internal_feature_compute_feature_dependencies out_var feature) + # Only compute the deps once per feature. + get_property(deps_computed GLOBAL PROPERTY _qt_feature_deps_computed_${feature}) + if(deps_computed) + get_property(deps GLOBAL PROPERTY _qt_feature_deps_${feature}) + set(${out_var} "${deps}" PARENT_SCOPE) + return() + endif() + + _qt_internal_parse_feature_definition("${feature}") + + set(options_to_check AUTODETECT CONDITION ENABLE DISABLE EMIT_IF) + set(deps "") + + # Go through each option that takes condition expressions and collect the feature names. + foreach(option ${options_to_check}) + set(option_value "${arg_${option}}") + if(option_value) + _qt_internal_feature_extract_feature_dependencies_from_expression( + option_deps "${option_value}") + if(option_deps) + list(APPEND deps ${option_deps}) + endif() + endif() + endforeach() + + set_property(GLOBAL PROPERTY _qt_feature_deps_computed_${feature} TRUE) + set_property(GLOBAL PROPERTY _qt_feature_deps_${feature} "${deps}") + set(${out_var} "${deps}" PARENT_SCOPE) +endfunction() + +function(qt_feature_config feature config_var_name) + qt_feature_normalize_name("${feature}" feature) + cmake_parse_arguments(PARSE_ARGV 2 arg + "NEGATE" + "NAME" + "") + _qt_internal_validate_all_args_are_parsed(arg) + + # Store all the config related info in a unique variable key. + set(key_name "_QT_FEATURE_CONFIG_DEFINITION_${feature}_${config_var_name}") + set(${key_name} "FEATURE;${feature};CONFIG_VAR_NAME;${config_var_name};${ARGN}" PARENT_SCOPE) + + # Store the key for later evaluation. + list(APPEND __QtFeature_config_definitions "${key_name}") + + set(__QtFeature_config_definitions ${__QtFeature_config_definitions} PARENT_SCOPE) +endfunction() + +function(qt_evaluate_qmake_config_values key) + if(NOT DEFINED ${key}) + qt_debug_print_variables(DEDUP MATCH "^_QT_FEATURE_CONFIG_DEFINITION") + message(FATAL_ERROR + "Attempting to evaluate feature config ${key} but its definition is missing. ") + endif() + + cmake_parse_arguments(arg + "NEGATE" + "FEATURE;NAME;CONFIG_VAR_NAME" + "" ${${key}}) + + # If no custom name is specified, then the config value is the same as the feature name. + if(NOT arg_NAME) + set(arg_NAME "${arg_FEATURE}") + endif() + + set(expected "NOT") + if (arg_NEGATE) + set(expected "") + if(arg_NAME MATCHES "^no_(.*)") + set(arg_NAME "${CMAKE_MATCH_1}") + else() + string(PREPEND arg_NAME "no_") + endif() + endif() + + # The feature condition is false, there is no need to export any config values. + if(${expected} ${QT_FEATURE_${arg_FEATURE}}) + return() + endif() + + if(arg_CONFIG_VAR_NAME STREQUAL "QMAKE_PUBLIC_CONFIG") + list(APPEND __QtFeature_qmake_public_config "${arg_NAME}") + set(__QtFeature_qmake_public_config "${__QtFeature_qmake_public_config}" PARENT_SCOPE) + endif() + if(arg_CONFIG_VAR_NAME STREQUAL "QMAKE_PRIVATE_CONFIG") + list(APPEND __QtFeature_qmake_private_config "${arg_NAME}") + set(__QtFeature_qmake_private_config "${__QtFeature_qmake_private_config}" PARENT_SCOPE) + endif() + if(arg_CONFIG_VAR_NAME STREQUAL "QMAKE_PUBLIC_QT_CONFIG") + list(APPEND __QtFeature_qmake_public_qt_config "${arg_NAME}") + set(__QtFeature_qmake_public_qt_config "${__QtFeature_qmake_public_qt_config}" PARENT_SCOPE) + endif() +endfunction() + +function(qt_feature_definition feature name) + qt_feature_normalize_name("${feature}" feature) + cmake_parse_arguments(PARSE_ARGV 2 arg + "NEGATE" + "VALUE;PREREQUISITE" + "") + _qt_internal_validate_all_args_are_parsed(arg) + + # Store all the define related info in a unique variable key. + set(key_name "_QT_FEATURE_DEFINE_DEFINITION_${feature}_${name}") + set(${key_name} "FEATURE;${feature};NAME;${name};${ARGN}" PARENT_SCOPE) + + # Store the key for later evaluation and subsequent define generation: + list(APPEND __QtFeature_define_definitions "${key_name}") + + set(__QtFeature_define_definitions ${__QtFeature_define_definitions} PARENT_SCOPE) +endfunction() + +function(qt_evaluate_feature_definition key) + if(NOT DEFINED ${key}) + qt_debug_print_variables(DEDUP MATCH "^_QT_FEATURE_DEFINE_DEFINITION") + message(FATAL_ERROR "Attempting to evaluate feature define ${key} but its definition is missing. ") + endif() + + cmake_parse_arguments(arg + "NEGATE;" + "FEATURE;NAME;VALUE;PREREQUISITE" "" ${${key}}) + + set(expected ON) + if (arg_NEGATE) + set(expected OFF) + endif() + + set(actual OFF) + if(QT_FEATURE_${arg_FEATURE}) + set(actual ON) + endif() + + set(msg "") + + if(actual STREQUAL expected) + set(indent "") + if(arg_PREREQUISITE) + string(APPEND msg "#if ${arg_PREREQUISITE}\n") + set(indent " ") + endif() + if (arg_VALUE) + string(APPEND msg "${indent}#define ${arg_NAME} ${arg_VALUE}\n") + else() + string(APPEND msg "${indent}#define ${arg_NAME}\n") + endif() + if(arg_PREREQUISITE) + string(APPEND msg "#endif\n") + endif() + + string(APPEND __QtFeature_public_extra "${msg}") + endif() + + set(__QtFeature_public_extra ${__QtFeature_public_extra} PARENT_SCOPE) +endfunction() + +function(qt_extra_definition name value) + cmake_parse_arguments(PARSE_ARGV 2 arg + "PUBLIC;PRIVATE" + "" + "") + _qt_internal_validate_all_args_are_parsed(arg) + + if (arg_PUBLIC) + string(APPEND __QtFeature_public_extra "\n#define ${name} ${value}\n") + elseif(arg_PRIVATE) + string(APPEND __QtFeature_private_extra "\n#define ${name} ${value}\n") + endif() + + set(__QtFeature_public_extra ${__QtFeature_public_extra} PARENT_SCOPE) + set(__QtFeature_private_extra ${__QtFeature_private_extra} PARENT_SCOPE) +endfunction() + +function(qt_internal_generate_feature_line line feature) + string(TOUPPER "${QT_FEATURE_${feature}}" value) + if (value STREQUAL "ON") + set(line "#define QT_FEATURE_${feature} 1\n\n" PARENT_SCOPE) + elseif(value STREQUAL "OFF") + set(line "#define QT_FEATURE_${feature} -1\n\n" PARENT_SCOPE) + elseif(value STREQUAL "UNSET") + set(line "#define QT_FEATURE_${feature} 0\n\n" PARENT_SCOPE) + else() + message(FATAL_ERROR "${feature} has unexpected value \"${QT_FEATURE_${feature}}\"! " + "Valid values are ON, OFF and UNSET.") + endif() +endfunction() + +function(qt_internal_feature_write_file file features extra) + set(contents "") + foreach(it ${features}) + qt_internal_generate_feature_line(line "${it}") + string(APPEND contents "${line}") + endforeach() + string(APPEND contents "${extra}") + + file(GENERATE OUTPUT "${file}" CONTENT "${contents}") +endfunction() + +# Helper function which evaluates features from a given list of configure.cmake paths +# and creates the feature cache entries. +# Should not be used directly, unless features need to be available in a directory scope before the +# associated module evaluates the features. +# E.g. qtbase/src.pro needs access to Core features before src/corelib/CMakeLists.txt is parsed. +function(qt_feature_evaluate_features list_of_paths) + qt_feature_module_begin(ONLY_EVALUATE_FEATURES) + foreach(path ${list_of_paths}) + include("${path}") + endforeach() + qt_feature_module_end(ONLY_EVALUATE_FEATURES) +endfunction() + +function(qt_feature_record_summary_entries list_of_paths) + # Clean up any stale state just in case. + qt_feature_unset_state_vars() + + set(__QtFeature_only_record_summary_entries TRUE) + foreach(path ${list_of_paths}) + include("${path}") + endforeach() + qt_feature_unset_state_vars() +endfunction() + +function(qt_feature_module_end) + set(flags ONLY_EVALUATE_FEATURES) + set(options OUT_VAR_PREFIX) + set(multiopts) + cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN}) + set(target ${arg_UNPARSED_ARGUMENTS}) + + # The value of OUT_VAR_PREFIX is used as a prefix for output variables that should be + # set in the parent scope. + if(NOT arg_OUT_VAR_PREFIX) + set(arg_OUT_VAR_PREFIX "") + endif() + + set(all_features ${__QtFeature_public_features} ${__QtFeature_private_features} ${__QtFeature_internal_features}) + list(REMOVE_DUPLICATES all_features) + + foreach(feature ${all_features}) + qt_evaluate_feature(${feature}) + endforeach() + + # Evaluate custom cache assignments. + foreach(cache_var_name ${__QtFeature_custom_enabled_cache_variables}) + set(${cache_var_name} ON CACHE BOOL "Force enabled by platform requirements." FORCE) + endforeach() + foreach(cache_var_name ${__QtFeature_custom_disabled_cache_variables}) + set(${cache_var_name} OFF CACHE BOOL "Force disabled by platform requirements." FORCE) + endforeach() + + set(enabled_public_features "") + set(disabled_public_features "") + set(enabled_private_features "") + set(disabled_private_features "") + + foreach(feature ${__QtFeature_public_features}) + if(QT_FEATURE_${feature}) + list(APPEND enabled_public_features ${feature}) + else() + list(APPEND disabled_public_features ${feature}) + endif() + endforeach() + + foreach(feature ${__QtFeature_private_features}) + if(QT_FEATURE_${feature}) + list(APPEND enabled_private_features ${feature}) + else() + list(APPEND disabled_private_features ${feature}) + endif() + endforeach() + + foreach(key ${__QtFeature_config_definitions}) + qt_evaluate_qmake_config_values(${key}) + unset(${key} PARENT_SCOPE) + endforeach() + + foreach(key ${__QtFeature_define_definitions}) + qt_evaluate_feature_definition(${key}) + unset(${key} PARENT_SCOPE) + endforeach() + + foreach(feature ${all_features}) + unset(_QT_FEATURE_DEFINITION_${feature} PARENT_SCOPE) + endforeach() + + if(NOT arg_ONLY_EVALUATE_FEATURES) + qt_internal_feature_write_file("${CMAKE_CURRENT_BINARY_DIR}/${__QtFeature_private_file}" + "${__QtFeature_private_features}" "${__QtFeature_private_extra}" + ) + + qt_internal_feature_write_file("${CMAKE_CURRENT_BINARY_DIR}/${__QtFeature_public_file}" + "${__QtFeature_public_features}" "${__QtFeature_public_extra}" + ) + endif() + + if (NOT ("${target}" STREQUAL "NO_MODULE") AND NOT arg_ONLY_EVALUATE_FEATURES) + get_target_property(targetType "${target}" TYPE) + if("${targetType}" STREQUAL "INTERFACE_LIBRARY") + set(propertyPrefix "INTERFACE_") + else() + set(propertyPrefix "") + set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES "QT_ENABLED_PUBLIC_FEATURES;QT_DISABLED_PUBLIC_FEATURES;QT_ENABLED_PRIVATE_FEATURES;QT_DISABLED_PRIVATE_FEATURES;QT_QMAKE_PUBLIC_CONFIG;QT_QMAKE_PRIVATE_CONFIG;QT_QMAKE_PUBLIC_QT_CONFIG") + endif() + foreach(visibility public private) + string(TOUPPER "${visibility}" capitalVisibility) + foreach(state enabled disabled) + string(TOUPPER "${state}" capitalState) + + set_property(TARGET "${target}" PROPERTY ${propertyPrefix}QT_${capitalState}_${capitalVisibility}_FEATURES "${${state}_${visibility}_features}") + endforeach() + endforeach() + + set_property(TARGET "${target}" + PROPERTY ${propertyPrefix}QT_QMAKE_PUBLIC_CONFIG + "${__QtFeature_qmake_public_config}") + set_property(TARGET "${target}" + PROPERTY ${propertyPrefix}QT_QMAKE_PRIVATE_CONFIG + "${__QtFeature_qmake_private_config}") + set_property(TARGET "${target}" + PROPERTY ${propertyPrefix}QT_QMAKE_PUBLIC_QT_CONFIG + "${__QtFeature_qmake_public_qt_config}") + + # Config values were the old-school features before actual configure.json features were + # implemented. Therefore "CONFIG+=foo" values should be considered features as well, + # so that CMake can find them when building qtmultimedia for example. + if(__QtFeature_qmake_public_config) + set_property(TARGET "${target}" + APPEND PROPERTY ${propertyPrefix}QT_ENABLED_PUBLIC_FEATURES + ${__QtFeature_qmake_public_config}) + endif() + if(__QtFeature_qmake_private_config) + set_property(TARGET "${target}" + APPEND PROPERTY ${propertyPrefix}QT_ENABLED_PRIVATE_FEATURES + ${__QtFeature_qmake_private_config}) + endif() + if(__QtFeature_qmake_public_qt_config) + set_property(TARGET "${target}" + APPEND PROPERTY ${propertyPrefix}QT_ENABLED_PUBLIC_FEATURES + ${__QtFeature_qmake_public_qt_config}) + endif() + + qt_feature_copy_global_config_features_to_core(${target}) + endif() + + qt_feature_unset_state_vars() +endfunction() + +macro(qt_feature_unset_state_vars) + unset(__QtFeature_library PARENT_SCOPE) + unset(__QtFeature_public_features PARENT_SCOPE) + unset(__QtFeature_private_features PARENT_SCOPE) + unset(__QtFeature_internal_features PARENT_SCOPE) + + unset(__QtFeature_private_file PARENT_SCOPE) + unset(__QtFeature_public_file PARENT_SCOPE) + + unset(__QtFeature_private_extra PARENT_SCOPE) + unset(__QtFeature_public_extra PARENT_SCOPE) + + unset(__QtFeature_define_definitions PARENT_SCOPE) + unset(__QtFeature_custom_enabled_features PARENT_SCOPE) + unset(__QtFeature_custom_disabled_features PARENT_SCOPE) + unset(__QtFeature_only_evaluate_features PARENT_SCOPE) + unset(__QtFeature_only_record_summary_entries PARENT_SCOPE) +endmacro() + +function(qt_feature_copy_global_config_features_to_core target) + # CMake doesn't support setting custom properties on exported INTERFACE libraries + # See https://gitlab.kitware.com/cmake/cmake/issues/19261. + # To circumvent that, copy the properties from GlobalConfig to Core target. + # This way the global features actually get set in the generated CoreTargets.cmake file. + if(target STREQUAL Core) + foreach(visibility public private) + string(TOUPPER "${visibility}" capitalVisibility) + foreach(state enabled disabled) + string(TOUPPER "${state}" capitalState) + + set(core_property_name "QT_${capitalState}_${capitalVisibility}_FEATURES") + set(global_property_name "INTERFACE_${core_property_name}") + + get_property(core_values TARGET Core PROPERTY ${core_property_name}) + get_property(global_values TARGET GlobalConfig PROPERTY ${global_property_name}) + + set(total_values ${core_values} ${global_values}) + set_property(TARGET Core PROPERTY ${core_property_name} ${total_values}) + endforeach() + endforeach() + + set(config_property_names + QT_QMAKE_PUBLIC_CONFIG QT_QMAKE_PRIVATE_CONFIG QT_QMAKE_PUBLIC_QT_CONFIG ) + foreach(property_name ${config_property_names}) + set(core_property_name "${property_name}") + set(global_property_name "INTERFACE_${core_property_name}") + + get_property(core_values TARGET Core PROPERTY ${core_property_name}) + get_property(global_values TARGET GlobalConfig PROPERTY ${global_property_name}) + + set(total_values ${core_values} ${global_values}) + set_property(TARGET Core PROPERTY ${core_property_name} ${total_values}) + endforeach() + endif() +endfunction() + +function(qt_internal_detect_dirty_features) + # We need to clean up QT_FEATURE_*, but only once per configuration cycle + get_property(qt_feature_clean GLOBAL PROPERTY _qt_feature_clean) + if(NOT qt_feature_clean AND NOT QT_NO_FEATURE_AUTO_RESET) + message(STATUS "Checking for feature set changes") + set_property(GLOBAL PROPERTY _qt_feature_clean TRUE) + foreach(feature ${QT_KNOWN_FEATURES}) + if(DEFINED "FEATURE_${feature}" AND + NOT "${QT_FEATURE_${feature}}" STREQUAL "${FEATURE_${feature}}") + message(" '${feature}' was changed from ${QT_FEATURE_${feature}} " + "to ${FEATURE_${feature}}") + set(dirty_build TRUE) + set_property(GLOBAL APPEND PROPERTY _qt_dirty_features "${feature}") + endif() + unset("QT_FEATURE_${feature}" CACHE) + endforeach() + + set(QT_KNOWN_FEATURES "" CACHE INTERNAL "" FORCE) + + if(dirty_build) + set_property(GLOBAL PROPERTY _qt_dirty_build TRUE) + message(WARNING + "Due to detected feature set changes, dependent features " + "will be re-computed automatically. This might cause a lot of files to be rebuilt. " + "To disable this behavior, configure with -DQT_NO_FEATURE_AUTO_RESET=ON") + endif() + endif() +endfunction() + +# Builds either a string of source code or a whole project to determine whether the build is +# successful. +# +# Sets a TEST_${name}_OUTPUT variable with the build output, to the scope of the calling function. +# Sets a TEST_${name} cache variable to either TRUE or FALSE if the build is successful or not. +function(qt_config_compile_test name) + if(DEFINED "TEST_${name}") + return() + endif() + + cmake_parse_arguments(arg "" "LABEL;PROJECT_PATH;C_STANDARD;CXX_STANDARD" + "COMPILE_OPTIONS;LIBRARIES;CODE;PACKAGES;CMAKE_FLAGS" ${ARGN}) + + if(arg_PROJECT_PATH) + message(STATUS "Performing Test ${arg_LABEL}") + + set(flags "") + qt_get_platform_try_compile_vars(platform_try_compile_vars) + list(APPEND flags ${platform_try_compile_vars}) + + # If the repo has its own cmake modules, include those in the module path, so that various + # find_package calls work. + if(EXISTS "${PROJECT_SOURCE_DIR}/cmake") + set(must_append_module_path_flag TRUE) + set(flags_copy "${flags}") + set(flags) + foreach(flag IN LISTS flags_copy) + if(flag MATCHES "^-DCMAKE_MODULE_PATH:STRING=") + set(must_append_module_path_flag FALSE) + set(flag "${flag}\\;${PROJECT_SOURCE_DIR}/cmake") + endif() + list(APPEND flags "${flag}") + endforeach() + if(must_append_module_path_flag) + list(APPEND flags "-DCMAKE_MODULE_PATH:STRING=${PROJECT_SOURCE_DIR}/cmake") + endif() + endif() + + # Pass which packages need to be found. + if(arg_PACKAGES) + set(packages_list "") + + # Parse the package names, version, etc. An example would be: + # PACKAGE Foo 6 REQUIRED + # PACKAGE Bar 2 COMPONENTS Baz + foreach(p ${arg_PACKAGES}) + if(p STREQUAL PACKAGE) + if(package_entry) + # Encode the ";" into "\;" to separate the arguments of a find_package call. + string(REPLACE ";" "\\;" package_entry_string "${package_entry}") + list(APPEND packages_list "${package_entry_string}") + endif() + + set(package_entry "") + else() + list(APPEND package_entry "${p}") + endif() + endforeach() + # Parse final entry. + if(package_entry) + string(REPLACE ";" "\\;" package_entry_string "${package_entry}") + list(APPEND packages_list "${package_entry_string}") + endif() + + # Encode the ";" again. + string(REPLACE ";" "\\;" packages_list "${packages_list}") + + # The flags are separated by ';', the find_package entries by '\;', + # and the package parts of an entry by '\\;'. + # Example: + # WrapFoo\\;6\\;COMPONENTS\\;bar\;WrapBaz\\;5 + list(APPEND flags "-DQT_CONFIG_COMPILE_TEST_PACKAGES:STRING=${packages_list}") + + # Inside the project, the value of QT_CONFIG_COMPILE_TEST_PACKAGES is used in a foreach + # loop that calls find_package() for each package entry, and thus the variable expansion + # ends up calling something like find_package(WrapFoo;6;COMPONENTS;bar) aka + # find_package(WrapFoo 6 COMPONENTS bar). + endif() + + # Pass which libraries need to be linked against. + if(arg_LIBRARIES) + set(link_flags "") + set(library_targets "") + # Separate targets from link flags or paths. This is to prevent configuration failures + # when the targets are not found due to missing packages. + foreach(lib ${arg_LIBRARIES}) + string(FIND "${lib}" "::" is_library_target) + if(is_library_target EQUAL -1) + list(APPEND link_flags "${lib}") + else() + list(APPEND library_targets "${lib}") + endif() + endforeach() + if(link_flags) + list(APPEND flags "-DQT_CONFIG_COMPILE_TEST_LIBRARIES:STRING=${link_flags}") + endif() + if(library_targets) + list(APPEND flags + "-DQT_CONFIG_COMPILE_TEST_LIBRARY_TARGETS:STRING=${library_targets}") + endif() + endif() + + # Pass override values for CMAKE_SYSTEM_{PREFIX|FRAMEWORK}_PATH. + if(DEFINED QT_CMAKE_SYSTEM_PREFIX_PATH_BACKUP) + set(path_list ${CMAKE_SYSTEM_PREFIX_PATH}) + string(REPLACE ";" "\\;" path_list "${path_list}") + list(APPEND flags "-DQT_CONFIG_COMPILE_TEST_CMAKE_SYSTEM_PREFIX_PATH=${path_list}") + endif() + if(DEFINED QT_CMAKE_SYSTEM_FRAMEWORK_PATH_BACKUP) + set(path_list ${CMAKE_SYSTEM_FRAMEWORK_PATH}) + string(REPLACE ";" "\\;" path_list "${path_list}") + list(APPEND flags "-DQT_CONFIG_COMPILE_TEST_CMAKE_SYSTEM_FRAMEWORK_PATH=${path_list}") + endif() + + if(NOT arg_CMAKE_FLAGS) + set(arg_CMAKE_FLAGS "") + endif() + + # CI passes the project dir of the Qt repository as absolute path without drive letter: + # \Users\qt\work\qt\qtbase + # Ensure that arg_PROJECT_PATH is an absolute path with drive letter: + # C:/Users/qt/work/qt/qtbase + # This works around CMake upstream issue #22534. + if(CMAKE_HOST_WIN32) + get_filename_component(arg_PROJECT_PATH "${arg_PROJECT_PATH}" REALPATH) + endif() + + try_compile( + HAVE_${name} "${CMAKE_BINARY_DIR}/config.tests/${name}" "${arg_PROJECT_PATH}" "${name}" + CMAKE_FLAGS ${flags} ${arg_CMAKE_FLAGS} + OUTPUT_VARIABLE try_compile_output + ) + + if(${HAVE_${name}}) + set(status_label "Success") + else() + set(status_label "Failed") + endif() + message(STATUS "Performing Test ${arg_LABEL} - ${status_label}") + else() + foreach(library IN ITEMS ${arg_LIBRARIES}) + if(NOT TARGET "${library}") + # If the dependency looks like a cmake target, then make this compile test + # fail instead of cmake abort later via CMAKE_REQUIRED_LIBRARIES. + string(FIND "${library}" "::" cmake_target_namespace_separator) + if(NOT cmake_target_namespace_separator EQUAL -1) + message(STATUS "Performing Test ${arg_LABEL} - Failed because ${library} not found") + set(HAVE_${name} FALSE) + break() + endif() + endif() + endforeach() + + if(NOT DEFINED HAVE_${name}) + set(_save_CMAKE_C_STANDARD "${CMAKE_C_STANDARD}") + set(_save_CMAKE_C_STANDARD_REQUIRED "${CMAKE_C_STANDARD_REQUIRED}") + set(_save_CMAKE_CXX_STANDARD "${CMAKE_CXX_STANDARD}") + set(_save_CMAKE_CXX_STANDARD_REQUIRED "${CMAKE_CXX_STANDARD_REQUIRED}") + set(_save_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}") + set(_save_CMAKE_TRY_COMPILE_PLATFORM_VARIABLES "${CMAKE_TRY_COMPILE_PLATFORM_VARIABLES}") + + if(arg_C_STANDARD) + set(CMAKE_C_STANDARD "${arg_C_STANDARD}") + set(CMAKE_C_STANDARD_REQUIRED OFF) + endif() + + if(arg_CXX_STANDARD) + if(${arg_CXX_STANDARD} LESS 23 OR ${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.20") + set(CMAKE_CXX_STANDARD "${arg_CXX_STANDARD}") + set(CMAKE_CXX_STANDARD_REQUIRED OFF) + endif() + endif() + + set(CMAKE_REQUIRED_FLAGS ${arg_COMPILE_OPTIONS}) + + # Pass -stdlib=libc++ on if necessary + if (QT_FEATURE_stdlib_libcpp) + list(APPEND CMAKE_REQUIRED_FLAGS "-stdlib=libc++") + endif() + + # For MSVC we need to explicitly pass -Zc:__cplusplus to get correct __cplusplus + # define values. According to common/msvc-version.conf the flag is supported starting + # with 1913. + # https://developercommunity.visualstudio.com/content/problem/139261/msvc-incorrectly-defines-cplusplus.html + # No support for the flag in upstream CMake as of 3.17. + # https://gitlab.kitware.com/cmake/cmake/issues/18837 + if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND MSVC_VERSION GREATER_EQUAL 1913) + list(APPEND CMAKE_REQUIRED_FLAGS "-Zc:__cplusplus") + endif() + + # Let CMake load our custom platform modules. + if(NOT QT_AVOID_CUSTOM_PLATFORM_MODULES) + list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES CMAKE_MODULE_PATH) + endif() + + set(_save_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}") + set(CMAKE_REQUIRED_LIBRARIES "${arg_LIBRARIES}") + + # OUTPUT_VARIABLE is an internal undocumented variable of check_cxx_source_compiles + # since 3.23. Allow an opt out in case this breaks in the future. + set(try_compile_output "") + set(output_var "") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.23" + AND NOT QT_INTERNAL_NO_TRY_COMPILE_OUTPUT_VARIABLE) + set(output_var OUTPUT_VARIABLE try_compile_output) + endif() + + check_cxx_source_compiles( + "${arg_UNPARSED_ARGUMENTS} ${arg_CODE}" HAVE_${name} ${output_var} + ) + set(CMAKE_REQUIRED_LIBRARIES "${_save_CMAKE_REQUIRED_LIBRARIES}") + + set(CMAKE_C_STANDARD "${_save_CMAKE_C_STANDARD}") + set(CMAKE_C_STANDARD_REQUIRED "${_save_CMAKE_C_STANDARD_REQUIRED}") + set(CMAKE_CXX_STANDARD "${_save_CMAKE_CXX_STANDARD}") + set(CMAKE_CXX_STANDARD_REQUIRED "${_save_CMAKE_CXX_STANDARD_REQUIRED}") + set(CMAKE_REQUIRED_FLAGS "${_save_CMAKE_REQUIRED_FLAGS}") + set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES "${_save_CMAKE_TRY_COMPILE_PLATFORM_VARIABLES}") + endif() + endif() + + set(TEST_${name}_OUTPUT "${try_compile_output}" PARENT_SCOPE) + set(TEST_${name} "${HAVE_${name}}" CACHE INTERNAL "${arg_LABEL}") +endfunction() + +# This function should be used for passing required try compile platform variables to the +# project-based try_compile() call. +# out_var will be a list of -Dfoo=bar strings, suitable to pass to CMAKE_FLAGS. +function(qt_get_platform_try_compile_vars out_var) + # Use the regular variables that are used for source-based try_compile() calls. + set(flags "${CMAKE_TRY_COMPILE_PLATFORM_VARIABLES}") + + # Pass custom flags. + list(APPEND flags "CMAKE_C_FLAGS") + list(APPEND flags "CMAKE_C_FLAGS_DEBUG") + list(APPEND flags "CMAKE_C_FLAGS_RELEASE") + list(APPEND flags "CMAKE_C_FLAGS_RELWITHDEBINFO") + list(APPEND flags "CMAKE_CXX_FLAGS") + list(APPEND flags "CMAKE_CXX_FLAGS_DEBUG") + list(APPEND flags "CMAKE_CXX_FLAGS_RELEASE") + list(APPEND flags "CMAKE_CXX_FLAGS_RELWITHDEBINFO") + list(APPEND flags "CMAKE_OBJCOPY") + list(APPEND flags "CMAKE_EXE_LINKER_FLAGS") + + # Pass toolchain files. + if(CMAKE_TOOLCHAIN_FILE) + list(APPEND flags "CMAKE_TOOLCHAIN_FILE") + endif() + if(VCPKG_CHAINLOAD_TOOLCHAIN_FILE) + list(APPEND flags "VCPKG_CHAINLOAD_TOOLCHAIN_FILE") + endif() + + # Pass language standard flags. + list(APPEND flags "CMAKE_C_STANDARD") + list(APPEND flags "CMAKE_C_STANDARD_REQUIRED") + list(APPEND flags "CMAKE_CXX_STANDARD") + list(APPEND flags "CMAKE_CXX_STANDARD_REQUIRED") + + # Pass -stdlib=libc++ on if necessary + if (QT_FEATURE_stdlib_libcpp) + if(CMAKE_CXX_FLAGS) + string(APPEND CMAKE_CXX_FLAGS " -stdlib=libc++") + else() + set(CMAKE_CXX_FLAGS "-stdlib=libc++") + endif() + endif() + + # Assemble the list with regular options. + set(flags_cmd_line "") + foreach(flag ${flags}) + if(${flag}) + list(APPEND flags_cmd_line "-D${flag}=${${flag}}") + endif() + endforeach() + + # Let CMake load our custom platform modules. + if(NOT QT_AVOID_CUSTOM_PLATFORM_MODULES) + list(APPEND flags_cmd_line "-DCMAKE_MODULE_PATH:STRING=${QT_CMAKE_DIR}/platforms") + endif() + + # Pass darwin specific options. + # The architectures need to be passed explicitly to project-based try_compile calls even on + # macOS, so that arm64 compilation works on Apple silicon. + qt_internal_get_first_osx_arch(osx_first_arch) + if(osx_first_arch) + # Do what qmake does, aka when doing a simulator_and_device build, build the + # target architecture test only with the first given architecture, which should be the + # device architecture, aka some variation of "arm" (armv7, arm64). + list(APPEND flags_cmd_line "-DCMAKE_OSX_ARCHITECTURES:STRING=${osx_first_arch}") + endif() + if(UIKIT) + # Specify the sysroot, but only if not doing a simulator_and_device build. + # So keep the sysroot empty for simulator_and_device builds. + if(QT_APPLE_SDK) + list(APPEND flags_cmd_line "-DCMAKE_OSX_SYSROOT:STRING=${QT_APPLE_SDK}") + endif() + endif() + if(QT_NO_USE_FIND_PACKAGE_SYSTEM_ENVIRONMENT_PATH) + list(APPEND flags_cmd_line "-DCMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH:BOOL=OFF") + endif() + + set("${out_var}" "${flags_cmd_line}" PARENT_SCOPE) +endfunction() + +# Set out_var to the first value of CMAKE_OSX_ARCHITECTURES. +# Sets an empty string if no architecture is present. +function(qt_internal_get_first_osx_arch out_var) + set(value "") + if(CMAKE_OSX_ARCHITECTURES) + list(GET CMAKE_OSX_ARCHITECTURES 0 value) + endif() + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +function(qt_config_compile_test_x86simd extension label) + if (DEFINED TEST_X86SIMD_${extension}) + return() + endif() + + set(flags "-DSIMD:string=${extension}") + + qt_get_platform_try_compile_vars(platform_try_compile_vars) + list(APPEND flags ${platform_try_compile_vars}) + + message(STATUS "Performing Test ${label} intrinsics") + try_compile("TEST_X86SIMD_${extension}" + "${CMAKE_CURRENT_BINARY_DIR}/config.tests/x86_simd_${extension}" + "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/x86_simd" + x86_simd + CMAKE_FLAGS ${flags}) + if(${TEST_X86SIMD_${extension}}) + set(status_label "Success") + else() + set(status_label "Failed") + endif() + message(STATUS "Performing Test ${label} intrinsics - ${status_label}") + set(TEST_subarch_${extension} "${TEST_X86SIMD_${extension}}" CACHE INTERNAL "${label}") +endfunction() + +function(qt_config_compile_test_machine_tuple label) + if(DEFINED TEST_MACHINE_TUPLE OR NOT (LINUX OR HURD) OR ANDROID) + return() + endif() + + message(STATUS "Performing Test ${label}") + execute_process(COMMAND "${CMAKE_CXX_COMPILER}" -dumpmachine + OUTPUT_VARIABLE output + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE exit_code) + if(exit_code EQUAL 0) + set(status_label "Success") + else() + set(status_label "Failed") + endif() + message(STATUS "Performing Test ${label} - ${status_label}") + set(TEST_machine_tuple "${output}" CACHE INTERNAL "${label}") +endfunction() + +function(qt_config_compiler_supports_flag_test name) + if(DEFINED "TEST_${name}") + return() + endif() + + cmake_parse_arguments(arg "" "LABEL;FLAG" "" ${ARGN}) + check_cxx_compiler_flag("${arg_FLAG}" TEST_${name}) + set(TEST_${name} "${TEST_${name}}" CACHE INTERNAL "${label}") +endfunction() + +# gcc expects -fuse-ld=mold (no absolute path can be given) (gcc >= 12.1) +# or an 'ld' symlink to 'mold' in a dir that is passed via -B flag (gcc < 12.1) +# +# clang expects -fuse-ld=mold +# or -fuse-ld= +# or --ldpath= (clang >= 12) +# https://github.com/rui314/mold/#how-to-use +# TODO: In the gcc < 12.1 case, the qt_internal_check_if_linker_is_available(mold) check will +# always return TRUE because gcc will not error out if it is given a -B flag pointing to an +# invalid dir, as well as when the the symlink to the linker in the -B dir is not actually +# a valid linker. +# It would be nice to handle that case in a better way, but it's not that important +# given that gcc > 12.1 now supports -fuse-ld=mold +# NOTE: In comparison to clang, in the gcc < 12.1 case, we pass the full path to where mold is +# and that is recorded in PlatformCommonInternal's INTERFACE_LINK_OPTIONS target. +# Moving such a Qt to a different machine and trying to build another repo won't +# work because the recorded path will be invalid. This is not a problem with +# the gcc >= 12.1 case +function(qt_internal_get_mold_linker_flags out_var) + cmake_parse_arguments(PARSE_ARGV 1 arg "ERROR_IF_EMPTY" "" "") + + find_program(QT_INTERNAL_LINKER_MOLD mold) + + set(flag "") + if(QT_INTERNAL_LINKER_MOLD) + if(GCC) + if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1") + set(flag "-fuse-ld=mold") + else() + set(mold_linker_dir "${CMAKE_CURRENT_BINARY_DIR}/.qt_linker") + set(mold_linker_path "${mold_linker_dir}/ld") + if(NOT EXISTS "${mold_linker_dir}") + file(MAKE_DIRECTORY "${mold_linker_dir}") + endif() + if(NOT EXISTS "${mold_linker_path}") + file(CREATE_LINK + "${QT_INTERNAL_LINKER_MOLD}" + "${mold_linker_path}" + SYMBOLIC) + endif() + set(flag "-B${mold_linker_dir}") + endif() + elseif(CLANG) + if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12") + set(flag "--ld-path=mold") + else() + set(flag "-fuse-ld=mold") + endif() + endif() + endif() + if(arg_ERROR_IS_EMPTY AND NOT flag) + message(FATAL_ERROR "Could not determine the flags to use the mold linker.") + endif() + set(${out_var} "${flag}" PARENT_SCOPE) +endfunction() + +function(qt_internal_get_active_linker_flags out_var) + set(flags "") + if(GCC OR CLANG) + if(QT_FEATURE_use_gold_linker) + list(APPEND flags "-fuse-ld=gold") + elseif(QT_FEATURE_use_bfd_linker) + list(APPEND flags "-fuse-ld=bfd") + elseif(QT_FEATURE_use_lld_linker) + list(APPEND flags "-fuse-ld=lld") + elseif(QT_FEATURE_use_mold_linker) + qt_internal_get_mold_linker_flags(mold_flags ERROR_IF_EMPTY) + list(APPEND flags "${mold_flags}") + endif() + endif() + set(${out_var} "${flags}" PARENT_SCOPE) +endfunction() + +function(qt_internal_check_if_linker_is_available name) + if(DEFINED "TEST_${name}") + return() + endif() + + cmake_parse_arguments(arg "" "LABEL;FLAG" "" ${ARGN}) + set(flags "${arg_FLAG}") + + set(CMAKE_REQUIRED_LINK_OPTIONS ${flags}) + check_cxx_source_compiles("int main() { return 0; }" TEST_${name}) + set(TEST_${name} "${TEST_${name}}" CACHE INTERNAL "${label}") +endfunction() + +function(qt_config_linker_supports_flag_test name) + if(DEFINED "TEST_${name}") + return() + endif() + + cmake_parse_arguments(arg "" "LABEL;FLAG" "" ${ARGN}) + if(GCC OR CLANG) + set(flags "-Wl,--fatal-warnings,${arg_FLAG}") + elseif(MSVC) + set(flags "${arg_FLAG}") + else() + # We don't know how to pass linker options in a way that + # it reliably fails, so assume the detection failed. + set(TEST_${name} "0" CACHE INTERNAL "${label}") + return() + endif() + + # Pass the linker that the main project uses to the compile test. + qt_internal_get_active_linker_flags(linker_flags) + if(linker_flags) + list(PREPEND flags ${linker_flags}) + endif() + + set(CMAKE_REQUIRED_LINK_OPTIONS ${flags}) + check_cxx_source_compiles("int main() { return 0; }" TEST_${name}) + set(TEST_${name} "${TEST_${name}}" CACHE INTERNAL "${label}") +endfunction() + +function(qt_make_features_available target) + if(NOT "${target}" MATCHES "^${QT_CMAKE_EXPORT_NAMESPACE}::[a-zA-Z0-9_-]*$") + message(FATAL_ERROR "${target} does not match ${QT_CMAKE_EXPORT_NAMESPACE}::[a-zA-Z0-9_-]*. INVALID NAME.") + endif() + if(NOT TARGET ${target}) + message(FATAL_ERROR "${target} not found.") + endif() + + get_target_property(target_type "${target}" TYPE) + if("${target_type}" STREQUAL "INTERFACE_LIBRARY") + set(property_prefix "INTERFACE_") + else() + set(property_prefix "") + endif() + foreach(visibility IN ITEMS PUBLIC PRIVATE) + set(value ON) + foreach(state IN ITEMS ENABLED DISABLED) + get_target_property(features "${target}" ${property_prefix}QT_${state}_${visibility}_FEATURES) + if("${features}" STREQUAL "features-NOTFOUND") + continue() + endif() + foreach(feature IN ITEMS ${features}) + if (DEFINED "QT_FEATURE_${feature}" AND NOT "${QT_FEATURE_${feature}}" STREQUAL "${value}") + message(WARNING + "This project was initially configured with the Qt feature \"${feature}\" " + "set to \"${QT_FEATURE_${feature}}\". While loading the " + "\"${target}\" package, the value of the feature " + "has changed to \"${value}\". That might cause a project rebuild due to " + "updated C++ headers. \n" + "In case of build issues, consider removing the CMakeCache.txt file and " + "reconfiguring the project." + ) + endif() + set(QT_FEATURE_${feature} "${value}" CACHE INTERNAL "Qt feature: ${feature} (from target ${target})") + endforeach() + set(value OFF) + endforeach() + endforeach() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFeatureCommon.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFeatureCommon.cmake new file mode 100644 index 0000000000000000000000000000000000000000..55bbbbdf2f18a8dd6e7b77859bba95a9cb1c8035 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFeatureCommon.cmake @@ -0,0 +1,12 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_feature_normalize_name name out_var) + # Normalize the feature name to something CMake can deal with. + if(name MATCHES "c\\+\\+") + string(REGEX REPLACE "[^a-zA-Z0-9_]" "x" name "${name}") + else() + string(REGEX REPLACE "[^a-zA-Z0-9_]" "_" name "${name}") + endif() + set(${out_var} "${name}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFileConfigure.txt.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFileConfigure.txt.in new file mode 100644 index 0000000000000000000000000000000000000000..993a41b4b7bd06ba09d027f28e3ee9f8722ee84c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFileConfigure.txt.in @@ -0,0 +1 @@ +@__qt_file_configure_content@ diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindPackageHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindPackageHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0078ee272c28f9e227a685d16564ff4eaa0352f6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindPackageHelpers.cmake @@ -0,0 +1,651 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# As an optimization when using -developer-build, qt_find_package records which +# packages were found during the initial configuration. Then on subsequent +# reconfigurations it skips looking for packages that were not found on the +# initial run. +# For the build system to pick up a newly added qt_find_package call, you need to: +# - Start with a clean build dir +# - Or remove the /CMakeCache.txt file and configure from scratch +# - Or remove the QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES cache variable (by +# editing CMakeCache.txt) and reconfigure. +macro(qt_find_package) + # Get the target names we expect to be provided by the package. + set(find_package_options CONFIG NO_MODULE MODULE REQUIRED) + set(options ${find_package_options} MARK_OPTIONAL) + set(oneValueArgs MODULE_NAME QMAKE_LIB) + set(multiValueArgs PROVIDED_TARGETS COMPONENTS OPTIONAL_COMPONENTS) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + # If some Qt internal project calls qt_find_package(WrapFreeType), but WrapFreeType was already + # found as part of a find_dependency() call from a ModuleDependencies.cmake file (or similar), + # and the provided target is also found, that means this might have been an unnecessary + # qt_find_package() call, because the dependency was already found via some other transitive + # dependency. Return early, so that CMake doesn't fail with an error with trying to promote the + # targets to be global. This behavior is not enabled by default, because there are cases + # when a regular find_package() (non qt_) can find a package (Freetype -> PNG), and a subsequent + # qt_find_package(PNG PROVIDED_TARGET PNG::PNG) still needs to succeed and register the provided + # targets. To enable the debugging behavior, set QT_DEBUG_QT_FIND_PACKAGE to 1. + set(_qt_find_package_skip_find_package FALSE) + + # Skip looking for packages that were not found on initial configuration, because they likely + # won't be found again, and only waste configuration time. + # Speeds up reconfiguration configuration for certain platforms and repos. + # Due to this behavior being different from what general CMake projects expect, it is only + # done for -developer-builds. + if(QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES AND + NOT "${ARGV0}" IN_LIST QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES + AND "${ARGV0}" IN_LIST QT_INTERNAL_PREVIOUSLY_SEARCHED_PACKAGES) + set(_qt_find_package_skip_find_package TRUE) + endif() + + set_property(GLOBAL APPEND PROPERTY _qt_previously_searched_packages "${ARGV0}") + + if(QT_DEBUG_QT_FIND_PACKAGE AND ${ARGV0}_FOUND AND arg_PROVIDED_TARGETS) + set(_qt_find_package_skip_find_package TRUE) + foreach(qt_find_package_target_name ${arg_PROVIDED_TARGETS}) + if(NOT TARGET ${qt_find_package_target_name}) + set(_qt_find_package_skip_find_package FALSE) + endif() + endforeach() + + if(_qt_find_package_skip_find_package) + message(AUTHOR_WARNING "qt_find_package(${ARGV0}) called even though the package " + "was already found. Consider removing the call.") + endif() + endif() + + # When configure.cmake is included only to record summary entries, there's no point in looking + # for the packages. + if(__QtFeature_only_record_summary_entries) + set(_qt_find_package_skip_find_package TRUE) + endif() + + # Get the version if specified. + set(package_version "") + if(${ARGC} GREATER_EQUAL 2) + if(${ARGV1} MATCHES "^[0-9\.]+$") + set(package_version "${ARGV1}") + endif() + endif() + + if(arg_COMPONENTS) + # Re-append components to forward them. + list(APPEND arg_UNPARSED_ARGUMENTS "COMPONENTS;${arg_COMPONENTS}") + endif() + if(arg_OPTIONAL_COMPONENTS) + # Re-append optional components to forward them. + list(APPEND arg_UNPARSED_ARGUMENTS "OPTIONAL_COMPONENTS;${arg_OPTIONAL_COMPONENTS}") + endif() + + # Don't look for packages in PATH if requested to. + if(QT_NO_USE_FIND_PACKAGE_SYSTEM_ENVIRONMENT_PATH) + set(_qt_find_package_use_system_env_backup "${CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH}") + set(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH "OFF") + endif() + + if(NOT (arg_CONFIG OR arg_NO_MODULE OR arg_MODULE) AND NOT _qt_find_package_skip_find_package) + # Try to find a config package first in quiet mode + set(config_package_arg ${arg_UNPARSED_ARGUMENTS}) + list(APPEND config_package_arg "CONFIG;QUIET") + find_package(${config_package_arg}) + + # Double check that in config mode the targets become visible. Sometimes + # only the module mode creates the targets. For example with vcpkg, the sqlite + # package provides sqlite3-config.cmake, which offers multi-config targets but + # in their own way. CMake has FindSQLite3.cmake and with the original + # qt_find_package(SQLite3) call it is our intention to use the cmake package + # in module mode. + unset(_qt_any_target_found) + unset(_qt_should_unset_found_var) + if(${ARGV0}_FOUND AND arg_PROVIDED_TARGETS) + foreach(expected_target ${arg_PROVIDED_TARGETS}) + if (TARGET ${expected_target}) + set(_qt_any_target_found TRUE) + break() + endif() + endforeach() + if(NOT _qt_any_target_found) + set(_qt_should_unset_found_var TRUE) + endif() + endif() + # If we consider the package not to be found, make sure to unset both regular + # and CACHE vars, otherwise CMP0126 set to NEW might cause issues with + # packages not being found correctly. + if(NOT ${ARGV0}_FOUND OR _qt_should_unset_found_var) + unset(${ARGV0}_FOUND) + unset(${ARGV0}_FOUND CACHE) + + # Unset the NOTFOUND ${package}_DIR var that might have been set by the previous + # find_package call, to get rid of "not found" messages in the feature summary + # if the package is found by the next find_package call. + if(DEFINED CACHE{${ARGV0}_DIR} AND NOT ${ARGV0}_DIR) + unset(${ARGV0}_DIR CACHE) + endif() + endif() + endif() + + # Ensure the options are back in the original unparsed arguments + foreach(opt IN LISTS find_package_options) + if(arg_${opt}) + list(APPEND arg_UNPARSED_ARGUMENTS ${opt}) + endif() + endforeach() + + # TODO: Handle packages with components where a previous component is already found. + # E.g. find_package(Qt6 COMPONENTS BuildInternals) followed by + # qt_find_package(Qt6 COMPONENTS Core) doesn't end up calling find_package(Qt6Core). + if (NOT ${ARGV0}_FOUND AND NOT _qt_find_package_skip_find_package) + # Call original function without our custom arguments. + find_package(${arg_UNPARSED_ARGUMENTS}) + endif() + + if(QT_NO_USE_FIND_PACKAGE_SYSTEM_ENVIRONMENT_PATH) + if("${_qt_find_package_use_system_env_backup}" STREQUAL "") + unset(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH) + else() + set(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH "${_qt_find_package_use_system_env_backup}") + endif() + endif() + + if(${ARGV0}_FOUND) + # Record that the package was found, so that future reconfigurations can be sped up. + set_property(GLOBAL APPEND PROPERTY _qt_previously_found_packages "${ARGV0}") + endif() + + if(${ARGV0}_FOUND AND arg_PROVIDED_TARGETS AND NOT _qt_find_package_skip_find_package) + # If package was found, associate each target with its package name. This will be used + # later when creating Config files for Qt libraries, to generate correct find_dependency() + # calls. Also make the provided targets global, so that the properties can be read in + # all scopes. + foreach(qt_find_package_target_name ${arg_PROVIDED_TARGETS}) + if(TARGET ${qt_find_package_target_name}) + # Allow usage of aliased targets by setting properties on the actual target + get_target_property(aliased_target ${qt_find_package_target_name} ALIASED_TARGET) + if(aliased_target) + set(qt_find_package_target_name ${aliased_target}) + endif() + + if("${qt_find_package_target_name}" MATCHES "${QT_CMAKE_EXPORT_NAMESPACE}::" + AND QT_FEATURE_developer_build + ) + message(AUTHOR_WARNING + "qt_find_package() should NOT be used to look up Qt packages. " + "It should only be used to look up 3rd party packages. " + "Please remove the " + "qt_find_package(${ARGV0} PROVIDED_TARGETS " + "${qt_find_package_target_name}) call and contact the build tools team " + "in case the removal is causing issues." + ) + endif() + + set_target_properties(${qt_find_package_target_name} PROPERTIES + INTERFACE_QT_PACKAGE_NAME ${ARGV0} + INTERFACE_QT_PACKAGE_IS_OPTIONAL ${arg_MARK_OPTIONAL}) + if(package_version) + set_target_properties(${qt_find_package_target_name} + PROPERTIES INTERFACE_QT_PACKAGE_VERSION ${ARGV1}) + endif() + + # Save the retrieved package version. + set(_qt_find_package_found_version "") + if(${ARGV0}_VERSION) + set(_qt_find_package_found_version "${${ARGV0}_VERSION}") + set_target_properties(${qt_find_package_target_name} + PROPERTIES + _qt_package_found_version "${_qt_find_package_found_version}") + endif() + + if(arg_COMPONENTS) + string(REPLACE ";" " " components_as_string "${arg_COMPONENTS}") + set_property(TARGET ${qt_find_package_target_name} + PROPERTY INTERFACE_QT_PACKAGE_COMPONENTS ${components_as_string}) + endif() + + if(arg_OPTIONAL_COMPONENTS) + string(REPLACE ";" " " components_as_string "${arg_OPTIONAL_COMPONENTS}") + set_property(TARGET ${qt_find_package_target_name} + PROPERTY INTERFACE_QT_PACKAGE_OPTIONAL_COMPONENTS + ${components_as_string}) + endif() + + # Work around: QTBUG-125371 + if(NOT "${ARGV0}" STREQUAL "Qt6") + # Record the package + component + optional component provided targets. + qt_internal_record_package_component_provided_targets( + PACKAGE_NAME "${ARGV0}" + ON_TARGET ${qt_find_package_target_name} + PROVIDED_TARGETS ${arg_PROVIDED_TARGETS} + COMPONENTS ${arg_COMPONENTS} + OPTIONAL_COMPONENTS ${arg_OPTIONAL_COMPONENTS} + ) + endif() + + _qt_internal_promote_3rd_party_provided_target_and_3rd_party_deps_to_global( + "${qt_find_package_target_name}") + + set(_qt_find_package_sbom_args "") + + if(_qt_find_package_found_version) + list(APPEND _qt_find_package_sbom_args + PACKAGE_VERSION "${_qt_find_package_found_version}" + ) + endif() + + # Work around: QTBUG-125371 + if(NOT "${ARGV0}" STREQUAL "Qt6") + _qt_internal_sbom_record_system_library_usage( + "${qt_find_package_target_name}" + TYPE SYSTEM_LIBRARY + FRIENDLY_PACKAGE_NAME "${ARGV0}" + ${_qt_find_package_sbom_args} + ) + endif() + endif() + endforeach() + + if(arg_MODULE_NAME AND arg_QMAKE_LIB + AND (NOT arg_QMAKE_LIB IN_LIST QT_QMAKE_LIBS_FOR_${arg_MODULE_NAME})) + set(QT_QMAKE_LIBS_FOR_${arg_MODULE_NAME} + ${QT_QMAKE_LIBS_FOR_${arg_MODULE_NAME}};${arg_QMAKE_LIB} CACHE INTERNAL "") + set(${arg_QMAKE_LIB}_existing_targets "") + foreach(provided_target ${arg_PROVIDED_TARGETS}) + if(TARGET ${provided_target}) + list(APPEND ${arg_QMAKE_LIB}_existing_targets "${provided_target}") + set(QT_QMAKE_LIB_OF_TARGET_${provided_target} + ${arg_QMAKE_LIB} CACHE INTERNAL "") + endif() + endforeach() + set(QT_TARGETS_OF_QMAKE_LIB_${arg_QMAKE_LIB} + "${${arg_QMAKE_LIB}_existing_targets}" CACHE INTERNAL "") + endif() + endif() +endmacro() + +# Records information about a package's provided targets, given a specific list of components. +# +# A package might contain multiple components, and create only a subset of targets based on which +# components are looked for. +# This function computes a unique key / id using the package name and the components that are +# passed. +# Then it saves the id in a property on the ON_TARGET target. The ON_TARGET target is one +# of the provided targets for that package id. This allows us to create a relationship to find +# the package id, given a target. +# The function also appends the list of provided targets for that package id to a global property. +# This information will later be saved into the module Dependencies.cmake file. +function(qt_internal_record_package_component_provided_targets) + set(opt_args "") + set(single_args + PACKAGE_NAME + ON_TARGET + ) + set(multi_args + COMPONENTS + OPTIONAL_COMPONENTS + PROVIDED_TARGETS + ) + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_PACKAGE_NAME) + message(FATAL_ERROR "PACKAGE_NAME is required.") + endif() + + if(NOT arg_ON_TARGET) + message(FATAL_ERROR "ON_TARGET is required.") + endif() + + _qt_internal_get_package_components_id( + PACKAGE_NAME "${arg_PACKAGE_NAME}" + COMPONENTS ${arg_COMPONENTS} + OPTIONAL_COMPONENTS ${arg_OPTIONAL_COMPONENTS} + OUT_VAR_KEY package_key + ) + + set_target_properties(${arg_ON_TARGET} PROPERTIES + _qt_package_components_id "${package_key}" + ) + + _qt_internal_append_to_cmake_property_without_duplicates( + _qt_find_package_${package_key}_provided_targets + "${arg_PROVIDED_TARGETS}" + ) +endfunction() + +# Save found packages in the cache. They will be read on next reconfiguration to skip looking +# for packages that were not previously found. +# Only applies to -developer-builds by default. +# Can also be opted in or opted out via QT_INTERNAL_SAVE_PREVIOUSLY_FOUND_PACKAGES. +# Opting out will need two reconfigurations to take effect. +function(qt_internal_save_previously_visited_packages) + if(DEFINED QT_INTERNAL_SAVE_PREVIOUSLY_FOUND_PACKAGES) + set(should_save "${QT_INTERNAL_SAVE_PREVIOUSLY_FOUND_PACKAGES}") + else() + if(FEATURE_developer_build OR QT_FEATURE_developer_build) + set(should_save ON) + else() + set(should_save OFF) + endif() + endif() + + if(NOT should_save) + # When the value is flipped to OFF, remove any previously saved packages. + unset(QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES CACHE) + unset(QT_INTERNAL_PREVIOUSLY_SEARCHED_PACKAGES CACHE) + return() + endif() + + get_property(_qt_previously_found_packages GLOBAL PROPERTY _qt_previously_found_packages) + if(_qt_previously_found_packages) + list(REMOVE_DUPLICATES _qt_previously_found_packages) + set(QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES "${_qt_previously_found_packages}" CACHE INTERNAL + "List of CMake packages found during configuration using qt_find_package.") + endif() + + get_property(_qt_previously_searched_packages GLOBAL PROPERTY _qt_previously_searched_packages) + if(_qt_previously_searched_packages) + list(REMOVE_DUPLICATES _qt_previously_searched_packages) + set(QT_INTERNAL_PREVIOUSLY_SEARCHED_PACKAGES + "${_qt_previously_searched_packages}" CACHE INTERNAL + "List of CMake packages searched during configuration using qt_find_package." + ) + endif() +endfunction() + +# Return qmake library name for the given target, e.g. return "vulkan" for "Vulkan::Vulkan". +function(qt_internal_map_target_to_qmake_lib target out_var) + set(${out_var} "${QT_QMAKE_LIB_OF_TARGET_${target}}" PARENT_SCOPE) +endfunction() + +# This function records a dependency between ${main_target_name} and ${dep_package_name}. +# at the CMake package level. +# E.g. The Tools package that provides the qtwaylandscanner target +# needs to call find_package(WaylandScanner) (non-qt-package). +# main_target_name = qtwaylandscanner +# dep_package_name = WaylandScanner +function(qt_record_extra_package_dependency main_target_name dep_package_name dep_package_version) + if(NOT TARGET "${main_target_name}") + qt_get_tool_target_name(main_target_name "${main_target_name}") + endif() + if (TARGET "${main_target_name}") + get_target_property(extra_packages "${main_target_name}" QT_EXTRA_PACKAGE_DEPENDENCIES) + if(NOT extra_packages) + set(extra_packages "") + endif() + + list(APPEND extra_packages "${dep_package_name}\;${dep_package_version}") + set_target_properties("${main_target_name}" PROPERTIES QT_EXTRA_PACKAGE_DEPENDENCIES + "${extra_packages}") + endif() +endfunction() + +# This function records a dependency between ${main_target_name} and ${dep_target_name} +# at the CMake package level. +# E.g. Qt6CoreConfig.cmake needs to find_package(Qt6EntryPointPrivate). +# main_target_name = Core +# dep_target_name = EntryPointPrivate +# This is just a convenience function that deals with Qt targets and their associated packages +# instead of raw package names. +function(qt_record_extra_qt_package_dependency main_target_name dep_target_name + dep_package_version) + # EntryPointPrivate -> Qt6EntryPointPrivate. + qt_internal_qtfy_target(qtfied_target_name "${dep_target_name}") + qt_record_extra_package_dependency("${main_target_name}" + "${qtfied_target_name_versioned}" "${dep_package_version}") +endfunction() + +# This function records a 'QtFooTools' package dependency for the ${main_target_name} target +# onto the ${dep_package_name} tools package. +# E.g. The QtWaylandCompositor package needs to call find_package(QtWaylandScannerTools). +# main_target_name = WaylandCompositor +# dep_package_name = Qt6WaylandScannerTools +function(qt_record_extra_main_tools_package_dependency + main_target_name dep_package_name dep_package_version) + if(NOT TARGET "${main_target_name}") + qt_get_tool_target_name(main_target_name "${main_target_name}") + endif() + if (TARGET "${main_target_name}") + get_target_property(extra_packages "${main_target_name}" + QT_EXTRA_TOOLS_PACKAGE_DEPENDENCIES) + if(NOT extra_packages) + set(extra_packages "") + endif() + + list(APPEND extra_packages "${dep_package_name}\;${dep_package_version}") + set_target_properties("${main_target_name}" PROPERTIES QT_EXTRA_TOOLS_PACKAGE_DEPENDENCIES + "${extra_packages}") + endif() +endfunction() + +# This function records a 'QtFooTools' package dependency for the ${main_target_name} target +# onto the ${dep_non_versioned_package_name} Tools package. +# main_target_name = WaylandCompositor +# dep_non_versioned_package_name = WaylandScannerTools +# This is just a convenience function to avoid hardcoding the qtified version in the dep package +# name. +function(qt_record_extra_qt_main_tools_package_dependency main_target_name + dep_non_versioned_package_name + dep_package_version) + # WaylandScannerTools -> Qt6WaylandScannerTools. + qt_internal_qtfy_target(qtfied_package_name "${dep_non_versioned_package_name}") + qt_record_extra_main_tools_package_dependency( + "${main_target_name}" "${qtfied_package_name_versioned}" "${dep_package_version}") +endfunction() + +# Record an extra 3rd party target as a dependency for ${main_target_name}. +# +# Adds a find_package(${dep_target_package_name}) in ${main_target_name}Dependencies.cmake. +# +# Needed to record a dependency on the package that provides WrapVulkanHeaders::WrapVulkanHeaders. +# The package version, components, whether the package is optional, etc, are queried from the +# ${dep_target} target properties. +# Usually these are set at the qt_find_package() call site of a configure.cmake file e.g. using +# Qt's MARK_OPTIONAL option. +function(qt_record_extra_third_party_dependency main_target_name dep_target) + if(NOT TARGET "${main_target_name}") + qt_get_tool_target_name(main_target_name "${main_target_name}") + endif() + if(TARGET "${main_target_name}") + get_target_property(extra_deps "${main_target_name}" _qt_extra_third_party_dep_targets) + if(NOT extra_deps) + set(extra_deps "") + endif() + + list(APPEND extra_deps "${dep_target}") + set_target_properties("${main_target_name}" PROPERTIES _qt_extra_third_party_dep_targets + "${extra_deps}") + endif() +endfunction() + +# Sets out_var to TRUE if the non-namespaced ${lib} target is exported as part of Qt6Targets.cmake. +function(qt_internal_is_lib_part_of_qt6_package lib out_var) + if (lib STREQUAL "Platform" + OR lib STREQUAL "GlobalConfig" + OR lib STREQUAL "GlobalConfigPrivate" + OR lib STREQUAL "PlatformModuleInternal" + OR lib STREQUAL "PlatformPluginInternal" + OR lib STREQUAL "PlatformToolInternal" + OR lib STREQUAL "PlatformCommonInternal" + ) + set(${out_var} "TRUE" PARENT_SCOPE) + else() + set(${out_var} "FALSE" PARENT_SCOPE) + endif() +endfunction() + +# Try to get the CMake package version of a Qt target. +# +# Query the target's _qt_package_version property, or try to read it from the CMake package version +# variable set from calling find_package(Qt6${target}). +# Not all targets will have a find_package _VERSION variable, for example if the target is an +# executable. +# A heuristic is used to handle QtFooPrivate module targets. +# If no version can be found, fall back to ${PROJECT_VERSION} and issue a warning. +function(qt_internal_get_package_version_of_target target package_version_out_var) + qt_internal_is_lib_part_of_qt6_package("${target}" is_part_of_qt6) + + if(is_part_of_qt6) + # When building qtbase, Qt6_VERSION is not set (unless examples are built in-tree, + # non-ExternalProject). Use the Platform target's version instead which would be the + # equivalent. + if(TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::Platform") + get_target_property(package_version + "${QT_CMAKE_EXPORT_NAMESPACE}::Platform" _qt_package_version) + endif() + if(NOT package_version) + set(package_version "${${QT_CMAKE_EXPORT_NAMESPACE}_VERSION}") + endif() + else() + # Try to get the version from the target. + # Try the Private target first and if it doesn't exist, try the non-Private target later. + if(TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + get_target_property(package_version + "${QT_CMAKE_EXPORT_NAMESPACE}::${target}" _qt_package_version) + endif() + + # Try to get the version from the corresponding package version variable. + if(NOT package_version) + set(package_version "${${QT_CMAKE_EXPORT_NAMESPACE}${target}_VERSION}") + endif() + + # Try non-Private target. + if(NOT package_version AND target MATCHES "(.*)Private$") + set(target "${CMAKE_MATCH_1}") + endif() + + if(NOT package_version AND TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + get_target_property(package_version + "${QT_CMAKE_EXPORT_NAMESPACE}::${target}" _qt_package_version) + endif() + + if(NOT package_version) + set(package_version "${${QT_CMAKE_EXPORT_NAMESPACE}${target}_VERSION}") + endif() + endif() + + if(NOT package_version) + set(package_version "${PROJECT_VERSION}") + if(FEATURE_developer_build) + message(WARNING + "Could not determine package version of target ${target}. " + "Defaulting to project version ${PROJECT_VERSION}.") + endif() + endif() + + set(${package_version_out_var} "${package_version}" PARENT_SCOPE) +endfunction() + +# Get the CMake package name that contains / exported the Qt module target. +function(qt_internal_get_package_name_of_target target package_name_out_var) + qt_internal_is_lib_part_of_qt6_package("${target}" is_part_of_qt6) + + if(is_part_of_qt6) + set(package_name "${INSTALL_CMAKE_NAMESPACE}") + else() + # Get the package name from the module's target property. + # If not set, fallback to a name based on the target name. + # + # TODO: Remove fallback once sufficient time has passed, aka all developers updated + # their builds not to contain stale FooDependencies.cmakes files without the + # _qt_package_name property. + set(package_name "") + set(package_name_default "${INSTALL_CMAKE_NAMESPACE}${target}") + set(target_namespaced "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + if(TARGET "${target_namespaced}") + get_target_property(package_name_from_prop "${target_namespaced}" _qt_package_name) + if(package_name_from_prop) + set(package_name "${package_name_from_prop}") + endif() + endif() + if(NOT package_name) + message(WARNING + "Could not find target ${target_namespaced} to query its package name. " + "Defaulting to package name ${package_name_default}. Consider re-arranging the " + "project structure to ensure the target exists by this point." + ) + set(package_name "${package_name_default}") + endif() + endif() + + set(${package_name_out_var} "${package_name}" PARENT_SCOPE) +endfunction() + +# This function stores the list of Qt targets a library depend on, +# along with their version info, for usage in ${target}Depends.cmake file +function(qt_register_target_dependencies target public_libs private_libs) + get_target_property(target_deps "${target}" _qt_target_deps) + if(NOT target_deps) + set(target_deps "") + endif() + + get_target_property(target_type ${target} TYPE) + set(lib_list ${public_libs}) + + set(target_is_shared FALSE) + set(target_is_static FALSE) + if(target_type STREQUAL "SHARED_LIBRARY") + set(target_is_shared TRUE) + elseif(target_type STREQUAL "STATIC_LIBRARY") + set(target_is_static TRUE) + endif() + + # Record 'Qt::Foo'-like private dependencies of static library targets, this will be used to + # generate find_dependency() calls. + # + # Private static library dependencies will become $ dependencies in + # INTERFACE_LINK_LIBRARIES. + if(target_is_static) + list(APPEND lib_list ${private_libs}) + endif() + + foreach(lib IN LISTS lib_list) + if("${lib}" MATCHES "^Qt::(.*)") + set(lib "${CMAKE_MATCH_1}") + elseif("${lib}" MATCHES "^${QT_CMAKE_EXPORT_NAMESPACE}::(.*)") + set(lib "${CMAKE_MATCH_1}") + else() + set(lib "") + endif() + + if(lib) + qt_internal_get_package_name_of_target("${lib}" package_name) + qt_internal_get_package_version_of_target("${lib}" package_version) + list(APPEND target_deps "${package_name}\;${package_version}") + endif() + endforeach() + + # Record 'Qt::Foo'-like shared private dependencies of shared library targets. + # + # Private shared library dependencies are listed in the target's + # IMPORTED_LINK_DEPENDENT_LIBRARIES and used in rpath-link calculation. + # See QTBUG-86533 for some details. + # We filter out static libraries and common platform targets, but include both SHARED and + # INTERFACE libraries. INTERFACE libraries in most cases will be FooPrivate libraries. + if(target_is_shared AND private_libs) + foreach(lib IN LISTS private_libs) + set(lib_namespaced "${lib}") + if("${lib}" MATCHES "^Qt::(.*)") + set(lib "${CMAKE_MATCH_1}") + elseif("${lib}" MATCHES "^${QT_CMAKE_EXPORT_NAMESPACE}::(.*)") + set(lib "${CMAKE_MATCH_1}") + else() + set(lib "") + endif() + + if(lib) + set(lib "${CMAKE_MATCH_1}") + + qt_internal_is_lib_part_of_qt6_package("${lib}" is_part_of_qt6) + get_target_property(lib_type "${lib_namespaced}" TYPE) + if(NOT lib_type STREQUAL "STATIC_LIBRARY" AND NOT is_part_of_qt6) + qt_internal_get_package_name_of_target("${lib}" package_name) + qt_internal_get_package_version_of_target("${lib}" package_version) + list(APPEND target_deps "${package_name}\;${package_version}") + endif() + endif() + endforeach() + endif() + + set_target_properties("${target}" PROPERTIES _qt_target_deps "${target_deps}") +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindWrapConfigExtra.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindWrapConfigExtra.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..1dafb523b97599f90da07e45e4b2706493916ed6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindWrapConfigExtra.cmake.in @@ -0,0 +1,4 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +@extra_cmake_code@ diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindWrapHelper.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindWrapHelper.cmake new file mode 100644 index 0000000000000000000000000000000000000000..23efa46dea825d0c1b82aaa54a22e7bbad5b0e0a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFindWrapHelper.cmake @@ -0,0 +1,122 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Creates an imported wrapper target that links against either a Qt bundled package +# or a system package. +# +# Used for consuming 3rd party libraries in Qt. +# +# Example: Creates WrapFreetype::WrapFreetype linking against either +# Qt6::BundledFreetype or WrapSystemFreetype::WrapSystemFreetype. +# +# The implementation has to use a unique prefix in each variable, otherwise when WrapFreetype +# find_package()s WrapPNG, the nested call would override the parent call variables, due to macros +# using the same scope. +macro(qt_find_package_system_or_bundled _unique_prefix) + set(_flags "") + set(_options + FRIENDLY_PACKAGE_NAME + WRAP_PACKAGE_TARGET + WRAP_PACKAGE_FOUND_VAR_NAME + BUNDLED_PACKAGE_NAME + BUNDLED_PACKAGE_TARGET + SYSTEM_PACKAGE_NAME + SYSTEM_PACKAGE_TARGET + ) + set(_multioptions "") + + cmake_parse_arguments("_qfwrap_${_unique_prefix}" + "${_flags}" "${_options}" "${_multioptions}" ${ARGN}) + + # We can't create the same interface imported target multiple times, CMake will complain if we + # do that. This can happen if the find_package call is done in multiple different + # subdirectories. + if(TARGET "${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_TARGET}") + set(${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_FOUND_VAR_NAME} ON) + return() + endif() + + set(${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_FOUND_VAR_NAME} OFF) + + include("FindWrap${_qfwrap_${_unique_prefix}_BUNDLED_PACKAGE_TARGET}ConfigExtra" OPTIONAL) + + if(NOT DEFINED "QT_USE_BUNDLED_${_qfwrap_${_unique_prefix}_BUNDLED_PACKAGE_TARGET}") + message(FATAL_ERROR + "Can't find cache variable " + "QT_USE_BUNDLED_${_qfwrap_${_unique_prefix}_BUNDLED_PACKAGE_TARGET} " + "to decide whether to use bundled or system library.") + endif() + + if("${QT_USE_BUNDLED_${_qfwrap_${_unique_prefix}_BUNDLED_PACKAGE_TARGET}}") + set(${_unique_prefix}_qt_package_name_to_use + "Qt6${_qfwrap_${_unique_prefix}_BUNDLED_PACKAGE_NAME}") + set(${_unique_prefix}_qt_package_target_to_use + "Qt6::${_qfwrap_${_unique_prefix}_BUNDLED_PACKAGE_TARGET}") + set(${_unique_prefix}_qt_package_success_message + "Using Qt bundled ${_qfwrap_${_unique_prefix}_FRIENDLY_PACKAGE_NAME}.") + set(${_unique_prefix}_qt_package_type "bundled") + else() + set(${_unique_prefix}_qt_package_name_to_use + "${_qfwrap_${_unique_prefix}_SYSTEM_PACKAGE_NAME}") + set(${_unique_prefix}_qt_package_target_to_use + "${_qfwrap_${_unique_prefix}_SYSTEM_PACKAGE_TARGET}") + set(${_unique_prefix}_qt_package_success_message + "Using system ${_qfwrap_${_unique_prefix}_FRIENDLY_PACKAGE_NAME}.") + set(${_unique_prefix}_qt_package_type "system") + endif() + + if(NOT TARGET "${${_unique_prefix}_qt_package_target_to_use}") + find_package("${${_unique_prefix}_qt_package_name_to_use}") + endif() + + if(TARGET "${${_unique_prefix}_qt_package_target_to_use}") + set(${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_FOUND_VAR_NAME} ON) + message(STATUS "${${_unique_prefix}_qt_package_success_message}") + add_library("${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_TARGET}" INTERFACE IMPORTED) + target_link_libraries("${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_TARGET}" + INTERFACE + ${${_unique_prefix}_qt_package_target_to_use}) + set_target_properties("${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_TARGET}" PROPERTIES + INTERFACE_QT_3RD_PARTY_PACKAGE_TYPE + "${${_unique_prefix}_qt_package_type}") + + + # This might not be set, because qt_find_package() is called from a configure.cmake file via + # qt_feature_evaluate_features, which means the _VERSION var is confined to the function + # scope. + if(${${_unique_prefix}_qt_package_name_to_use}_VERSION) + set(_qfwrap_${_unique_prefix}_package_version + "${${${_unique_prefix}_qt_package_name_to_use}_VERSION}" + ) + else() + # We set this in qt_find_package, so try to retrieve it. + get_target_property(_qfwrap_${_unique_prefix}_package_version_from_prop + "${${_unique_prefix}_qt_package_target_to_use}" _qt_package_found_version) + if(_qfwrap_${_unique_prefix}_package_version_from_prop) + set(_qfwrap_${_unique_prefix}_package_version + "${_qfwrap_${_unique_prefix}_package_version_from_prop}" + ) + else() + set(_qfwrap_${_unique_prefix}_package_version "") + endif() + endif() + + if(_qfwrap_${_unique_prefix}_package_version) + set(Wrap${_qfwrap_${_unique_prefix}_FRIENDLY_PACKAGE_NAME}_VERSION + "${_qfwrap_${_unique_prefix}_package_version}" + ) + set(_qfwrap_${_unique_prefix}_package_version_option + VERSION_VAR "Wrap${_qfwrap_${_unique_prefix}_FRIENDLY_PACKAGE_NAME}_VERSION" + ) + endif() + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args( + Wrap${_qfwrap_${_unique_prefix}_FRIENDLY_PACKAGE_NAME} + REQUIRED_VARS ${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_FOUND_VAR_NAME} + ${_qfwrap_${_unique_prefix}_package_version_option} + ) + elseif(${_unique_prefix}_qt_package_type STREQUAL "bundled") + message(FATAL_ERROR "Can't find ${${_unique_prefix}_qt_package_target_to_use}.") + endif() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFinishPkgConfigFile.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFinishPkgConfigFile.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dde75f3ea751d2eb133066c0e0afc51061da214a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFinishPkgConfigFile.cmake @@ -0,0 +1,31 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Finish a preliminary .pc file. +# +# - Appends to each requirement the proper configuration postfix. +# - Strips empty PkgConfig fields. +# +# This file is to be used in CMake script mode with the following variables set: +# IN_FILE: path to the step 2 preliminary .pc file. +# OUT_FILE: path to the .pc file that is going to be created. +# POSTFIX: postfix for each requirement (optional). + +cmake_policy(SET CMP0057 NEW) +file(STRINGS "${IN_FILE}" lines) +set(content "") +set(emptied "Libs:" "Cflags:" "Requires:") +foreach(line ${lines}) + if(POSTFIX) + if(line MATCHES "^Libs:") + string(REGEX REPLACE "( -lQt[^ ]+)" "\\1${POSTFIX}" line "${line}") + elseif(line MATCHES "^Requires:") + string(REGEX REPLACE "( Qt[^ ]+)" "\\1${POSTFIX}" line "${line}") + endif() + endif() + string(REGEX REPLACE " +$" "" line "${line}") + if(NOT line IN_LIST emptied) + string(APPEND content "${line}\n") + endif() +endforeach() +file(WRITE "${OUT_FILE}" "${content}") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFinishPrlFile.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFinishPrlFile.cmake new file mode 100644 index 0000000000000000000000000000000000000000..143a813ff61227e9ac7c2aa80239a85f9e466870 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFinishPrlFile.cmake @@ -0,0 +1,153 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Finish a preliminary .prl file. +# +# - Replaces occurrences of the build libdir with $$[QT_INSTALL_LIBDIR]. +# - Strips version number suffixes from absolute paths, because qmake's lflag +# merging does not handle them correctly. +# - Transforms absolute library paths into link flags +# aka from "/usr/lib/x86_64-linux-gnu/libcups.so" to "-lcups" +# - Replaces Qt absolute framework paths into a combination of -F$$[QT_INSTALL_LIBS] and +# -framework QtFoo +# - Prepends '-l' to values that are not absolute paths, and don't start with a dash +# aka, '-lfoo', '-framework', '-pthread'. +# +# The path to the final .prl file is stored in the input file as assignment to FINAL_PRL_FILE_PATH. +# +# This file is to be used in CMake script mode with the following variables set: +# IN_FILE: path to the step 1 preliminary .prl file +# OUT_FILE: path to the step 2 preliminary .prl file that is going to be created +# QT_LIB_DIRS: list of paths where Qt libraries are located. +# This includes the install prefix and the current repo build dir. +# These paths get replaced with relocatable paths or linker / framework flags. +# LIBRARY_SUFFIXES: list of known library extensions, e.g. .so;.a on Linux +# LIBRARY_PREFIXES: list of known library prefies, e.g. the "lib" in "libz" on on Linux +# LINK_LIBRARY_FLAG: flag used to link a shared library to an executable, e.g. -l on UNIX +# IMPLICIT_LINK_DIRECTORIES: list of implicit linker search paths + +cmake_policy(SET CMP0007 NEW) +cmake_policy(SET CMP0057 NEW) +include("${CMAKE_CURRENT_LIST_DIR}/QtGenerateLibHelpers.cmake") + +file(STRINGS "${IN_FILE}" lines) +set(content "") +set(qt_framework_search_path_inserted FALSE) +foreach(line ${lines}) + if(line MATCHES "^RCC_OBJECTS = (.*)") + set(rcc_objects ${CMAKE_MATCH_1}) + elseif(line MATCHES "^QMAKE_PRL_TARGET_PATH_FOR_CMAKE = (.*)") + set(target_library_path "${CMAKE_MATCH_1}") + elseif(line MATCHES "^QMAKE_PRL_LIBS_FOR_CMAKE = (.*)") + unset(adjusted_libs) + foreach(lib ${CMAKE_MATCH_1}) + if("${lib}" STREQUAL "") + continue() + endif() + + # Check if the absolute path represents a Qt module located either in Qt's + # $prefix/lib dir, or in the build dir of the repo. + if(IS_ABSOLUTE "${lib}") + qt_internal_path_is_relative_to_qt_lib_path( + "${lib}" "${QT_LIB_DIRS}" lib_is_a_qt_module relative_lib) + if(NOT lib_is_a_qt_module) + # It's not a Qt module, extract linker flags from the library path. + qt_transform_absolute_library_paths_to_link_flags(lib_with_link_flag "${lib}") + foreach(flag ${lib_with_link_flag}) + # Linker flags started with "-L" shouldn't be added duplicately. + if(NOT flag MATCHES "^-L" OR NOT flag IN_LIST adjusted_libs) + list(APPEND adjusted_libs "${flag}") + endif() + endforeach() + else() + # Is a Qt module. + # Transform Qt framework paths into -framework flags. + if(relative_lib MATCHES "^(Qt(.+))\\.framework/") + if(NOT qt_framework_search_path_inserted) + set(qt_framework_search_path_inserted TRUE) + list(APPEND adjusted_libs "-F$$[QT_INSTALL_LIBS]") + endif() + list(APPEND adjusted_libs "-framework" "${CMAKE_MATCH_1}") + else() + # Not a framework, transform the Qt module into relocatable relative path. + qt_strip_library_version_suffix(relative_lib "${relative_lib}") + list(APPEND adjusted_libs "$$[QT_INSTALL_LIBS]/${relative_lib}") + endif() + endif() + else() + # Not absolute path, most likely a library name or a linker flag. + # If linker flag (like -framework, -lfoo, -pthread, keep it as-is). + if(NOT lib MATCHES "^-") + string(PREPEND lib "-l") + endif() + list(APPEND adjusted_libs "${lib}") + endif() + endforeach() + if(rcc_objects) + set(libs_to_prepend ${rcc_objects}) + + # By default, when qmake processes prl files, it first puts the processed library + # on the link line, followed by all values specified in QMAKE_PRL_LIBS. + # Because we add the resource object files into QMAKE_PRL_LIBS, this means they will + # also appear on the link line after the library. + # This causes issues on Linux because the linker may discard unreferenced symbols from + # the library, which are referenced by the resource object files. + # We can't control the placement of the library in relation to QMAKE_PRL_LIBS, but we + # can add the library one more time in QMAKE_PRL_LIBS, after the object files. + # qmake's UnixMakefileGenerator::findLibraries then takes care of deduplication, which + # keeps the last occurrence of the library on the link line, the one after the object + # files. + qt_internal_path_is_relative_to_qt_lib_path( + "${target_library_path}" "${QT_LIB_DIRS}" lib_is_a_qt_module relative_lib) + if(NOT lib_is_a_qt_module) + qt_internal_path_is_relative_to_qt_lib_path( + "${target_library_path}" "${QT_PLUGIN_DIRS}" lib_is_a_qt_plugin relative_lib) + endif() + if(NOT lib_is_a_qt_module AND NOT lib_is_a_qt_plugin) + qt_internal_path_is_relative_to_qt_lib_path( + "${target_library_path}" "${QT_QML_DIRS}" lib_is_a_qt_qml_plugin relative_lib) + endif() + if(NOT lib_is_a_qt_module AND NOT lib_is_a_qt_plugin AND NOT lib_is_a_qt_qml_plugin) + message(AUTHOR_WARNING + "Could not determine relative path for library ${target_library_path} when " + "generating prl file contents. An absolute path will be embedded, which " + "will cause issues if the Qt installation is relocated.") + list(APPEND libs_to_prepend "${target_library_path}") + else() + set(qmake_lib_path_prefix "$$[QT_PRL_INVALID_QMAKE_VARIABLE]") + if(lib_is_a_qt_module) + set(qmake_lib_path_prefix "$$[QT_INSTALL_LIBS]") + elseif(lib_is_a_qt_plugin) + set(qmake_lib_path_prefix "$$[QT_INSTALL_PLUGINS]") + elseif(lib_is_a_qt_qml_plugin) + set(qmake_lib_path_prefix "$$[QT_INSTALL_QML]") + endif() + qt_strip_library_version_suffix(relative_lib "${relative_lib}") + list(APPEND libs_to_prepend "${qmake_lib_path_prefix}/${relative_lib}") + endif() + + list(PREPEND adjusted_libs ${libs_to_prepend}) + endif() + list(JOIN adjusted_libs " " adjusted_libs_for_qmake) + string(APPEND content "QMAKE_PRL_LIBS = ${adjusted_libs_for_qmake}\n") + string(APPEND content "QMAKE_PRL_LIBS_FOR_CMAKE = ${adjusted_libs}\n") + else() + string(APPEND content "${line}\n") + endif() +endforeach() +file(WRITE "${OUT_FILE}" "${content}") + +# Read the prl meta file to find out where should the final prl file be placed, +# Copy it there, if the contents hasn't changed. +file(STRINGS "${IN_META_FILE}" lines) + +foreach(line ${lines}) + if(line MATCHES "^FINAL_PRL_FILE_PATH = (.*)") + set(final_prl_file_path "${CMAKE_MATCH_1}") + configure_file( + "${OUT_FILE}" + "${final_prl_file_path}" + COPYONLY + ) + endif() +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFlagHandlingHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFlagHandlingHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1a4c27241ce82cb149d42bb59eadfe58595c6702 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFlagHandlingHelpers.cmake @@ -0,0 +1,1149 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Sets '${var}' to a genex that extracts the target's property. +# Sets 'have_${var}' to a genex that checks that the property has a +# non-empty value. +macro(qt_internal_genex_get_property var target property) + set(${var} "$") + set(have_${var} "$") +endmacro() + +# Sets '${var}' to a genex that will join the given property values +# using '${glue}' and will surround the entire output with '${prefix}' +# and '${suffix}'. +macro(qt_internal_genex_get_joined_property var target property prefix suffix glue) + qt_internal_genex_get_property("${var}" "${target}" "${property}") + set(${var} + "$<${have_${var}}:${prefix}$${suffix}>") +endmacro() + +# This function generates LD version script for the target and uses it in the target linker line. +# Function has two modes dependending on the specified arguments. +# Arguments: +# PRIVATE_CONTENT_FILE specifies the pre-cooked content of Qt__PRIVATE_API section. +# Requires the content file available at build time. +function(qt_internal_add_linker_version_script target) + if(WASM) + return() + endif() + + cmake_parse_arguments(PARSE_ARGV 1 arg + "" + "PRIVATE_CONTENT_FILE" + "PRIVATE_HEADERS" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + if(arg_PRIVATE_CONTENT_FILE AND arg_PRIVATE_HEADERS) + message(FATAL_ERROR "Both PRIVATE_CONTENT_FILE and PRIVATE_HEADERS are specified.") + endif() + + if(TEST_ld_version_script) + # Create a list of mangled symbol matches for all "std::" symbols. This + # list will catch most symbols, but will miss global-namespace symbols + # that only have std parameters. + # See https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangle.name for reference + set(contents "NonQt {\nlocal:") + + # For types: vtable, VTT, typeinfo, typeinfo name + foreach(ptrqualifier "" "P" "PK") # T, T *, const T * (volatile ignored) + string(APPEND contents "\n _ZT[VTIS]${ptrqualifier}S*;" + "_ZT[VTIS]${ptrqualifier}NS*;") + endforeach() + + # For functions and variables + foreach(special "" + "G[VR]" # guard variables, extended-lifetime references + "GTt") # transaction entry points + foreach(cvqualifier "" "[VK]" "VK") # plain, const|volatile, const volatile + string(APPEND contents "\n ") + foreach(refqualifier "" "[RO]") # plain, & or && + # For names in the std:: namespace, compression applies + # (https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling-compression) + string(APPEND contents + " _Z${special}${cvqualifier}${refqualifier}S*;" # plain + " _Z${special}N${cvqualifier}${refqualifier}S*;" # nested name + ) + endforeach() + endforeach() + endforeach() + + string(APPEND contents "\n};\nQt_${PROJECT_VERSION_MAJOR}") + if(QT_FEATURE_elf_private_full_version) + string(APPEND contents ".${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}") + endif() + string(APPEND contents "_PRIVATE_API { qt_private_api_tag*;\n") + if(arg_PRIVATE_HEADERS) + foreach(ph ${arg_PRIVATE_HEADERS}) + string(APPEND contents " @FILE:${ph}@\n") + endforeach() + else() + string(APPEND contents "@PRIVATE_CONTENT@") + endif() + string(APPEND contents "};\n") + set(current "Qt_${PROJECT_VERSION_MAJOR}") + string(APPEND contents "${current} {\n *;") + + get_target_property(target_type ${target} TYPE) + if(NOT target_type STREQUAL "INTERFACE_LIBRARY") + # Export all specializations of the QExplicitlySharedDataPointer + # and QSharedDataPointer destructors; due to use of the + # QT_DECLARE_Q{,E}SDP_SPECIALIZATION_DTOR_WITH_EXPORT macros + string(APPEND contents "\n _ZN*18QSharedDataPointerI*D?Ev;") + string(APPEND contents "\n _ZN*28QExplicitlySharedDataPointerI*D?Ev;") + + set(genex_prefix "\n ") + set(genex_glue "$\n ") + set(genex_suffix "$") + qt_internal_genex_get_joined_property( + linker_exports "${target}" _qt_extra_linker_script_exports + "${genex_prefix}" "${genex_suffix}" "${genex_glue}" + ) + string(APPEND contents "${linker_exports}") + endif() + string(APPEND contents "\n};\n") + + if(NOT target_type STREQUAL "INTERFACE_LIBRARY") + set(property_genex "$") + set(check_genex "$") + string(APPEND contents + "$<${check_genex}:${property_genex}>") + endif() + + set(infile "${CMAKE_CURRENT_BINARY_DIR}/${target}.version.in") + set(outfile "${CMAKE_CURRENT_BINARY_DIR}/${target}.version") + + file(GENERATE OUTPUT "${infile}" CONTENT "${contents}") + + if(NOT arg_PRIVATE_CONTENT_FILE) + set(arg_PRIVATE_CONTENT_FILE "") + endif() + set(generator_command ${CMAKE_COMMAND} + "-DIN_FILE=${infile}" + "-DPRIVATE_CONTENT_FILE=${arg_PRIVATE_CONTENT_FILE}" + "-DOUT_FILE=${outfile}" + -P "${QT_CMAKE_DIR}/QtGenerateVersionScript.cmake" + ) + set(generator_dependencies + "${arg_PRIVATE_CONTENT_FILE}" + "${QT_CMAKE_DIR}/QtGenerateVersionScript.cmake" + ) + + add_custom_command( + OUTPUT "${outfile}" + COMMAND ${generator_command} + DEPENDS ${generator_dependencies} + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + COMMENT "Generating version linker script for target ${target}" + VERBATIM + ) + add_custom_target(${target}_version_script DEPENDS ${outfile}) + add_dependencies(${target} ${target}_version_script) + target_link_options(${target} PRIVATE "-Wl,--version-script,${outfile}") + endif() +endfunction() + +function(qt_internal_add_link_flags_no_undefined target) + if (NOT QT_BUILD_SHARED_LIBS OR WASM) + return() + endif() + if (VXWORKS) + # VxWorks requires thread_local-related symbols to be found at + # runtime, resulting in linker error when no-undefined flag is + # set and thread_local is used + return() + endif() + if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang") + # ld64 defaults to -undefined,error, and in Xcode 15 + # passing this option is deprecated, causing a warning. + return() + endif() + if ((GCC OR CLANG) AND NOT MSVC) + if(CLANG AND QT_FEATURE_sanitizer) + return() + endif() + set(previous_CMAKE_REQUIRED_LINK_OPTIONS ${CMAKE_REQUIRED_LINK_OPTIONS}) + + set(CMAKE_REQUIRED_LINK_OPTIONS "-Wl,-undefined,error") + check_cxx_source_compiles("int main() {}" HAVE_DASH_UNDEFINED_SYMBOLS) + if(HAVE_DASH_UNDEFINED_SYMBOLS) + set(no_undefined_flag "-Wl,-undefined,error") + endif() + + set(CMAKE_REQUIRED_LINK_OPTIONS "-Wl,--no-undefined") + check_cxx_source_compiles("int main() {}" HAVE_DASH_DASH_NO_UNDEFINED) + if(HAVE_DASH_DASH_NO_UNDEFINED) + set(no_undefined_flag "-Wl,--no-undefined") + endif() + + set(CMAKE_REQUIRED_LINK_OPTIONS ${previous_CMAKE_REQUIRED_LINK_OPTIONS}) + + if (NOT HAVE_DASH_UNDEFINED_SYMBOLS AND NOT HAVE_DASH_DASH_NO_UNDEFINED) + message(FATAL_ERROR "Platform linker doesn't support erroring upon encountering undefined symbols. Target:\"${target}\".") + endif() + target_link_options("${target}" PRIVATE "${no_undefined_flag}") + endif() +endfunction() + +function(qt_internal_apply_gc_binaries_conditional target visibility) + # Should only be applied when the feature is enabled, aka for static builds. + if(NOT QT_FEATURE_gc_binaries) + return() + endif() + qt_internal_apply_gc_binaries("${target}" "${visibility}") +endfunction() + +function(qt_internal_apply_gc_binaries target visibility) + set(possible_visibilities PRIVATE INTERFACE PUBLIC) + if(NOT visibility IN_LIST possible_visibilities) + message(FATAL_ERROR "Visibitily setting must be one of PRIVATE, INTERFACE or PUBLIC.") + endif() + + string(JOIN "" clang_or_gcc_begin + "$<$," + "$," + "$," + "$" + ">:" + ) + set(clang_or_gcc_end ">") + + if ((GCC OR CLANG) AND NOT WASM AND NOT UIKIT AND NOT MSVC) + if(APPLE) + set(gc_sections_flag "-Wl,-dead_strip") + elseif(SOLARIS) + set(gc_sections_flag "-Wl,-z,ignore") + elseif(LINUX OR BSD OR WIN32 OR ANDROID) + set(gc_sections_flag "-Wl,--gc-sections") + endif() + + # Save the flag value with and without genex wrapping, so we can remove the wrapping + # when generating .pc pkgconfig files. + set_property(GLOBAL PROPERTY _qt_internal_gc_sections_without_genex "${gc_sections_flag}") + + set(gc_sections_flag + "${clang_or_gcc_begin}${gc_sections_flag}${clang_or_gcc_end}") + + set_property(GLOBAL PROPERTY _qt_internal_gc_sections_with_genex "${gc_sections_flag}") + endif() + if(gc_sections_flag) + target_link_options("${target}" ${visibility} "${gc_sections_flag}") + endif() + + if((GCC OR CLANG) AND NOT WASM AND NOT UIKIT AND NOT MSVC) + set(split_sections_flags + "${clang_or_gcc_begin}-ffunction-sections;-fdata-sections${clang_or_gcc_end}") + endif() + if(split_sections_flags) + target_compile_options("${target}" ${visibility} "${split_sections_flags}") + endif() +endfunction() + +# Only applied to Bootstrap and BundledPCRE2. +function(qt_internal_apply_intel_cet target visibility) + if(NOT QT_FEATURE_intelcet) + return() + endif() + + set(possible_visibilities PRIVATE INTERFACE PUBLIC) + if(NOT visibility IN_LIST possible_visibilities) + message(FATAL_ERROR "Visibitily setting must be one of PRIVATE, INTERFACE or PUBLIC.") + endif() + + if(GCC) + string(JOIN "" flags + "$<$," + "$," + "$" + ">:-mshstk>") + endif() + if(flags) + set(opt_out_condition "$>>") + set(flags "$<${opt_out_condition}:${flags}>") + target_compile_options("${target}" ${visibility} "${flags}") + endif() +endfunction() + +# Meant to be applied to PlatformCommonInternal. +function(qt_internal_apply_intel_cet_harderning target) + if(NOT QT_FEATURE_intelcet) + return() + endif() + + set(opt_out_condition "$>>") + + if(MSVC) + set(intel_cet_flag "-CETCOMPAT") + set(condition "$<${opt_out_condition}:${intel_cet_flag}>") + qt_internal_platform_link_options("${target}" INTERFACE "${condition}") + else() + set(intel_cet_flag "-fcf-protection=full") + set(condition "$<${opt_out_condition}:${intel_cet_flag}>") + target_compile_options("${target}" INTERFACE "${condition}") + endif() +endfunction() + +# Allow opting out of the Intel CET hardening on a per-target basis. +function(qt_internal_skip_intel_cet_hardening target) + set_target_properties("${target}" PROPERTIES _qt_no_intel_cet_harderning TRUE) +endfunction() + +# Sets the exceptions flags for the given target according to exceptions_on +function(qt_internal_set_exceptions_flags target exceptions_on) + set(_defs "") + set(_flag "") + if(exceptions_on) + if(MSVC) + set(_flag "/EHsc") + if((MSVC_VERSION GREATER_EQUAL 1929) AND NOT CLANG) + # Use the undocumented compiler flag to make our binary smaller on x64. + # https://devblogs.microsoft.com/cppblog/making-cpp-exception-handling-smaller-x64/ + # NOTE: It seems we'll use this new exception handling model unconditionally without + # this hack since some unknown MSVC version. + set(_flag ${_flag} "/d2FH4") + endif() + else() + set(_flag "-fexceptions") + endif() + else() + set(_defs "QT_NO_EXCEPTIONS") + if(MSVC) + set(_flag "/EHs-c-" "/wd4530" "/wd4577") + else() + set(_flag "-fno-exceptions") + endif() + endif() + + target_compile_definitions("${target}" PRIVATE ${_defs}) + target_compile_options("${target}" PRIVATE ${_flag}) +endfunction() + +function(qt_skip_warnings_are_errors target) + get_target_property(target_type "${target}" TYPE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + return() + endif() + set_target_properties("${target}" PROPERTIES QT_SKIP_WARNINGS_ARE_ERRORS ON) +endfunction() + +function(qt_skip_warnings_are_errors_when_repo_unclean target) + if(QT_REPO_NOT_WARNINGS_CLEAN) + qt_skip_warnings_are_errors("${target}") + endif() +endfunction() + +function(qt_disable_warnings target) + get_target_property(target_type "${target}" TYPE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + return() + endif() + set_target_properties("${target}" PROPERTIES QT_COMPILE_OPTIONS_DISABLE_WARNINGS ON) +endfunction() + +function(qt_set_symbol_visibility_preset target value) + get_target_property(target_type "${target}" TYPE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + return() + endif() + + set_target_properties("${target}" PROPERTIES C_VISIBILITY_PRESET "${value}") + set_target_properties("${target}" PROPERTIES CXX_VISIBILITY_PRESET "${value}") + set_target_properties("${target}" PROPERTIES OBJC_VISIBILITY_PRESET "${value}") + set_target_properties("${target}" PROPERTIES OBJCXX_VISIBILITY_PRESET "${value}") +endfunction() + +function(qt_set_symbol_visibility_hidden target) + qt_set_symbol_visibility_preset("${target}" "hidden") +endfunction() + +function(qt_set_language_standards) + ## Use the latest standard the compiler supports (same as qt_common.prf) + if (QT_FEATURE_cxx2b) + set(CMAKE_CXX_STANDARD 23 PARENT_SCOPE) + elseif (QT_FEATURE_cxx20) + set(CMAKE_CXX_STANDARD 20 PARENT_SCOPE) + else() + set(CMAKE_CXX_STANDARD 17 PARENT_SCOPE) + endif() + set(CMAKE_CXX_STANDARD_REQUIRED ON PARENT_SCOPE) + + set(CMAKE_C_STANDARD 11 PARENT_SCOPE) + set(CMAKE_C_STANDARD_REQUIRED ON PARENT_SCOPE) +endfunction() + +function(qt_set_language_standards_interface_compile_features target) + # Regardless of which C++ standard is used to build Qt itself, require C++17 when building + # Qt applications using CMake (because the Qt header files use C++17 features). + set(cpp_feature "cxx_std_17") + target_compile_features("${target}" INTERFACE ${cpp_feature}) +endfunction() + +function(qt_set_msvc_cplusplus_options target visibility) + # For MSVC we need to explicitly pass -Zc:__cplusplus to get correct __cplusplus. + # Check qt_config_compile_test for more info. + if(MSVC AND MSVC_VERSION GREATER_EQUAL 1913) + set(flags "-Zc:__cplusplus" "-permissive-") + target_compile_options("${target}" ${visibility} + "$<$,$>:${flags}>") + endif() +endfunction() + +function(qt_enable_utf8_sources target) + set(utf8_flags "") + if(MSVC) + list(APPEND utf8_flags "$<$:-utf-8>") + endif() + + if(utf8_flags) + # Allow opting out by specifying the QT_NO_UTF8_SOURCE target property. + set(opt_out_condition "$>>") + # Only set the compiler option for C and C++. + set(language_condition "$") + # Compose the full condition. + set(genex_condition "$") + set(utf8_flags "$<${genex_condition}:${utf8_flags}>") + target_compile_options("${target}" INTERFACE "${utf8_flags}") + endif() +endfunction() + +function(qt_internal_enable_unicode_defines) + if(WIN32) + set(no_unicode_condition + "$>>") + target_compile_definitions(Platform + INTERFACE "$<${no_unicode_condition}:UNICODE$_UNICODE>") + endif() +endfunction() + +# Saves the list of known optimization flags for the current compiler in out_var. +# +# Mostly used for removing them before adding new ones. +function(qt_internal_get_all_possible_optimization_flag_values out_var) + set(flag_values "") + set(vars QT_CFLAGS_OPTIMIZE QT_CFLAGS_OPTIMIZE_FULL + QT_CFLAGS_OPTIMIZE_DEBUG QT_CFLAGS_OPTIMIZE_SIZE) + foreach(optimize_var ${vars}) + set(value "${${optimize_var}}") + if(value) + list(APPEND flag_values "${value}") + endif() + endforeach() + + # Additional flag values which might not be used in qmake mkspecs, but might be set by CMake, + # aka flags that are recognized by the compile which we might want to remove. + if(QT_CFLAGS_OPTIMIZE_VALID_VALUES) + list(APPEND flag_values ${QT_CFLAGS_OPTIMIZE_VALID_VALUES}) + endif() + + set("${out_var}" "${flag_values}" PARENT_SCOPE) +endfunction() + +# Return's the current compiler's optimize_full flags if available. +# Otherwise returns the regular optimization level flag. +function(qt_internal_get_optimize_full_flags out_var) + set(optimize_full_flags "${QT_CFLAGS_OPTIMIZE_FULL}") + if(NOT optimize_full_flags) + set(optimize_full_flags "${QT_CFLAGS_OPTIMIZE}") + endif() + set(${out_var} "${optimize_full_flags}" PARENT_SCOPE) +endfunction() + +# Prints the compiler and linker flags for each configuration, language and target type. +# +# Usually it would print the cache variables, but one may also override the variables +# in a specific directory scope, so this is useful for debugging. +# +# Basically dumps either scoped or cached +# CMAKE__FLAGS_CONFIG> and CMAKE__LINKER_FLAGS_ variables. + +function(qt_internal_print_optimization_flags_values) + qt_internal_get_enabled_languages_for_flag_manipulation(languages) + qt_internal_get_configs_for_flag_manipulation(configs) + qt_internal_get_target_link_types_for_flag_manipulation(target_link_types) + + qt_internal_print_optimization_flags_values_helper( + "${languages}" "${configs}" "${target_link_types}") +endfunction() + +# Helper function for printing the optimization flags. +function(qt_internal_print_optimization_flags_values_helper languages configs target_link_types) + foreach(lang ${languages}) + set(flag_var_name "CMAKE_${lang}_FLAGS") + message(STATUS "${flag_var_name}: ${${flag_var_name}}") + + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + message(STATUS "${flag_var_name}: ${${flag_var_name}}") + endforeach() + endforeach() + + foreach(t ${target_link_types}) + set(flag_var_name "CMAKE_${t}_LINKER_FLAGS") + message(STATUS "${flag_var_name}: ${${flag_var_name}}") + + foreach(config ${configs}) + set(flag_var_name "CMAKE_${t}_LINKER_FLAGS_${config}") + message(STATUS "${flag_var_name}: ${${flag_var_name}}") + endforeach() + endforeach() +endfunction() + +# Saves the list of configs for which flag manipulation will occur. +function(qt_internal_get_configs_for_flag_manipulation out_var) + set(configs RELEASE RELWITHDEBINFO MINSIZEREL DEBUG) + + # Opt into additional non-standard configs for flag removal only. + if(QT_ADDITIONAL_OPTIMIZATION_FLAG_CONFIGS) + list(APPEND configs ${QT_ADDITIONAL_OPTIMIZATION_FLAG_CONFIGS}) + endif() + + set(${out_var} "${configs}" PARENT_SCOPE) +endfunction() + +# Saves the list of target link types for which flag manipulation will occur. +function(qt_internal_get_target_link_types_for_flag_manipulation out_var) + set(target_link_types EXE SHARED MODULE STATIC) + set(${out_var} "${target_link_types}" PARENT_SCOPE) +endfunction() + +# Saves list of enabled languages for which it is safe to manipulate compilation flags. +function(qt_internal_get_enabled_languages_for_flag_manipulation out_var) + # Limit flag modification to c-like code. We don't want to accidentally add incompatible + # flags to MSVC's RC or Swift. + set(languages_to_process ASM C CXX OBJC OBJCXX) + get_property(globally_enabled_languages GLOBAL PROPERTY ENABLED_LANGUAGES) + set(enabled_languages "") + foreach(lang ${languages_to_process}) + if(lang IN_LIST globally_enabled_languages) + list(APPEND enabled_languages "${lang}") + endif() + endforeach() + set(${out_var} "${enabled_languages}" PARENT_SCOPE) +endfunction() + +# Helper function used to update compiler and linker flags further below +function(qt_internal_replace_flags_impl flag_var_name match_string replace_string IN_CACHE) + # This must come before cache variable modification because setting the + # cache variable with FORCE will overwrite the non-cache variable, but + # we need to use the original value on entry to this function. + + # Handle an empty input string and an empty match string as a set(). + if(match_string STREQUAL "" AND "${${flag_var_name}}" STREQUAL "") + set(${flag_var_name} "${replace_string}" PARENT_SCOPE) + else() + string(REPLACE + "${match_string}" "${replace_string}" + ${flag_var_name} "${${flag_var_name}}") + string(STRIP "${${flag_var_name}}" ${flag_var_name}) + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endif() + + if(IN_CACHE) + # We must not use the non-cache variable's value because toolchain files + # might be appending things to the cache variable's value and storing it + # in a non-cache variable (e.g. Android NDK toolchain file does this). + # Work exclusively on cache variable value only. + get_property(help_text CACHE "${flag_var_name}" PROPERTY HELPSTRING) + + # Handle an empty input string and an empty match string as a set(). + if(match_string STREQUAL "" AND "$CACHE{${flag_var_name}}" STREQUAL "") + set(${flag_var_name} "${replace_string}" CACHE STRING "${help_text}" FORCE) + else() + set(mod_flags "$CACHE{${flag_var_name}}") + string(REPLACE + "${match_string}" "${replace_string}" + mod_flags "${mod_flags}") + string(STRIP "${mod_flags}" mod_flags) + set(${flag_var_name} "${mod_flags}" CACHE STRING "${help_text}" FORCE) + endif() + endif() +endfunction() + +# Helper function used to update compiler and linker flags further below +function(qt_internal_remove_flags_impl flag_var_name flag_values IN_CACHE) + cmake_parse_arguments(arg "REGEX" "" "" ${ARGN}) + set(replace_type REPLACE) + if(arg_REGEX) + list(PREPEND replace_type REGEX) + endif() + + # This must come before cache variable modification because setting the + # cache variable with FORCE will overwrite the non-cache variable in this + # function scope, but we need to use the original value before that change. + foreach(flag_value IN LISTS flag_values) + string(${replace_type} "${flag_value}" " " ${flag_var_name} "${${flag_var_name}}") + endforeach() + string(STRIP "${${flag_var_name}}" ${flag_var_name}) + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + + if(IN_CACHE) + # We must not use the non-cache variable's value because toolchain files + # might be appending things to the cache variable's value and storing it + # in a non-cache variable (e.g. Android NDK toolchain file does this). + # Work exclusively on cache variable value only. + set(mod_flags $CACHE{${flag_var_name}}) + foreach(flag_value IN LISTS flag_values) + string(${replace_type} "${flag_value}" " " mod_flags "${mod_flags}") + endforeach() + string(STRIP "${mod_flags}" mod_flags) + get_property(help_text CACHE ${flag_var_name} PROPERTY HELPSTRING) + set(${flag_var_name} "${mod_flags}" CACHE STRING "${help_text}" FORCE) + endif() +endfunction() + +# Helper function used to update compiler and linker flags further below +function(qt_internal_add_flags_impl flag_var_name flags IN_CACHE) + # This must come before cache variable modification because setting the + # cache variable with FORCE will overwrite the non-cache variable, but + # we need to use the original value on entry to this function. + set(${flag_var_name} "${${flag_var_name}} ${flags}") + string(STRIP "${${flag_var_name}}" ${flag_var_name}) + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + + if(IN_CACHE) + # We must not use the non-cache variable's value because toolchain files + # might be appending things to the cache variable's value and storing it + # in a non-cache variable (e.g. Android NDK toolchain file does this). + # Work exclusively on cache variable value only. + set(mod_flags "$CACHE{${flag_var_name}} ${flags}") + string(STRIP "${mod_flags}" mod_flags) + get_property(help_text CACHE ${flag_var_name} PROPERTY HELPSTRING) + set(${flag_var_name} "${mod_flags}" CACHE STRING "${help_text}" FORCE) + endif() +endfunction() + + +# Removes all known compiler optimization flags for the given CONFIGS, for all enabled 'safe' +# languages. The flag variables are always updated in the calling scope, even if they did not +# exist beforehand. +# +# IN_CACHE - remove them from the corresponding cache variable too. Note that the cache +# variable may have a different value to the non-cache variable. +# CONFIGS - should be a list of upper case configs like DEBUG, RELEASE, RELWITHDEBINFO. +# LANGUAGES - optional list of languages like 'C', 'CXX', for which to remove the flags +# if not provided, defaults to the list of enabled C-like languages +function(qt_internal_remove_known_optimization_flags) + cmake_parse_arguments(PARSE_ARGV 0 arg + "IN_CACHE" + "" + "CONFIGS;LANGUAGES") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_CONFIGS) + message(FATAL_ERROR + "You must specify at least one configuration for which to remove the flags.") + endif() + + if(arg_LANGUAGES) + set(enabled_languages "${arg_LANGUAGES}") + else() + qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages) + endif() + + qt_internal_get_all_possible_optimization_flag_values(flag_values) + set(configs ${arg_CONFIGS}) + + foreach(lang ${enabled_languages}) + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + qt_internal_remove_flags_impl(${flag_var_name} "${flag_values}" "${arg_IN_CACHE}") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() +endfunction() + +# Removes specified flags from CMAKE__FLAGS[_CONFIGS] variables +# +# Option Arguments: +# IN_CACHE +# Enables flags removal from CACHE +# REGEX +# Enables the flag processing as a regular expression. +# +# Multi-value Arguments: +# CONFIGS +# List of configurations that need to clear flags. Clears all configs by default if not +# specified. +# +# LANGUAGES +# List of LANGUAGES that need clear flags. Clears all languages by default if not +# specified. +function(qt_internal_remove_compiler_flags flags) + cmake_parse_arguments(PARSE_ARGV 1 arg + "IN_CACHE;REGEX" + "" + "CONFIGS;LANGUAGES" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + if("${flags}" STREQUAL "") + message(WARNING "qt_internal_remove_compiler_flags was called without any flags specified.") + return() + endif() + + if(arg_LANGUAGES) + set(languages "${arg_LANGUAGES}") + else() + qt_internal_get_enabled_languages_for_flag_manipulation(languages) + endif() + + if(arg_CONFIGS) + set(configs "${arg_CONFIGS}") + else() + qt_internal_get_configs_for_flag_manipulation(configs) + endif() + + if(arg_REGEX) + list(APPEND extra_options "REGEX") + endif() + + foreach(lang ${languages}) + set(flag_var_name "CMAKE_${lang}_FLAGS") + qt_internal_remove_flags_impl(${flag_var_name} + "${flags}" + "${arg_IN_CACHE}" + ${extra_options} + ) + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + qt_internal_remove_flags_impl(${flag_var_name} + "${flags}" + "${arg_IN_CACHE}" + ${extra_options} + ) + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() +endfunction() + +# Adds compiler flags for the given CONFIGS in the calling scope. Can also update the cache +# if asked to do so. The flag variables are always updated in the calling scope, even if they +# did not exist beforehand. +# +# FLAGS - should be a single string of flags separated by spaces. +# IN_CACHE - add them to the corresponding cache variable too. Note that the cache +# variable may have a different value to the non-cache variable. +# CONFIGS - should be a list of upper case configs like DEBUG, RELEASE, RELWITHDEBINFO. +# LANGUAGES - optional list of languages like 'C', 'CXX', for which to add the flags +# if not provided, defaults to the list of enabled C-like languages +function(qt_internal_add_compiler_flags) + cmake_parse_arguments(PARSE_ARGV 0 arg + "IN_CACHE" + "FLAGS" + "CONFIGS;LANGUAGES") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_CONFIGS) + message(FATAL_ERROR + "You must specify at least one configuration for which to add the flags.") + endif() + if(NOT arg_FLAGS) + message(FATAL_ERROR "You must specify at least one flag to add.") + endif() + + if(arg_LANGUAGES) + set(enabled_languages "${arg_LANGUAGES}") + else() + qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages) + endif() + + set(configs ${arg_CONFIGS}) + + foreach(lang ${enabled_languages}) + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + qt_internal_add_flags_impl(${flag_var_name} "${arg_FLAGS}" "${arg_IN_CACHE}") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() +endfunction() + +# Convenience function that adds compiler flags for all release configurations. +# The flag variables are always updated in the calling scope, even if they did not +# exist beforehand. +# +# FLAGS - should be a single string of flags separated by spaces. +# IN_CACHE - add them to the corresponding cache variable too. Note that the cache +# variable may have a different value to the non-cache variable. +# LANGUAGES - optional list of languages like 'C', 'CXX', for which to add the flags +# if not provided, defaults to the list of enabled C-like languages +function(qt_internal_add_compiler_flags_for_release_configs) + cmake_parse_arguments(PARSE_ARGV 0 arg + "IN_CACHE" + "FLAGS" + "LANGUAGES") + _qt_internal_validate_all_args_are_parsed(arg) + + set(args "") + + if(arg_LANGUAGES) + set(enabled_languages "${arg_LANGUAGES}") + else() + qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages) + endif() + + set(configs RELEASE RELWITHDEBINFO MINSIZEREL) + + list(APPEND args CONFIGS ${configs}) + + if(arg_FLAGS) + list(APPEND args FLAGS "${arg_FLAGS}") + endif() + + if(arg_IN_CACHE) + list(APPEND args IN_CACHE) + endif() + list(APPEND args LANGUAGES ${enabled_languages}) + + qt_internal_add_compiler_flags(${args}) + + foreach(lang ${enabled_languages}) + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + set("${flag_var_name}" "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() +endfunction() + +# Convenience function that replaces all optimization flags with the equivalent of '-O3' +# (optimize_full) flag for all release configs. +# +# This is the equivalent of qmake's CONFIG += optimize_full. +# It is meant to be called in a subdirectory scope to enable full optimizations for a particular +# Qt module, like Core or Gui. +function(qt_internal_add_optimize_full_flags) + cmake_parse_arguments(PARSE_ARGV 0 arg + "IN_CACHE" + "" + "") + _qt_internal_validate_all_args_are_parsed(arg) + + # QT_USE_DEFAULT_CMAKE_OPTIMIZATION_FLAGS disables forced full optimization. + if(QT_USE_DEFAULT_CMAKE_OPTIMIZATION_FLAGS) + return() + endif() + + # Assume that FEATURE_optimize_full has higher priority. But if FEATURE_optimize_full is OFF, + # flags are set by FEATURE_optimize_size should remain unchanged. + if(QT_FEATURE_optimize_size AND NOT QT_FEATURE_optimize_full) + return() + endif() + + set(args "") + if(arg_IN_CACHE) + list(APPEND args IN_CACHE) + endif() + + qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages) + set(configs RELEASE RELWITHDEBINFO) + if(QT_FEATURE_optimize_full) # Assume that FEATURE_optimize_full has higher priority. + list(APPEND configs MINSIZEREL) + endif() + + qt_internal_remove_known_optimization_flags(${args} CONFIGS ${configs}) + + # If the respective compiler doesn't have optimize_full flags, use regular optimization flags. + # Mainly MSVC. + qt_internal_get_optimize_full_flags(optimize_full_flags) + list(APPEND args FLAGS "${optimize_full_flags}") + + qt_internal_add_compiler_flags_for_release_configs(${args}) + + foreach(lang ${enabled_languages}) + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + set("${flag_var_name}" "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() +endfunction() + +# Convenience function to replace a compiler flag with another one, for the given configurations +# for all enabled 'safe' languages. +# Essentially a glorified string(REPLACE). +# Can be used to remove compiler flags. +# The flag variables are always updated in the calling scope, even if they did not +# exist beforehand. +# +# match_string - string to match +# replace_string - replacement string +# IN_CACHE - replace them in the corresponding cache variable too. Note that the cache +# variable may have a different value to the non-cache variable. +# CONFIGS - should be a list of upper case configs like DEBUG, RELEASE, RELWITHDEBINFO. +# LANGUAGES - optional list of languages like 'C', 'CXX', for which to replace the flags +# if not provided, defaults to the list of enabled C-like languages +function(qt_internal_replace_compiler_flags match_string replace_string) + cmake_parse_arguments(PARSE_ARGV 2 arg + "IN_CACHE" + "" + "CONFIGS;LANGUAGES") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_CONFIGS) + message(FATAL_ERROR + "You must specify at least one configuration for which to replace the flags.") + endif() + + if(arg_LANGUAGES) + set(enabled_languages "${arg_LANGUAGES}") + else() + qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages) + endif() + set(configs ${arg_CONFIGS}) + + foreach(lang ${enabled_languages}) + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + qt_internal_replace_flags_impl(${flag_var_name} + "${match_string}" "${replace_string}" "${arg_IN_CACHE}") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() +endfunction() + +# Convenience function to add linker flags, for the given configurations and target link types. +# The flag variables are always updated in the calling scope, even if they did not exist beforehand. +# +# FLAGS - should be a single string of flags separated by spaces. +# IN_CACHE - add them to the corresponding cache variable too. Note that the cache +# variable may have a different value to the non-cache variable. +# CONFIGS - should be a list of upper case configs like DEBUG, RELEASE, RELWITHDEBINFO. +# TYPES - should be a list of target link types as expected by CMake's +# CMAKE__LINKER_FLAGS_ cache variable. +# e.g EXE, MODULE, SHARED, STATIC. +function(qt_internal_add_linker_flags) + cmake_parse_arguments(PARSE_ARGV 0 arg + "IN_CACHE" + "FLAGS" + "CONFIGS;TYPES") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_TYPES) + message(FATAL_ERROR + "You must specify at least one linker target type for which to add the flags.") + endif() + if(NOT arg_CONFIGS) + message(FATAL_ERROR + "You must specify at least one configuration for which to add the flags.") + endif() + if(NOT arg_FLAGS) + message(FATAL_ERROR "You must specify at least one flag to add.") + endif() + + set(configs ${arg_CONFIGS}) + set(target_link_types ${arg_TYPES}) + + foreach(config ${configs}) + foreach(t ${target_link_types}) + set(flag_var_name "CMAKE_${t}_LINKER_FLAGS_${config}") + qt_internal_add_flags_impl(${flag_var_name} "${arg_FLAGS}" "${arg_IN_CACHE}") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() +endfunction() + +# Convenience function to replace a linker flag with another one, for the given configurations +# and target link types. +# Essentially a glorified string(REPLACE). +# Can be used to remove linker flags. +# The flag variables are always updated in the calling scope, even if they did not exist beforehand. +# +# match_string - string to match +# replace_string - replacement string +# IN_CACHE - replace them in the corresponding cache variable too. Note that the cache +# variable may have a different value to the non-cache variable. +# CONFIGS - should be a list of upper case configs like DEBUG, RELEASE, RELWITHDEBINFO. +# TYPES - should be a list of target link types as expected by CMake's +# CMAKE__LINKER_FLAGS_ cache variable. +# e.g EXE, MODULE, SHARED, STATIC. +function(qt_internal_replace_linker_flags match_string replace_string) + cmake_parse_arguments(PARSE_ARGV 2 arg + "IN_CACHE" + "" + "CONFIGS;TYPES") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_TYPES) + message(FATAL_ERROR + "You must specify at least one linker target type for which to replace the flags.") + endif() + if(NOT arg_CONFIGS) + message(FATAL_ERROR + "You must specify at least one configuration for which to replace the flags.") + endif() + + set(configs ${arg_CONFIGS}) + set(target_link_types ${arg_TYPES}) + + foreach(config ${configs}) + foreach(t ${target_link_types}) + set(flag_var_name "CMAKE_${t}_LINKER_FLAGS_${config}") + qt_internal_replace_flags_impl(${flag_var_name} + "${match_string}" "${replace_string}" "${arg_IN_CACHE}") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() +endfunction() + +# This function finds the optimization flags set by the default CMake platform modules or toolchain +# files and replaces them with flags that Qt qmake builds expect, for all the usual +# CMAKE_BUILD_TYPE configurations. +# This normalizes things like using -O2 for both Release and RelWithDebInfo, among other compilation +# flags. Also some linker flags specific to MSVC. +# See QTBUG-85992 for details. +# +# Note that both the calling scope and the CMake cache are updated. +function(qt_internal_set_up_config_optimizations_like_in_qmake) + # Allow opt out. + if(QT_USE_DEFAULT_CMAKE_OPTIMIZATION_FLAGS) + return() + endif() + + qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages) + qt_internal_get_configs_for_flag_manipulation(configs) + qt_internal_get_target_link_types_for_flag_manipulation(target_link_types) + + # You can set QT_DEBUG_OPTIMIZATION_FLAGS to see the before and after results. + if(QT_DEBUG_OPTIMIZATION_FLAGS) + message(STATUS "") + message(STATUS "DEBUG: Original CMake optimization flags.\n") + qt_internal_print_optimization_flags_values_helper("${enabled_languages}" "${configs}" + "${target_link_types}") + endif() + + # Remove known optimization flags. + qt_internal_remove_known_optimization_flags(IN_CACHE CONFIGS ${configs}) + + # Re-add optimization flags as per qmake mkspecs. + foreach(lang ${enabled_languages}) + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + set(value_to_append "") + + # Release and RelWithDebInfo should get the same base optimization flags. + if(config STREQUAL "RELEASE" AND QT_CFLAGS_OPTIMIZE) + set(value_to_append "${QT_CFLAGS_OPTIMIZE}") + elseif(config STREQUAL "RELWITHDEBINFO" AND QT_CFLAGS_OPTIMIZE) + set(value_to_append "${QT_CFLAGS_OPTIMIZE}") + + # MinSizeRel should get the optimize size flag if available, otherwise the regular + # release flag. + elseif(config STREQUAL "MINSIZEREL") + if(QT_CFLAGS_OPTIMIZE_SIZE) + set(value_to_append "${QT_CFLAGS_OPTIMIZE_SIZE}") + else() + set(value_to_append "${QT_CFLAGS_OPTIMIZE}") + endif() + endif() + + # Debug should get the OPTIMIZE_DEBUG flag if the respective feature is ON. + if(config STREQUAL "DEBUG" AND QT_FEATURE_optimize_debug) + set(value_to_append "${QT_CFLAGS_OPTIMIZE_DEBUG}") + endif() + + set(configs_for_optimize_size RELEASE RELWITHDEBINFO) + if(QT_FEATURE_optimize_size AND config IN_LIST configs_for_optimize_size) + set(value_to_append "${QT_CFLAGS_OPTIMIZE_SIZE}") + endif() + + # Check if the fake 'optimize_full' feature is enabled. + # Use the max optimization level flag for all release configs, effectively + # overriding any previous setting. + set(configs_for_optimize RELEASE RELWITHDEBINFO MINSIZEREL) + if(QT_FEATURE_optimize_full AND config IN_LIST configs_for_optimize) + qt_internal_get_optimize_full_flags(optimize_full_flags) + set(value_to_append "${optimize_full_flags}") + endif() + + # Assign value to the cache entry. + if(value_to_append) + qt_internal_add_flags_impl(${flag_var_name} "${value_to_append}" TRUE) + # Delay updating the calling scope's variables to the end of this function + endif() + + endforeach() + endforeach() + + if(MSVC) + # Handle MSVC /INCREMENTAL flag which should not be enabled for Release configurations. + # First remove them from all configs, and re-add INCREMENTAL for Debug only. + set(flag_values "/INCREMENTAL:YES" "/INCREMENTAL:NO" "/INCREMENTAL") + foreach(flag_value ${flag_values}) + qt_internal_replace_linker_flags( + "${flag_value}" "" + CONFIGS ${configs} + TYPES ${target_link_types} + IN_CACHE) + endforeach() + + set(flag_value "/INCREMENTAL:NO") + qt_internal_add_linker_flags( + FLAGS "${flag_value}" + CONFIGS RELEASE RELWITHDEBINFO MINSIZEREL + TYPES EXE SHARED MODULE # when linking static libraries, link.exe can't recognize this parameter, clang-cl will error out. + IN_CACHE) + qt_internal_remove_compiler_flags("(^| )/EH[scra-]*( |$)" LANGUAGES CXX CONFIGS ${configs} IN_CACHE REGEX) + endif() + + # Allow opting into generating debug info in object files with a fake feature. + # This would allow us to enable caching with sccache. + # See QTQAINFRA-3934 for details. + if(MSVC AND QT_FEATURE_msvc_obj_debug_info) + qt_internal_replace_compiler_flags( + "/Zi" "/Z7" + CONFIGS RELWITHDEBINFO DEBUG + TYPES ${target_link_types} + IN_CACHE) + endif() + + # Legacy Android toolchain file adds the `-g` flag to CMAKE__FLAGS, as a + # result, our release build ends up containing debug symbols. To avoid that, we + # remove the flag from CMAKE__FLAGS and add + # it to CMAKE__FLAGS_DEBUG. + # + # Note: + # The new `android.toolchain.cmake` file does not have this problem, but + # it has other issues, eg., https://github.com/android/ndk/issues/1693, so we + # cannot force it. While we do load the new toolchain, it automatically falls + # back to the legacy toolchain, ie., `android-legacy.toolchain.cmake` which + # has the problem described above. + # + # Todo: + # When the new toolchain is fixed, and it doesn't fall back to the legacy + # anymore by default, then we should be able to remove this workaround. + if(ANDROID AND ANDROID_COMPILER_FLAGS MATCHES "(^| )-g") + qt_internal_remove_compiler_flags("-g") + qt_internal_add_compiler_flags(FLAGS "-g" CONFIGS DEBUG RELWITHDEBINFO) + endif() + + # Update all relevant flags in the calling scope + foreach(lang ${enabled_languages}) + set(flag_var_name "CMAKE_${lang}_FLAGS") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + + foreach(config ${configs}) + set(flag_var_name "CMAKE_${lang}_FLAGS_${config}") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() + + foreach(t ${target_link_types}) + set(flag_var_name "CMAKE_${t}_LINKER_FLAGS") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + + foreach(config ${configs}) + set(flag_var_name "CMAKE_${t}_LINKER_FLAGS_${config}") + set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE) + endforeach() + endforeach() + + if(QT_DEBUG_OPTIMIZATION_FLAGS) + message(STATUS "") + message(STATUS "DEBUG: Modified optimization flags to mirror qmake mkspecs.\n") + qt_internal_print_optimization_flags_values_helper("${enabled_languages}" "${configs}" + "${target_link_types}") + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFrameworkHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFrameworkHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9e6cb0ed1e58a52d961acc54121e35d623aa95ca --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtFrameworkHelpers.cmake @@ -0,0 +1,254 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +macro(qt_find_apple_system_frameworks) + if(APPLE) + qt_internal_find_apple_system_framework(FWAppKit AppKit) + qt_internal_find_apple_system_framework(FWCFNetwork CFNetwork) + qt_internal_find_apple_system_framework(FWAssetsLibrary AssetsLibrary) + qt_internal_find_apple_system_framework(FWPhotos Photos) + qt_internal_find_apple_system_framework(FWAudioToolbox AudioToolbox) + qt_internal_find_apple_system_framework(FWApplicationServices ApplicationServices) + qt_internal_find_apple_system_framework(FWCarbon Carbon) + qt_internal_find_apple_system_framework(FWCoreFoundation CoreFoundation) + qt_internal_find_apple_system_framework(FWCoreServices CoreServices) + qt_internal_find_apple_system_framework(FWCoreGraphics CoreGraphics) + qt_internal_find_apple_system_framework(FWCoreText CoreText) + qt_internal_find_apple_system_framework(FWCoreVideo CoreVideo) + qt_internal_find_apple_system_framework(FWCryptoTokenKit CryptoTokenKit) + qt_internal_find_apple_system_framework(FWDiskArbitration DiskArbitration) + qt_internal_find_apple_system_framework(FWFoundation Foundation) + qt_internal_find_apple_system_framework(FWIOBluetooth IOBluetooth) + qt_internal_find_apple_system_framework(FWIOKit IOKit) + qt_internal_find_apple_system_framework(FWIOSurface IOSurface) + qt_internal_find_apple_system_framework(FWImageIO ImageIO) + qt_internal_find_apple_system_framework(FWMetal Metal) + qt_internal_find_apple_system_framework(FWMobileCoreServices MobileCoreServices) + qt_internal_find_apple_system_framework(FWQuartzCore QuartzCore) + qt_internal_find_apple_system_framework(FWSecurity Security) + qt_internal_find_apple_system_framework(FWSystemConfiguration SystemConfiguration) + qt_internal_find_apple_system_framework(FWUIKit UIKit) + qt_internal_find_apple_system_framework(FWCoreLocation CoreLocation) + qt_internal_find_apple_system_framework(FWCoreMotion CoreMotion) + qt_internal_find_apple_system_framework(FWWatchKit WatchKit) + qt_internal_find_apple_system_framework(FWGameController GameController) + qt_internal_find_apple_system_framework(FWCoreBluetooth CoreBluetooth) + qt_internal_find_apple_system_framework(FWAVFoundation AVFoundation) + qt_internal_find_apple_system_framework(FWContacts Contacts) + qt_internal_find_apple_system_framework(FWEventKit EventKit) + qt_internal_find_apple_system_framework(FWHealthKit HealthKit) + qt_internal_find_apple_system_framework(FWUniformTypeIdentifiers UniformTypeIdentifiers) + endif() +endmacro() + +# Given framework_name == 'IOKit', sets non-cache variable 'FWIOKit' to '-framework IOKit' in +# the calling directory scope if the framework is found, or 'IOKit-NOTFOUND'. +function(qt_internal_find_apple_system_framework out_var framework_name) + # To avoid creating many FindFoo.cmake files for each apple system framework, populate each + # FWFoo variable with '-framework Foo' instead of an absolute path to the framework. This makes + # the generated CMake target files relocatable, so that Xcode SDK absolute paths are not + # hardcoded, like with Xcode11.app on the CI. + # We might revisit this later. + set(cache_var_name "${out_var}Internal") + + find_library(${cache_var_name} "${framework_name}") + + if(${cache_var_name} AND ${cache_var_name} MATCHES ".framework$") + set(${out_var} "-framework ${framework_name}" PARENT_SCOPE) + else() + set(${out_var} "${out_var}-NOTFOUND" PARENT_SCOPE) + endif() +endfunction() + +# Copy header files to the framework's Headers directory +# Use this function for header files that +# - are not added as source files to the target +# - are not marked as PUBLIC_HEADER +# - or are private and supposed to end up in the 6.7.8/QtXYZ/private subdir. +function(qt_copy_framework_headers target) + get_target_property(is_fw ${target} FRAMEWORK) + if(NOT "${is_fw}") + return() + endif() + + set(options) + set(oneValueArgs) + set(multiValueArgs PUBLIC PRIVATE QPA RHI SSG) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + qt_internal_get_framework_info(fw ${target}) + get_target_property(output_dir ${target} LIBRARY_OUTPUT_DIRECTORY) + set(output_dir_PUBLIC "${output_dir}/${fw_versioned_header_dir}") + set(output_dir_PRIVATE "${output_dir}/${fw_private_module_header_dir}/private") + set(output_dir_QPA "${output_dir}/${fw_private_module_header_dir}/qpa") + set(output_dir_RHI "${output_dir}/${fw_private_module_header_dir}/rhi") + set(output_dir_SSG "${output_dir}/${fw_private_module_header_dir}/ssg") + + qt_internal_module_info(module "${target}") + + set(out_files "") + set(in_files "") + set(out_dirs "") + set(copy_commands "") + foreach(type IN ITEMS PUBLIC PRIVATE QPA RHI SSG) + set(in_files_${type} "") + set(fw_output_header_dir "${output_dir_${type}}") + list(APPEND out_dirs "${fw_output_header_dir}") + foreach(hdr IN LISTS arg_${type}) + get_filename_component(in_file_path ${hdr} ABSOLUTE) + get_filename_component(in_file_name ${hdr} NAME) + set(out_file_path "${fw_output_header_dir}/${in_file_name}") + list(APPEND out_files ${out_file_path}) + list(APPEND in_files_${type} "${in_file_path}") + endforeach() + if(in_files_${type}) + list(APPEND copy_commands + COMMAND ${CMAKE_COMMAND} -E copy ${in_files_${type}} "${fw_output_header_dir}") + list(APPEND in_files ${in_files_${type}}) + endif() + endforeach() + + list(REMOVE_DUPLICATES out_files) + list(REMOVE_DUPLICATES in_files) + + set(copy_fw_sync_headers_command + "${CMAKE_COMMAND}" -E copy_directory + "${module_build_interface_include_dir}/.syncqt_staging" + "${output_dir}/${fw_versioned_header_dir}" + ) + + set(copy_fw_sync_headers_marker_file + "${CMAKE_CURRENT_BINARY_DIR}/${target}_fw_sync_headers_marker_file" + ) + + set(copy_fw_sync_headers_marker_file_command + "${CMAKE_COMMAND}" -E touch "${copy_fw_sync_headers_marker_file}" + ) + + if(CMAKE_GENERATOR MATCHES "^Ninja") + add_custom_command( + OUTPUT + "${output_dir}/${fw_versioned_header_dir}" + "${copy_fw_sync_headers_marker_file}" + DEPENDS ${target}_sync_headers + COMMAND ${copy_fw_sync_headers_command} + COMMAND ${copy_fw_sync_headers_marker_file_command} + VERBATIM + ) + add_custom_target(${target}_copy_fw_sync_headers + DEPENDS "${output_dir}/${fw_versioned_header_dir}") + else() + add_custom_target(${target}_copy_fw_sync_headers + COMMAND ${copy_fw_sync_headers_command} + COMMAND ${copy_fw_sync_headers_marker_file_command} + DEPENDS ${target}_sync_headers + ) + endif() + + if(out_files) + add_custom_command( + OUTPUT ${out_files} + DEPENDS ${target}_copy_fw_sync_headers ${in_files} + COMMAND + ${CMAKE_COMMAND} -E make_directory ${out_dirs} + ${copy_commands} + VERBATIM + COMMENT "Copy the ${target} header files to the framework directory" + ) + set_property(TARGET ${target} APPEND PROPERTY + QT_COPIED_FRAMEWORK_HEADERS "${out_files}") + endif() +endfunction() + +function(qt_internal_generate_fake_framework_header target) + # Hack to create the "Headers" symlink in the framework: + # Create a fake header file and copy it into the framework by marking it as PUBLIC_HEADER. + # CMake now takes care of creating the symlink. + set(fake_header "${CMAKE_CURRENT_BINARY_DIR}/${target}_fake_header.h") + qt_internal_get_main_cmake_configuration(main_config) + file(GENERATE OUTPUT "${fake_header}" CONTENT "// ignore this file\n" + CONDITION "$") + target_sources(${target} PRIVATE "${fake_header}") + set_source_files_properties("${fake_header}" PROPERTIES GENERATED ON) + set_property(TARGET ${target} APPEND PROPERTY PUBLIC_HEADER "${fake_header}") +endfunction() + +function(qt_finalize_framework_headers_copy target) + get_target_property(target_type ${target} TYPE) + if(${target_type} STREQUAL "INTERFACE_LIBRARY") + return() + endif() + get_target_property(is_fw ${target} FRAMEWORK) + if(NOT "${is_fw}") + return() + endif() + get_target_property(headers ${target} QT_COPIED_FRAMEWORK_HEADERS) + if(headers) + qt_internal_generate_fake_framework_header(${target}) + + # Add a target, e.g. Core_framework_headers, that triggers the header copy. + add_custom_target(${target}_framework_headers DEPENDS ${headers}) + add_dependencies(${target} ${target}_framework_headers) + endif() +endfunction() + +# Collects the framework related information and paths from the target properties. +# Output variables: +# _name framework base name, e.g. 'QtCore'. +# _dir framework base directory, e.g. 'QtCore.framework'. +# _version framework version, e.g. 'A', 'B' etc. +# _bundle_version framework bundle version, same as the PROJECT_VERSION, e.g. '6.0.0'. +# _header_dir top-level header directory, e.g. 'QtCore.framework/Headers'. +# _versioned_binary_dir versioned directory that contains the framework binary, +# e.g. 'QtCore.framework/Versions/A' +# _versioned_header_dir header directory for specific framework version, +# e.g. 'QtCore.framework/Versions/A/Headers' +# _private_header_dir header directory for the specific framework version and +# framework bundle version e.g. 'QtCore.framework/Versions/A/Headers/6.0.0' +# _private_module_header_dir private header directory for the specific framework +# version, framework bundle version and tailing module name, e.g. +# 'QtCore.framework/Versions/A/Headers/6.0.0/Core' +function(qt_internal_get_framework_info out_var target) + # Avoid "INTERFACE_LIBRARY targets may only have whitelisted properties" error on CMake < 3.17. + get_target_property(target_type ${target} TYPE) + if("${target_type}" STREQUAL "INTERFACE_LIBRARY") + return() + endif() + + get_target_property(${out_var}_version ${target} FRAMEWORK_VERSION) + get_target_property(${out_var}_bundle_version ${target} MACOSX_FRAMEWORK_BUNDLE_VERSION) + + # The module name might be different of the actual target name + # and we want to use the Qt'fied module name as a framework identifier. + get_target_property(module_interface_name ${target} _qt_module_interface_name) + if(module_interface_name) + qt_internal_qtfy_target(module ${module_interface_name}) + else() + qt_internal_qtfy_target(module ${target}) + endif() + + set(${out_var}_name "${module}") + set(${out_var}_dir "${${out_var}_name}.framework") + set(${out_var}_header_dir "${${out_var}_dir}/Headers") + + if(UIKIT) + # iOS frameworks do not have a Versions sub-directory + set(${out_var}_versioned_binary_dir "${${out_var}_dir}") + set(${out_var}_versioned_header_dir "${${out_var}_header_dir}") + else() + set(${out_var}_versioned_binary_dir "${${out_var}_dir}/Versions/${${out_var}_version}") + set(${out_var}_versioned_header_dir "${${out_var}_versioned_binary_dir}/Headers") + endif() + set(${out_var}_private_header_dir "${${out_var}_versioned_header_dir}/${${out_var}_bundle_version}") + set(${out_var}_private_module_header_dir "${${out_var}_private_header_dir}/${module}") + + set(${out_var}_name "${${out_var}_name}" PARENT_SCOPE) + set(${out_var}_dir "${${out_var}_dir}" PARENT_SCOPE) + set(${out_var}_header_dir "${${out_var}_header_dir}" PARENT_SCOPE) + set(${out_var}_version "${${out_var}_version}" PARENT_SCOPE) + set(${out_var}_bundle_version "${${out_var}_bundle_version}" PARENT_SCOPE) + set(${out_var}_versioned_binary_dir "${${out_var}_versioned_binary_dir}" PARENT_SCOPE) + set(${out_var}_versioned_header_dir "${${out_var}_versioned_header_dir}" PARENT_SCOPE) + set(${out_var}_private_header_dir "${${out_var}_private_header_dir}" PARENT_SCOPE) + set(${out_var}_private_module_header_dir "${${out_var}_private_module_header_dir}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateExtPri.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateExtPri.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3ff67c57a0f539f3edf63aad436a0cb08638d2a8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateExtPri.cmake @@ -0,0 +1,50 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Generate a qt_ext_XXX.pri file. +# +# - Replaces occurrences of the build libdir with $$[QT_INSTALL_LIBDIR/get]. +# +# This file is to be used in CMake script mode with the following variables set: +# IN_FILES: path to the qt_ext_XXX.cmake files +# OUT_FILE: path to the generated qt_ext_XXX.pri file +# QT_BUILD_LIBDIR: path to Qt's libdir when building (those paths get replaced) +set(content "") +string(TOUPPER "${LIB}" uclib) +set(first_iteration TRUE) +list(LENGTH CONFIGS number_of_configs) +foreach(in_file ${IN_FILES}) + include(${in_file}) + if(first_iteration) + # Add configuration-independent variables + set(first_iteration FALSE) + list(JOIN incdir " " incdir) + list(JOIN defines " " defines) + string(APPEND content "QMAKE_INCDIR_${uclib} = ${incdir} +QMAKE_DEFINES_${uclib} = ${defines} +") + endif() + set(config_suffix "") + if(number_of_configs GREATER "1") + # We're in multi-config mode. Use a _DEBUG or _RELEASE suffix for libs. + # qmake_use.prf does not support other configurations. + string(TOUPPER "${cfg}" config_suffix) + if(config_suffix STREQUAL "DEBUG") + set(config_suffix _DEBUG) + else() + set(config_suffix _RELEASE) + endif() + endif() + + # Replace the build libdir + set(fixed_libs "") + foreach(lib ${libs}) + string(REPLACE "${QT_BUILD_LIBDIR}" "$$[QT_INSTALL_LIBS/get]" lib "${lib}") + list(APPEND fixed_libs "${lib}") + endforeach() + + list(JOIN fixed_libs " " libs) + string(APPEND content "QMAKE_LIBS_${uclib}${config_suffix} = ${libs} +") +endforeach() +file(WRITE "${OUT_FILE}" "${content}") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateLibHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateLibHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..69edf5167b3fa3ff1d36d8f53b2c10ea55f76369 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateLibHelpers.cmake @@ -0,0 +1,135 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Given "/usr/lib/x86_64-linux-gnu/libcups.so", returns "cups". +# Given "libavcodec.a", returns "avcodec". +# Given "ws2_32", returns "ws2_32". +# Returns an empty string if not given a linkable library (most likely a linker flag). +function(qt_get_library_name_without_prefix_and_suffix out_var file_path) + set(out_value "") + if(NOT file_path MATCHES "^-") # not a linker flag + get_filename_component(basename "${file_path}" NAME_WE) + get_filename_component(ext "${file_path}" EXT) + if(NOT ext) # seems like a library name without prefix and suffix + set(${out_var} "${file_path}" PARENT_SCOPE) + return() + endif() + string(TOLOWER "${ext}" ext_lower) + foreach(libsuffix ${LIBRARY_SUFFIXES}) + # Handle weird prefix extensions like in the case of + # "/usr/lib/x86_64-linux-gnu/libglib-2.0.so" + # it's ".0.so". + if(ext_lower MATCHES "^(\\.[0-9]+)*${libsuffix}(\\.[0-9]+)*") + set(is_linkable_library TRUE) + set(weird_numbered_extension "${CMAKE_MATCH_1}") + break() + endif() + endforeach() + if(is_linkable_library) + set(out_value "${basename}") + if(LIBRARY_PREFIXES) + foreach(libprefix ${LIBRARY_PREFIXES}) + # Strip any library prefix like "lib" for a library that we will use with a link + # flag. + if(libprefix AND out_value MATCHES "^${libprefix}(.+)") + set(out_value "${CMAKE_MATCH_1}") + break() + endif() + endforeach() + endif() + if(weird_numbered_extension) + set(out_value "${out_value}${weird_numbered_extension}") + endif() + endif() + endif() + + # Reverse the dependency order to be in sync with what qmake generated .pri files + # have. + list(REVERSE out_list) + + set(${out_var} "${out_value}" PARENT_SCOPE) +endfunction() + +# Given "/usr/lib/x86_64-linux-gnu/libcups.so", returns "-lcups". +# Given "libavcodec.a", returns "-lavcodec". +# Given "ws2_32", returns "-lws2_32". +# Returns an empty string if not given a linkable library (most likely a linker flag). +function(qt_get_library_with_link_flag out_var file_path) + qt_get_library_name_without_prefix_and_suffix(lib_name "${file_path}") + + set(out_value "") + if(lib_name) + set(out_value "${lib_name}") + if(LINK_LIBRARY_FLAG) + string(PREPEND out_value "${LINK_LIBRARY_FLAG}") + endif() + endif() + + set(${out_var} "${out_value}" PARENT_SCOPE) +endfunction() + +# Given a list of potential library paths, returns a transformed list where absolute library paths +# are replaced with library link flags. +function(qt_transform_absolute_library_paths_to_link_flags out_var library_path_list) + set(out_list "") + foreach(library_path ${library_path_list}) + qt_get_library_with_link_flag(lib_name_with_link_flag "${library_path}") + if(lib_name_with_link_flag) + string(TOLOWER "${IMPLICIT_LINK_DIRECTORIES}" IMPLICIT_LINK_DIRECTORIES_LOWER) + get_filename_component(dir "${library_path}" DIRECTORY) + if(dir) + string(TOLOWER "${dir}" dir_lower) + # If library_path isn't in default link directories, we should add it to link flags. + # But we shouldn't add it duplicately. + list(FIND IMPLICIT_LINK_DIRECTORIES_LOWER "${dir_lower}" index) + if(index EQUAL -1 AND NOT "-L\"${dir}\"" IN_LIST out_list) + list(APPEND out_list "-L\"${dir}\"") + endif() + endif() + list(APPEND out_list "${lib_name_with_link_flag}") + else() + list(APPEND out_list "${library_path}") + endif() + endforeach() + set(${out_var} "${out_list}" PARENT_SCOPE) +endfunction() + +function(qt_strip_library_version_suffix out_var file_path) + get_filename_component(dir "${file_path}" DIRECTORY) + get_filename_component(basename "${file_path}" NAME_WE) + get_filename_component(ext "${file_path}" EXT) + foreach(libsuffix ${LIBRARY_SUFFIXES}) + if(ext MATCHES "^${libsuffix}(\\.[0-9]+)+") + set(ext ${libsuffix}) + break() + endif() + endforeach() + set(final_value "${basename}${ext}") + if(dir) + set(final_value "${dir}/${final_value}") + endif() + set(${out_var} "${final_value}" PARENT_SCOPE) +endfunction() + +# Checks if `input_path` is relative to at least one path given in the list of `qt_lib_paths`. +# Sets TRUE or FALSE in `out_var_is_relative`. +# Assigns the relative path to `out_var_relative_path` if the path is relative, otherwise assigns +# the original path. +function(qt_internal_path_is_relative_to_qt_lib_path + input_path qt_lib_paths out_var_is_relative out_var_relative_path) + set(is_relative "FALSE") + set(relative_path_value "${input_path}") + + foreach(qt_lib_path ${qt_lib_paths}) + file(RELATIVE_PATH relative_path "${qt_lib_path}" "${input_path}") + if(IS_ABSOLUTE "${relative_path}" OR (relative_path MATCHES "^\\.\\.")) + set(is_relative "FALSE") + else() + set(is_relative "TRUE") + set(relative_path_value "${relative_path}") + break() + endif() + endforeach() + set(${out_var_is_relative} "${is_relative}" PARENT_SCOPE) + set(${out_var_relative_path} "${relative_path_value}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateLibPri.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateLibPri.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b403edd31e436e847d5b0c6dfc3510a644a7dafe --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateLibPri.cmake @@ -0,0 +1,104 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Generate a qt_lib_XXX.pri file. +# +# This file is to be used in CMake script mode with the following variables set: +# IN_FILES: path to the qt_lib_XXX.cmake files +# OUT_FILE: path to the generated qt_lib_XXX.pri file +# CONFIGS: the configurations Qt is being built with +# LIBRARY_SUFFIXES: list of known library extensions, e.g. .so;.a on Linux +# LIBRARY_PREFIXES: list of known library prefies, e.g. the "lib" in "libz" on on Linux +# LINK_LIBRARY_FLAG: flag used to link a shared library to an executable, e.g. -l on UNIX +# IMPLICIT_LINK_DIRECTORIES: list of implicit linker search paths +# +# QMAKE_LIBS_XXX values are split into QMAKE_LIBS_XXX_DEBUG and QMAKE_LIBS_XXX_RELEASE if +# debug_and_release was detected. The CMake configuration "Debug" is considered for the _DEBUG +# values. The first config that is not "Debug" is treated as _RELEASE. +# +# The library values are transformed from an absolute path into link flags +# aka from "/usr/lib/x86_64-linux-gnu/libcups.so" to "-lcups". + +cmake_policy(SET CMP0007 NEW) +cmake_policy(SET CMP0057 NEW) + +# Create a qmake-style list from the passed arguments and store it in ${out_var}. +function(qmake_list out_var) + set(result "") + + # Surround values that contain spaces with double quotes. + foreach(v ${ARGN}) + if(v MATCHES " " AND NOT MATCHES "^-framework") + set(v "\"${v}\"") + endif() + list(APPEND result ${v}) + endforeach() + + list(JOIN result " " result) + set(${out_var} ${result} PARENT_SCOPE) +endfunction() + +include("${CMAKE_CURRENT_LIST_DIR}/QtGenerateLibHelpers.cmake") + +list(POP_FRONT IN_FILES in_pri_file) +file(READ ${in_pri_file} content) +string(APPEND content "\n") +foreach(in_file ${IN_FILES}) + include(${in_file}) +endforeach() +list(REMOVE_DUPLICATES known_libs) + +set(is_debug_and_release FALSE) +if("Debug" IN_LIST CONFIGS AND ("Release" IN_LIST CONFIGS OR "RelWithDebInfo" IN_LIST CONFIGS)) + set(is_debug_and_release TRUE) + set(release_configs ${CONFIGS}) + list(REMOVE_ITEM release_configs "Debug") + list(GET release_configs 0 release_cfg) + string(TOUPPER "${release_cfg}" release_cfg) +endif() + +foreach(lib ${known_libs}) + set(configuration_independent_infixes LIBDIR INCDIR DEFINES) + + if(is_debug_and_release) + set(value_debug ${QMAKE_LIBS_${lib}_DEBUG}) + set(value_release ${QMAKE_LIBS_${lib}_${release_cfg}}) + qt_transform_absolute_library_paths_to_link_flags(value_debug "${value_debug}") + qt_transform_absolute_library_paths_to_link_flags(value_release "${value_release}") + + if(value_debug STREQUAL value_release) + qmake_list(value_debug ${value_debug}) + string(APPEND content "QMAKE_LIBS_${lib} = ${value_debug}\n") + else() + string(APPEND content "QMAKE_LIBS_${lib} =\n") + if(value_debug) + qmake_list(value_debug ${value_debug}) + string(APPEND content "QMAKE_LIBS_${lib}_DEBUG = ${value_debug}\n") + endif() + if(value_release) + qmake_list(value_release ${value_release}) + string(APPEND content "QMAKE_LIBS_${lib}_RELEASE = ${value_release}\n") + endif() + endif() + else() + list(APPEND configuration_independent_infixes LIBS) + endif() + + # The remaining values are considered equal for all configurations. + # Pick the first configuration and use its values. + list(GET CONFIGS 0 cfg) + string(TOUPPER ${cfg} cfg) + foreach(infix ${configuration_independent_infixes}) + set(value ${QMAKE_${infix}_${lib}_${cfg}}) + if(infix STREQUAL "LIBS") + qt_transform_absolute_library_paths_to_link_flags(value "${value}") + elseif("${value}" STREQUAL "") + # Do not write empty entries, but ensure to write at least + # the QMAKE_LIBS_FOO entry to make the lib 'foo' known. + continue() + endif() + qmake_list(value ${value}) + string(APPEND content "QMAKE_${infix}_${lib} = ${value}\n") + endforeach() +endforeach() +file(WRITE "${OUT_FILE}" "${content}") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateVersionScript.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateVersionScript.cmake new file mode 100644 index 0000000000000000000000000000000000000000..057363e494d4908d054879113b484361e13f96ed --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGenerateVersionScript.cmake @@ -0,0 +1,15 @@ +cmake_minimum_required(VERSION 3.16) + +if(EXISTS "${PRIVATE_CONTENT_FILE}") + file(READ "${PRIVATE_CONTENT_FILE}" PRIVATE_CONTENT) +endif() + +if(NOT EXISTS "${IN_FILE}") + message(FATAL_ERROR "Input file ${IN_FILE} doesn't exists") +endif() + +if(OUT_FILE STREQUAL "") + message(FATAL_ERROR "Output file is not specified") +endif() + +configure_file("${IN_FILE}" "${OUT_FILE}" @ONLY) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGlobalStateHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGlobalStateHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e7eb2ea22a418a0783e61159e232892426905845 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtGlobalStateHelpers.cmake @@ -0,0 +1,88 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_internal_clear_qt_repo_known_modules) + set(QT_REPO_KNOWN_MODULES "" CACHE INTERNAL "Known current repo Qt modules" FORCE) +endfunction() + +function(qt_internal_add_qt_repo_known_module) + set(QT_REPO_KNOWN_MODULES ${QT_REPO_KNOWN_MODULES} ${ARGN} + CACHE INTERNAL "Known current repo Qt modules" FORCE) +endfunction() + +function(qt_internal_get_qt_repo_known_modules out_var) + set("${out_var}" "${QT_REPO_KNOWN_MODULES}" PARENT_SCOPE) +endfunction() + +# Gets the list of all known Qt modules both found and that were built as part of the +# current project. +function(qt_internal_get_qt_all_known_modules out_var) + qt_internal_get_qt_repo_known_modules(repo_known_modules) + set(known_modules ${QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE} ${repo_known_modules}) + list(REMOVE_DUPLICATES known_modules) + set("${out_var}" "${known_modules}" PARENT_SCOPE) +endfunction() + +macro(qt_internal_set_qt_known_plugins) + set(QT_KNOWN_PLUGINS ${ARGN} CACHE INTERNAL "Known Qt plugins" FORCE) +endmacro() + +### Global plug-in types handling ### +# QT_REPO_KNOWN_PLUGIN_TYPES and QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE +# hold a list of plug-in types (e.G. "imageformats;bearer") +function(qt_internal_clear_qt_repo_known_plugin_types) + set(QT_REPO_KNOWN_PLUGIN_TYPES "" CACHE INTERNAL "Known current repo Qt plug-in types" FORCE) +endfunction() + +function(qt_internal_add_plugin_types target plugin_types) + # Update the variable containing the list of plugins for the given plugin type + foreach(plugin_type ${plugin_types}) + qt_get_sanitized_plugin_type("${plugin_type}" plugin_type) + set_property(TARGET "${target}" APPEND PROPERTY MODULE_PLUGIN_TYPES "${plugin_type}") + qt_internal_add_qt_repo_known_plugin_types("${plugin_type}") + endforeach() + + # Save the non-sanitized plugin type values for qmake consumption via .pri files. + set_property(TARGET "${target}" + APPEND PROPERTY QMAKE_MODULE_PLUGIN_TYPES "${plugin_types}") + + # Export the plugin types. + get_property(export_properties TARGET ${target} PROPERTY EXPORT_PROPERTIES) + if(NOT MODULE_PLUGIN_TYPES IN_LIST export_properties) + set_property(TARGET ${target} APPEND PROPERTY + EXPORT_PROPERTIES MODULE_PLUGIN_TYPES) + endif() +endfunction() + +function(qt_internal_add_qt_repo_known_plugin_types) + set(QT_REPO_KNOWN_PLUGIN_TYPES ${QT_REPO_KNOWN_PLUGIN_TYPES} ${ARGN} + CACHE INTERNAL "Known current repo Qt plug-in types" FORCE) +endfunction() + +function(qt_internal_get_qt_repo_known_plugin_types out_var) + set("${out_var}" "${QT_REPO_KNOWN_PLUGIN_TYPES}" PARENT_SCOPE) +endfunction() + +function(qt_internal_get_qt_all_known_plugin_types out_var) + qt_internal_get_qt_repo_known_plugin_types(repo_known_plugin_types) + set(known ${QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE} ${repo_known_plugin_types}) + list(REMOVE_DUPLICATES known) + set("${out_var}" "${known}" PARENT_SCOPE) +endfunction() + +macro(qt_internal_append_known_modules_with_tools module) + if(NOT ${module} IN_LIST QT_KNOWN_MODULES_WITH_TOOLS) + set(QT_KNOWN_MODULES_WITH_TOOLS "${QT_KNOWN_MODULES_WITH_TOOLS};${module}" + CACHE INTERNAL "Known Qt modules with tools" FORCE) + set(QT_KNOWN_MODULE_${module}_TOOLS "" + CACHE INTERNAL "Known Qt module ${module} tools" FORCE) + endif() +endmacro() + +macro(qt_internal_append_known_module_tool module tool) + if(NOT ${tool} IN_LIST QT_KNOWN_MODULE_${module}_TOOLS) + list(APPEND QT_KNOWN_MODULE_${module}_TOOLS "${tool}") + set(QT_KNOWN_MODULE_${module}_TOOLS "${QT_KNOWN_MODULE_${module}_TOOLS}" + CACHE INTERNAL "Known Qt module ${module} tools" FORCE) + endif() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtHeadersClean.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtHeadersClean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2a38e72bef1c37836e93a2aa746de1c6357cda6a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtHeadersClean.cmake @@ -0,0 +1,284 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Add a custom ${module_target}_headersclean_check target that builds each header in +# ${module_headers} with a custom set of defines. This makes sure our public headers +# are self-contained, and also compile with more strict compiler options. +function(qt_internal_add_headersclean_target module_target module_headers) + if(INPUT_headersclean AND WASM) + message(FATAL_ERROR "The headersclean targets are not supported on WASM platform.") + endif() + + get_target_property(no_headersclean_check ${module_target} _qt_no_headersclean_check) + if(no_headersclean_check) + return() + endif() + + set(hclean_headers "") + foreach(header IN LISTS module_headers) + get_filename_component(header_name "${header}" NAME) + if(header_name MATCHES "^q[^_]+\\.h$" AND NOT header_name MATCHES ".*(global|exports)\\.h") + list(APPEND hclean_headers "${header}") + endif() + endforeach() + + # Make sure that the header compiles with our strict options + set(hcleanDEFS -DQT_NO_CAST_TO_ASCII + -DQT_NO_CAST_FROM_ASCII + -DQT_NO_URL_CAST_FROM_STRING + -DQT_NO_CAST_FROM_BYTEARRAY + -DQT_NO_CONTEXTLESS_CONNECT + -DQT_NO_KEYWORDS + -DQT_TYPESAFE_FLAGS + -DQT_USE_QSTRINGBUILDER + -DQT_USE_FAST_OPERATOR_PLUS) + + set(compiler_to_run "${CMAKE_CXX_COMPILER}") + if(CMAKE_CXX_COMPILER_LAUNCHER) + list(PREPEND compiler_to_run "${CMAKE_CXX_COMPILER_LAUNCHER}") + endif() + + set(prop_prefix "") + get_target_property(target_type "${module_target}" TYPE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + set(prop_prefix "INTERFACE_") + endif() + + set(target_includes_genex + "$") + set(includes_exist_genex "$") + set(target_includes_joined_genex + "$<${includes_exist_genex}:-I$>") + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + list(GET CMAKE_CONFIGURATION_TYPES 0 first_config_type) + set(config_suffix "$<$>:-$>") + endif() + + # qmake doesn't seem to add the defines that are set by the header_only_module when checking the + # the cleanliness of the module's header files. + # This allows us to bypass an error with CMake 3.18 and lower when trying to evaluate + # genex-enhanced compile definitions. An example of that is in + # qttools/src/designer/src/uiplugin/CMakeLists.txt which ends up causing the following error + # message: + # CMake Error at qtbase/cmake/QtModuleHelpers.cmake:35 (add_library): + # INTERFACE_LIBRARY targets may only have whitelisted properties. The + # property "QT_PLUGIN_CLASS_NAME" is not allowed. + # Call Stack (most recent call first): + # src/designer/src/uiplugin/CMakeLists.txt:7 (qt_internal_add_module) + if(NOT target_type STREQUAL "INTERFACE_LIBRARY") + set(target_defines_genex + "$") + set(defines_exist_genex "$") + set(target_defines_joined_genex + "$<${defines_exist_genex}:-D$>") + endif() + + # TODO: FIXME + # Passing COMPILE_OPTIONS can break add_custom_command() if the values contain genexes + # that add_custom_command does not support. + # + # Such a case happens on Linux where libraries linking against Threads::Threads bring in a + # '<$' genex. + # + # If this is really required for headersclean (and qmake's headerclean implementation does + # actually pass all flags of the associated target), we'll have to replace the genex usage + # with an implementation that recursively processes a target's dependencies property + # to compile an expanded list of values for COMPILE_OPTIONS, and then filter out any genexes. + # + # This is similar to the proposed workaround at + # https://gitlab.kitware.com/cmake/cmake/-/issues/21074#note_814979 + # + # See also https://gitlab.kitware.com/cmake/cmake/-/issues/21336 + # + #set(target_compile_options_genex "$") + #set(compile_options_exist_genex "$") + #set(target_compile_options_joined_genex + # "$<${compile_options_exist_genex}:$>") + + set(target_compile_flags_genex + "$") + set(compile_flags_exist_genex "$") + set(target_compile_flags_joined_genex + "$<${compile_flags_exist_genex}:$>") + + if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" + OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang|IntelLLVM") + + # Compile header in strict C++20 mode. Enable further warnings. + set(hcleanFLAGS -std=c++2a + -Wall -Wextra -Werror -pedantic-errors + -Woverloaded-virtual -Wshadow -Wundef -Wfloat-equal + -Wnon-virtual-dtor -Wpointer-arith -Wformat-security + -Wchar-subscripts -Wold-style-cast + -Wredundant-decls # QTBUG-115583 + -fno-operator-names) + + if(QT_FEATURE_reduce_relocations AND UNIX) + list(APPEND hcleanFLAGS -fPIC) + endif() + + if (NOT ((TEST_architecture_arch STREQUAL arm) + OR (TEST_architecture_arch STREQUAL mips))) + list(APPEND hcleanFLAGS -Wcast-align) + endif() + + if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + list(APPEND hcleanFLAGS -Wzero-as-null-pointer-constant + -Wdouble-promotion -Wfloat-conversion) + endif() + + if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang|IntelLLVM") + list(APPEND hcleanFLAGS -Wshorten-64-to-32 + -Wweak-vtables) + endif() + + separate_arguments(cxx_flags NATIVE_COMMAND ${CMAKE_CXX_FLAGS}) + + if(APPLE AND CMAKE_OSX_SYSROOT) + list(APPEND cxx_flags "${CMAKE_CXX_SYSROOT_FLAG}" "${CMAKE_OSX_SYSROOT}") + endif() + + if(APPLE AND QT_FEATURE_framework) + # For some reason CMake doesn't generate -iframework flags from the INCLUDE_DIRECTORIES + # generator expression we provide, so pass it explicitly and hope for the best. + list(APPEND framework_includes + "-iframework" "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_LIBDIR}") + + # If additional package prefixes are provided, we consider they can contain frameworks + # as well. + foreach(prefix IN LISTS _qt_additional_packages_prefix_paths) + __qt_internal_reverse_prefix_path_from_cmake_dir(path "${path}") + + set(libdir "${prefix}/${INSTALL_LIBDIR}") + if(EXISTS "${libdir}") + list(APPEND framework_includes + "-iframework" "${libdir}") + endif() + endforeach() + endif() + + set(compiler_command_line + "${compiler_to_run}" "-c" "${cxx_flags}" + "${target_compile_flags_joined_genex}" + "${target_defines_joined_genex}" + "${hcleanFLAGS}" + "${target_includes_joined_genex}" + "${framework_includes}" + "${hcleanDEFS}" + + ) + string(JOIN " " compiler_command_line_variables + "-xc++" + "\${INPUT_HEADER_FILE}" + "-o" + "\${OUTPUT_ARTIFACT}" + ) + set(input_header_path_type ABSOLUTE) + elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + # Note we can't enable -Za, as it does not support certain key Microsoft SDK header files + # we use. Microsoft suggests to use /permissive- instead, which is implicity set by + # -std:c++latest. + set(hcleanFLAGS -std:c++latest -Zc:__cplusplus -WX -W4 -EHsc) + + # Because we now add `-DNOMINMAX` to `PlatformCommonInternal`. + set(hcleanUDEFS -UNOMINMAX) + + # cl.exe needs a source path + get_filename_component(source_path "${QT_MKSPECS_DIR}/features/data/dummy.cpp" REALPATH) + + set(compiler_command_line + "${compiler_to_run}" "-nologo" "-c" "${CMAKE_CXX_FLAGS}" + "${target_compile_flags_joined_genex}" + "${target_defines_joined_genex}" + "${hcleanFLAGS}" + "${target_includes_joined_genex}" + "${hcleanDEFS}" + "${hcleanUDEFS}" + ) + string(JOIN " " compiler_command_line_variables + "-FI" + "\${INPUT_HEADER_FILE}" + "-Fo\${OUTPUT_ARTIFACT}" + "${source_path}" + ) + + set(input_header_path_type REALPATH) + else() + message(FATAL_ERROR "CMAKE_CXX_COMPILER_ID \"${CMAKE_CXX_COMPILER_ID}\" is not supported" + " for the headersclean check.") + endif() + + qt_internal_module_info(module ${module_target}) + + unset(header_check_exceptions) + set(header_check_exceptions + "${CMAKE_CURRENT_BINARY_DIR}/${module}_header_check_exceptions") + set(headers_check_parameters + "${CMAKE_CURRENT_BINARY_DIR}/${module_target}HeadersCheckParameters${config_suffix}.cmake") + string(JOIN "\n" headers_check_parameters_content + "set(HEADER_CHECK_EXCEPTIONS" + " \"${header_check_exceptions}\")" + "set(HEADER_CHECK_COMPILER_COMMAND_LINE" + " \[\[$\]\]\n" + " ${compiler_command_line_variables}" + ")" + ) + file(GENERATE OUTPUT "${headers_check_parameters}" + CONTENT "${headers_check_parameters_content}") + + set(sync_headers_dep "${module_target}_sync_headers") + + foreach(header ${hclean_headers}) + # We need realpath here to make sure path starts with drive letter + get_filename_component(input_path "${header}" ${input_header_path_type}) + + get_filename_component(input_file_name ${input_path} NAME) + set(artifact_path "${CMAKE_CURRENT_BINARY_DIR}/header_check/${input_file_name}.o") + + unset(input_base_dir) + if(input_path MATCHES "${CMAKE_BINARY_DIR}") + set(input_base_dir "${CMAKE_BINARY_DIR}") + elseif(input_path MATCHES "${CMAKE_SOURCE_DIR}") + set(input_base_dir "${CMAKE_SOURCE_DIR}") + endif() + + if(input_base_dir AND IS_ABSOLUTE "${input_base_dir}" AND IS_ABSOLUTE "${input_path}") + file(RELATIVE_PATH comment_header_path "${input_base_dir}" "${input_path}") + else() + set(comment_header_path "${input_path}") + endif() + + add_custom_command( + OUTPUT "${artifact_path}" + COMMENT "headersclean: Checking header ${comment_header_path}" + COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/header_check" + COMMAND ${CMAKE_COMMAND} + -DINPUT_HEADER_FILE=${input_path} + -DOUTPUT_ARTIFACT=${artifact_path} + -DPARAMETERS=${headers_check_parameters} + -P "${QT_CMAKE_DIR}/QtModuleHeadersCheck.cmake" + IMPLICIT_DEPENDS CXX + VERBATIM + COMMAND_EXPAND_LISTS + DEPENDS + ${headers_check_parameters} + ${sync_headers_dep} + ${input_path} + ${header_check_exceptions} + ) + list(APPEND hclean_artifacts "${artifact_path}") + endforeach() + + add_custom_target(${module_target}_headersclean_check + COMMENT "headersclean: Checking headers in ${module}" + DEPENDS ${hclean_artifacts} + VERBATIM) + + if(NOT TARGET headersclean_check) + add_custom_target(headersclean_check ALL) + endif() + + add_dependencies(headersclean_check ${module_target}_headersclean_check) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInitProject.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInitProject.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8b2717dcdf45b7ca39d69e83d17a07a029e83903 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInitProject.cmake @@ -0,0 +1,214 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause +cmake_minimum_required(VERSION 3.16) + +if(NOT PROJECT_DIR) + set(PROJECT_DIR "${CMAKE_SOURCE_DIR}") +endif() + +get_filename_component(project_name "${PROJECT_DIR}" NAME) + +get_filename_component(project_abs_dir "${PROJECT_DIR}" ABSOLUTE) +if(NOT IS_DIRECTORY "${project_abs_dir}") + message(FATAL_ERROR "Unable to scan ${project_abs_dir}. The directory doesn't exist.") +endif() + +set(known_extensions "") +set(types "") + +# The function allows extending the capabilities of this script and establishes simple relation +# chains between the file types. +# Option Arguments: +# EXPERIMENTAL +# Marks that the support of the following files is experimental and the required Qt modules +# are in Technical preview state. +# DEPRECATED +# Marks that the support of the following files will be discontinued soon and the required +# Qt modules are deprecated. +# One-value Arguments: +# TEMPLATE +# The CMake code template. Use the '@files@' string for the files substitution. +# Multi-value Arguments: +# EXTENSIONS +# List of the file extensions treated as this source 'type'. +# MODULES +# List of Qt modules required for these file types. +# DEPENDS +# The prerequisite source 'type' needed by this source 'type' +macro(handle_type type) + cmake_parse_arguments(arg + "EXPERIMENTAL;DEPRECATED" + "TEMPLATE" + "EXTENSIONS;MODULES;DEPENDS" + ${ARGN} + ) + + if(NOT arg_EXTENSIONS) + message(FATAL_ERROR "Unexpected call handle_type of with no EXTENSIONS specified." + " This is the Qt issue, please report a bug at https://bugreports.qt.io.") + endif() + set(unique_extensions_subset "${known_extensions}") + list(REMOVE_ITEM unique_extensions_subset ${arg_EXTENSIONS}) + if(NOT "${known_extensions}" STREQUAL "${unique_extensions_subset}") + message(FATAL_ERROR "${type} contains duplicated extensions, this is not supported." + " This is the Qt issue, please report a bug at https://bugreports.qt.io.") + endif() + set(${type}_file_extensions "${arg_EXTENSIONS}") + + if(NOT arg_TEMPLATE) + message(FATAL_ERROR "Unexpected call handle_type of with no TEMPLATE specified." + " This is the Qt issue, please report a bug at https://bugreports.qt.io.") + endif() + set(${type}_template "${arg_TEMPLATE}") + + if(arg_MODULES) + set(${type}_required_modules "${arg_MODULES}") + endif() + + list(APPEND types ${type}) + + if(arg_EXPERIMENTAL) + set(${type}_is_experimental TRUE) + else() + set(${type}_is_experimental FALSE) + endif() + + if(arg_DEPRECATED) + set(${type}_is_deprecated TRUE) + else() + set(${type}_is_deprecated FALSE) + endif() + + if(arg_DEPENDS) + set(${type}_dependencies ${arg_DEPENDS}) + endif() +endmacro() + +handle_type(cpp EXTENSIONS .c .cc .cpp .cxx .h .hh .hxx .hpp MODULES Core TEMPLATE +"\n\nqt_add_executable(${project_name} + @files@ +)" +) + +handle_type(qml EXTENSIONS .qml .js .mjs MODULES Gui Qml Quick TEMPLATE +"\n\nqt_add_qml_module(${project_name} + URI ${project_name} + OUTPUT_DIRECTORY qml + VERSION 1.0 + RESOURCE_PREFIX /qt/qml + QML_FILES + @files@ +)" +) + +handle_type(ui EXTENSIONS .ui MODULES Gui Widgets DEPENDS cpp TEMPLATE +"\n\ntarget_sources(${project_name} + PRIVATE + @files@ +)" +) + +handle_type(qrc EXTENSIONS .qrc DEPENDS cpp TEMPLATE +"\n\nqt_add_resources(${project_name}_resources @files@) +target_sources(${project_name} + PRIVATE + \\\${${project_name}_resources} +)" +) + +handle_type(protobuf EXPERIMENTAL EXTENSIONS .proto MODULES Protobuf Grpc TEMPLATE +"\n\nqt_add_protobuf(${project_name} + GENERATE_PACKAGE_SUBFOLDERS + PROTO_FILES + @files@ +)" +) + +set(extra_packages "") +file(GLOB_RECURSE files RELATIVE "${project_abs_dir}" "${project_abs_dir}/*") +foreach(f IN LISTS files) + get_filename_component(file_extension "${f}" LAST_EXT) + string(TOLOWER "${file_extension}" file_extension) + + foreach(type IN LISTS types) + if(file_extension IN_LIST ${type}_file_extensions) + list(APPEND ${type}_sources "${f}") + list(APPEND packages ${${type}_required_modules}) + if(${type}_is_experimental) + message("We found files with the following extensions in your directory:" + " ${${type}_file_extensions}\n" + "Note that the modules ${${type}_required_modules} are" + " in the technical preview state.") + endif() + if(${type}_is_deprecated) + message("We found files with the following extensions in your directory:" + " ${${type}_file_extensions}\n" + "Note that the modules ${${type}_required_modules} are deprecated.") + endif() + break() + endif() + endforeach() +endforeach() + +if(packages) + list(REMOVE_DUPLICATES packages) + list(JOIN packages " " packages_string) + list(JOIN packages "\n Qt::" deps_string) + set(deps_string "Qt::${deps_string}") +endif() + +set(content +"cmake_minimum_required(VERSION 3.16) +project(${project_name} LANGUAGES CXX) + +find_package(Qt6 REQUIRED COMPONENTS ${packages_string}) +qt_standard_project_setup()" +) + +set(has_useful_sources FALSE) +foreach(type IN LISTS types) + if(${type}_sources) + set(skip FALSE) + foreach(dep IN LISTS ${type}_dependencies) + if(NOT ${dep}_sources) + set(skip TRUE) + message("Sources of type ${${type}_file_extensions} cannot live in the project" + " without ${${dep}_file_extensions} files. Skipping.") + break() + endif() + endforeach() + if(skip) + continue() + endif() + + set(has_useful_sources TRUE) + string(REGEX MATCH "( +)@files@" unused "${${type}_template}") + list(JOIN ${type}_sources "\n${CMAKE_MATCH_1}" ${type}_sources) + string(REPLACE "@files@" "${${type}_sources}" ${type}_content + "${${type}_template}") + string(APPEND content "${${type}_content}") + endif() +endforeach() + +string(APPEND content "\n\ntarget_link_libraries(${project_name} + PRIVATE + ${deps_string} +)\n" +) + +if(EXISTS "${project_abs_dir}/CMakeLists.txt") + message(FATAL_ERROR "Project is already initialized in current directory." + " Please remove CMakeLists.txt if you want to regenerate the project.") +endif() + +if(NOT has_useful_sources) + message(FATAL_ERROR "Could not find any files to generate the project.") +endif() +file(WRITE "${project_abs_dir}/CMakeLists.txt" "${content}") + +message("The project file is successfully generated. To build the project run:" + "\nmkdir build" + "\ncd build" + "\nqt-cmake ${project_abs_dir}" + "\ncmake --build ${project_abs_dir}" +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInstallHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInstallHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..912489b0bdd10ba012ed0a64d9c310385e544314 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInstallHelpers.cmake @@ -0,0 +1,249 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Wraps install() command. In a prefix build, simply passes along arguments to install(). +# In a non-prefix build, handles association of targets to export names, and also calls export(). +function(qt_install) + set(flags) + set(options EXPORT DESTINATION NAMESPACE) + set(multiopts TARGETS) + cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN}) + + if(arg_TARGETS) + set(is_install_targets TRUE) + endif() + + # In a prefix build, always invoke install() without modification. + # In a non-prefix build, pass install(TARGETS) commands to allow + # association of targets to export names, so we can later use the export names + # in export() commands. + if(QT_WILL_INSTALL OR is_install_targets) + install(${ARGV}) + endif() + + # When install(EXPORT) is called, also call export(EXPORT) + # to generate build tree target files. + if(NOT is_install_targets AND arg_EXPORT) + # For prefixed builds (both top-level and per-repo) export build tree CMake Targets files so + # they can be used in CMake ExternalProjects. One such case is examples built as + # ExternalProjects as part of the Qt build. + # In a top-level build the exported config files are placed under qtbase/lib/cmake. + # In a per-repo build, they will be placed in each repo's build dir/lib/cmake. + if(QT_WILL_INSTALL) + qt_path_join(arg_DESTINATION "${QT_BUILD_DIR}" "${arg_DESTINATION}") + endif() + + set(namespace_option "") + if(arg_NAMESPACE) + set(namespace_option NAMESPACE ${arg_NAMESPACE}) + endif() + export(EXPORT ${arg_EXPORT} + ${namespace_option} + FILE "${arg_DESTINATION}/${arg_EXPORT}.cmake") + endif() +endfunction() + +# Copies files using file(COPY) signature in non-prefix builds. +function(qt_non_prefix_copy) + if(NOT QT_WILL_INSTALL) + file(${ARGV}) + endif() +endfunction() + +# Retrieve the permissions that are set by install(PROGRAMS). +function(qt_get_install_executable_permissions out_var) + set(default_permissions ${CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS}) + if(NOT default_permissions) + set(default_permissions OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ) + endif() + set(executable_permissions ${default_permissions} OWNER_EXECUTE) + if(GROUP_READ IN_LIST default_permissions) + list(APPEND executable_permissions GROUP_EXECUTE) + endif() + if(WORLD_READ IN_LIST default_permissions) + list(APPEND executable_permissions WORLD_EXECUTE) + endif() + set(${out_var} ${executable_permissions} PARENT_SCOPE) +endfunction() + +# Use case is installing files in a prefix build, or copying them to the correct build dir +# in a non-prefix build. +# Pass along arguments as you would pass them to install(). +# Only supports FILES, PROGRAMS and DIRECTORY signature, and without fancy things +# like OPTIONAL or RENAME or COMPONENT. +function(qt_copy_or_install) + set(flags FILES PROGRAMS DIRECTORY) + set(options) + set(multiopts) + cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN}) + + # Remember which option has to be passed to the install command. + set(copy_arguments "") + set(argv_copy ${ARGV}) + if(arg_FILES) + set(install_option "FILES") + elseif(arg_PROGRAMS) + set(install_option "PROGRAMS") + qt_get_install_executable_permissions(executable_permissions) + list(APPEND copy_arguments FILE_PERMISSIONS ${executable_permissions}) + elseif(arg_DIRECTORY) + set(install_option "DIRECTORY") + endif() + + list(REMOVE_AT argv_copy 0) + qt_install(${install_option} ${argv_copy}) + qt_non_prefix_copy(COPY ${argv_copy} ${copy_arguments}) +endfunction() + +# Create a versioned hard-link for the given target, or a program +# E.g. "bin/qmake6" -> "bin/qmake". +# +# One-value Arguments: +# WORKING_DIRECTORY +# The directory where the original file is already placed. +# SUFFIX +# The program file extension, only used for PROGRAMS +# Multi-value Arguments: +# TARGETS +# List of targets for which the versioned link will be created. +# If targets are given, BASE_NAME and SUFFIX will be derived from it. +# PROGRAMS +# List of program file names for which the versioned link will be created. +# +# +# NOTE: This assumes that TARGETS, or PROGRAMS are already installed in the +# WORKING_DIRECTORY. +# +# In a multi-config build, create the link for the main config only. +function(qt_internal_install_versioned_link) + if(NOT QT_WILL_INSTALL) + return() + endif() + + if(NOT QT_CREATE_VERSIONED_HARD_LINK) + return() + endif() + + set(options) + set(oneValueArgs "WORKING_DIRECTORY;SUFFIX") + set(multiValueArgs "TARGETS;PROGRAMS") + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(arg_TARGETS) + foreach(target "${arg_TARGETS}") + _qt_internal_create_versioned_link_or_copy("${arg_WORKING_DIRECTORY}" + $ + $) + endforeach() + endif() + + if(arg_PROGRAMS) + foreach(program "${arg_PROGRAMS}") + _qt_internal_create_versioned_link_or_copy("${arg_WORKING_DIRECTORY}" + "${program}" + "${arg_SUFFIX}") + endforeach() + endif() +endfunction() + +# Generate a script for creating a hard-link between the base_name, and +# base_name${PROJECT_VERSION_MAJOR}. +# +# If no hard link can be created, make a copy instead. +function(_qt_internal_create_versioned_link_or_copy install_dir base_name suffix) + qt_path_join(install_base_file_path "$\{qt_full_install_prefix}" + "${install_dir}" "${base_name}") + set(original "${install_base_file_path}${suffix}") + set(linkname "${install_base_file_path}${PROJECT_VERSION_MAJOR}${suffix}") + set(code "set(qt_full_install_prefix \"$\{CMAKE_INSTALL_PREFIX}\")" + " if(NOT \"$ENV\{DESTDIR}\" STREQUAL \"\")" + ) + + if(CMAKE_HOST_WIN32) + list(APPEND code + " if(qt_full_install_prefix MATCHES \"^[a-zA-Z]:\")" + " string(SUBSTRING \"$\{qt_full_install_prefix}\" 2 -1 qt_full_install_prefix)" + " endif()" + ) + endif() + list(APPEND code + " string(PREPEND qt_full_install_prefix \"$ENV\{DESTDIR}\")" + " endif()" + " message(STATUS \"Creating hard link ${original} -> ${linkname}\")" + " file(CREATE_LINK \"${original}\" \"${linkname}\" COPY_ON_ERROR)") + + if(QT_GENERATOR_IS_MULTI_CONFIG) + # Wrap the code in a configuration check, + # because install(CODE) does not support a CONFIGURATIONS argument. + qt_create_case_insensitive_regex(main_config_regex ${QT_MULTI_CONFIG_FIRST_CONFIG}) + list(PREPEND code "if(\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"${main_config_regex}\")") + list(APPEND code "endif()") + endif() + + list(JOIN code "\n" code) + install(CODE "${code}") +endfunction() + +# Use case is copying files or directories in a non-prefix build with each build, so that changes +# are available each time, this is useful for some Android templates that are needed for building, +# apks and need to sync changes each time a build is started +function(qt_internal_copy_at_build_time) + set(flags) + set(options TARGET DESTINATION) + set(multiopts FILES DIRECTORIES) + cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN}) + + file(MAKE_DIRECTORY "${arg_DESTINATION}") + + unset(outputs) + foreach(dir_to_copy IN LISTS arg_DIRECTORIES) + get_filename_component(file_name "${dir_to_copy}" NAME) + set(destination_file_name "${arg_DESTINATION}/${file_name}") + + file(GLOB_RECURSE all_files_in_dir RELATIVE "${dir_to_copy}" "${dir_to_copy}/*") + set(dir_outputs ${all_files_in_dir}) + set(dir_deps ${all_files_in_dir}) + + list(TRANSFORM dir_outputs PREPEND "${destination_file_name}/") + list(TRANSFORM dir_deps PREPEND "${dir_to_copy}/") + + add_custom_command(OUTPUT ${dir_outputs} + COMMAND ${CMAKE_COMMAND} -E copy_directory ${dir_to_copy} "${destination_file_name}" + DEPENDS ${dir_deps} + COMMENT "Copying directory ${dir_to_copy} to ${arg_DESTINATION}." + ) + list(APPEND outputs ${dir_outputs}) + endforeach() + + unset(file_outputs) + unset(files_to_copy) + foreach(path_to_copy IN LISTS arg_FILES) + get_filename_component(file_name "${path_to_copy}" NAME) + set(destination_file_name "${arg_DESTINATION}/${file_name}") + + list(APPEND file_outputs "${destination_file_name}") + list(APPEND files_to_copy "${path_to_copy}") + endforeach() + + if(files_to_copy) + add_custom_command(OUTPUT ${file_outputs} + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${files_to_copy} ${arg_DESTINATION} + DEPENDS ${files_to_copy} + COMMENT "Copying files ${files_to_copy} to ${arg_DESTINATION}." + ) + list(APPEND outputs ${file_outputs}) + endif() + + get_property(count GLOBAL PROPERTY _qt_internal_copy_at_build_time_count) + if(NOT count) + set(count 0) + endif() + + add_custom_target(qt_internal_copy_at_build_time_${count} DEPENDS ${outputs}) + if(arg_TARGET) + add_dependencies(${arg_TARGET} qt_internal_copy_at_build_time_${count}) + endif() + + math(EXPR count "${count} + 1") + set_property(GLOBAL PROPERTY _qt_internal_copy_at_build_time_count ${count}) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInstallPaths.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInstallPaths.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bbba102d9a951e0b3d738e33afc94eed31e57750 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtInstallPaths.cmake @@ -0,0 +1,16 @@ +# install layout information, following what qmake -query provides +get_filename_component(QT6_INSTALL_PREFIX + ${CMAKE_CURRENT_LIST_DIR}/../../../ ABSOLUTE) +set(QT6_INSTALL_ARCHDATA ".") +set(QT6_INSTALL_BINS "bin") +set(QT6_INSTALL_CONFIGURATION "etc/xdg") +set(QT6_INSTALL_DATA ".") +set(QT6_INSTALL_DOCS "doc") +set(QT6_INSTALL_EXAMPLES "examples") +set(QT6_INSTALL_HEADERS "include") +set(QT6_INSTALL_LIBS "lib") +set(QT6_INSTALL_LIBEXECS "bin") +set(QT6_INSTALL_PLUGINS "plugins") +set(QT6_INSTALL_QML "qml") +set(QT6_INSTALL_TESTS "tests") +set(QT6_INSTALL_TRANSLATIONS "translations") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtJavaHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtJavaHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c2ce70a3ffbe21ecf027a9b493cce49bb0f66d9b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtJavaHelpers.cmake @@ -0,0 +1,30 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This function can be used to compile java sources into a jar package. + +function(qt_internal_add_jar target) + set(options) + set(oneValueArgs OUTPUT_DIR) + set(multiValueArgs INCLUDE_JARS SOURCES) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(javac_target_version "${QT_ANDROID_JAVAC_TARGET}") + if (NOT javac_target_version) + set(javac_target_version "8") + endif() + + set(javac_source_version "${QT_ANDROID_JAVAC_SOURCE}") + if (NOT javac_source_version) + set(javac_source_version "8") + endif() + + set(CMAKE_JAVA_COMPILE_FLAGS -source "${javac_source_version}" -target "${javac_target_version}" + -Xlint:unchecked,cast,divzero,fallthrough,overrides,path -classpath "${QT_ANDROID_JAR}") + add_jar(${ARGV}) + + foreach(f IN LISTS arg_SOURCES) + _qt_internal_expose_source_file_to_ide(${target} "${f}") + endforeach() + +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtLalrHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtLalrHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6d2ec2f25f974f9a79e63225e77c2cb43be4f129 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtLalrHelpers.cmake @@ -0,0 +1,77 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Match the pattern 'regex' in 'input_line', replace the match with 'replacement' +# and set that result in 'out_var' in the parent scope. +function(qt_regex_match_and_get input_line regex replacement out_var) + string(REGEX MATCH "${regex}" match "${input_line}") + if(match) + string(REGEX REPLACE "${regex}" "${replacement}" match "${input_line}") + string(STRIP ${match} match) + set(${out_var} "${match}" PARENT_SCOPE) + endif() +endfunction() + +# Match 'regex' in a list of lines. When found, set the value to 'out_var' and break early. +function(qt_qlalr_find_option_in_list input_list regex out_var) + foreach(line ${input_list}) + qt_regex_match_and_get("${line}" "${regex}" "\\1" option) + if(option) + string(TOLOWER ${option} option) + set(${out_var} "${option}" PARENT_SCOPE) + return() + endif() + endforeach() + message(FATAL_ERROR "qt_qlalr_find_option_in_list: Could not extract ${out_var}") +endfunction() + +# Generate a few output files using qlalr, and assign those to 'consuming_target'. +# 'input_file_list' is a list of 'foo.g' file paths. +# 'flags' are extra flags to be passed to qlalr. +function(qt_process_qlalr consuming_target input_file_list flags) + # Don't try to extend_target when cross compiling an imported host target (like a tool). + qt_is_imported_target("${consuming_target}" is_imported) + if(is_imported) + return() + endif() + + qt_internal_is_skipped_test(skipped ${consuming_target}) + if(skipped) + return() + endif() + qt_internal_is_in_test_batch(in_batch ${consuming_target}) + if(in_batch) + _qt_internal_test_batch_target_name(consuming_target) + endif() + + foreach(input_file ${input_file_list}) + file(STRINGS ${input_file} input_file_lines) + qt_qlalr_find_option_in_list("${input_file_lines}" "^%parser(.+)" "parser") + qt_qlalr_find_option_in_list("${input_file_lines}" "^%decl(.+)" "decl") + qt_qlalr_find_option_in_list("${input_file_lines}" "^%impl(.+)" "impl") + get_filename_component(base_file_name ${input_file} NAME_WE) + + # Pass a relative input file path to qlalr to generate relative #line directives. + if(IS_ABSOLUTE "${input_file}") + set(absolute_input_file "${input_file}") + else() + get_filename_component(absolute_input_file "${input_file}" ABSOLUTE) + endif() + file(RELATIVE_PATH relative_input_file "${CMAKE_CURRENT_BINARY_DIR}" + "${absolute_input_file}") + + set(cpp_file "${parser}.cpp") + set(private_file "${CMAKE_CURRENT_BINARY_DIR}/${parser}_p.h") + set(decl_file "${CMAKE_CURRENT_BINARY_DIR}/${decl}") + set(impl_file "${impl}") + add_custom_command( + OUTPUT ${cpp_file} ${private_file} ${decl_file} ${impl_file} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::qlalr ${flags} ${relative_input_file} + DEPENDS ${QT_CMAKE_EXPORT_NAMESPACE}::qlalr + MAIN_DEPENDENCY ${input_file} + VERBATIM + ) + target_sources(${consuming_target} PRIVATE ${cpp_file} ${impl_file} + ${private_file} ${decl_file}) + endforeach() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtMkspecHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtMkspecHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6edc26c3e495233d793bfd27ea22a0f57ba5adc8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtMkspecHelpers.cmake @@ -0,0 +1,148 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +macro(qt_internal_set_mkspecs_dir) + # Find the path to mkspecs/, depending on whether we are building as part of a standard qtbuild, + # or a module against an already installed version of qt. + if(NOT QT_MKSPECS_DIR) + if("${QT_BUILD_INTERNALS_PATH}" STREQUAL "") + get_filename_component(QT_MKSPECS_DIR "${CMAKE_CURRENT_LIST_DIR}/../mkspecs" ABSOLUTE) + else() + # We can rely on QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX being set by + # QtBuildInternalsExtra.cmake. + get_filename_component( + QT_MKSPECS_DIR + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_MKSPECSDIR}" ABSOLUTE) + endif() + set(QT_MKSPECS_DIR "${QT_MKSPECS_DIR}" CACHE INTERNAL "") + endif() +endmacro() + +macro(qt_internal_setup_platform_definitions_and_mkspec) + # Platform define path, etc. + if(WIN32) + set(QT_DEFAULT_PLATFORM_DEFINITIONS WIN32 _ENABLE_EXTENDED_ALIGNED_STORAGE) + if(QT_64BIT) + list(APPEND QT_DEFAULT_PLATFORM_DEFINITIONS WIN64 _WIN64) + endif() + + if(CLANG) + if(CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC" OR MSVC) + set(QT_DEFAULT_MKSPEC win32-clang-msvc) + elseif(CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU" OR MINGW) + set(QT_DEFAULT_MKSPEC win32-clang-g++) + endif() + elseif(MSVC) + string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" cmake_system_processor_case_independent) + if(cmake_system_processor_case_independent STREQUAL "arm64") + set(QT_DEFAULT_MKSPEC win32-arm64-msvc) + else() + set(QT_DEFAULT_MKSPEC win32-msvc) + endif() + unset(cmake_system_processor_case_independent) + elseif(MINGW) + set(QT_DEFAULT_MKSPEC win32-g++) + list(APPEND QT_DEFAULT_PLATFORM_DEFINITIONS MINGW_HAS_SECURE_API=1) + endif() + elseif(LINUX) + if(GCC) + set(QT_DEFAULT_MKSPEC linux-g++) + elseif(CLANG) + set(QT_DEFAULT_MKSPEC linux-clang) + endif() + elseif(ANDROID) + if(GCC) + set(QT_DEFAULT_MKSPEC android-g++) + elseif(CLANG) + set(QT_DEFAULT_MKSPEC android-clang) + endif() + elseif(IOS) + set(QT_DEFAULT_MKSPEC macx-ios-clang) + elseif(APPLE) + set(QT_DEFAULT_MKSPEC macx-clang) + elseif(WASM) + if(WASM64) + set(QT_DEFAULT_MKSPEC wasm-emscripten-64) + else() + set(QT_DEFAULT_MKSPEC wasm-emscripten) + endif() + elseif(QNX) + # Certain POSIX defines are not set if we don't compile with -std=gnuXX + set(QT_ENABLE_CXX_EXTENSIONS ON) + + list(APPEND QT_DEFAULT_PLATFORM_DEFINITIONS _FORTIFY_SOURCE=2 _REENTRANT) + + set(compiler_aarch64le aarch64le) + set(compiler_armle-v7 armv7le) + set(compiler_x86-64 x86_64) + set(compiler_x86 x86) + foreach(arch aarch64le armle-v7 x86-64 x86) + if (CMAKE_CXX_COMPILER_TARGET MATCHES "${compiler_${arch}}$") + set(QT_DEFAULT_MKSPEC qnx-${arch}-qcc) + endif() + endforeach() + elseif(FREEBSD) + if(CLANG) + set(QT_DEFAULT_MKSPEC freebsd-clang) + elseif(GCC) + set(QT_DEFAULT_MKSPEC freebsd-g++) + endif() + elseif(NETBSD) + set(QT_DEFAULT_MKSPEC netbsd-g++) + elseif(OPENBSD) + set(QT_DEFAULT_MKSPEC openbsd-g++) + elseif(SOLARIS) + if(GCC) + if(QT_64BIT) + set(QT_DEFAULT_MKSPEC solaris-g++-64) + else() + set(QT_DEFAULT_MKSPEC solaris-g++) + endif() + else() + if(QT_64BIT) + set(QT_DEFAULT_MKSPEC solaris-cc-64) + else() + set(QT_DEFAULT_MKSPEC solaris-cc) + endif() + endif() + elseif(HURD) + set(QT_DEFAULT_MKSPEC hurd-g++) + endif() + + if(NOT QT_QMAKE_TARGET_MKSPEC) + set(QT_QMAKE_TARGET_MKSPEC "${QT_DEFAULT_MKSPEC}" CACHE STRING "QMake target mkspec") + endif() + + if(CMAKE_CROSSCOMPILING) + set(QT_QMAKE_HOST_MKSPEC "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_QMAKE_MKSPEC}") + else() + set(QT_QMAKE_HOST_MKSPEC "${QT_QMAKE_TARGET_MKSPEC}") + endif() + + if(NOT QT_QMAKE_TARGET_MKSPEC OR NOT EXISTS "${QT_MKSPECS_DIR}/${QT_QMAKE_TARGET_MKSPEC}") + if(NOT QT_QMAKE_TARGET_MKSPEC) + set(reason + "Platform is not detected. Please make sure your build environment is configured" + " properly or specify it manually using QT_QMAKE_TARGET_MKSPEC variable and one of" + " the known platforms.") + else() + set(reason "Unknown platform ${QT_QMAKE_TARGET_MKSPEC}") + endif() + + file(GLOB known_platforms + LIST_DIRECTORIES true + RELATIVE "${QT_MKSPECS_DIR}" + "${QT_MKSPECS_DIR}/*" + ) + list(JOIN known_platforms "\n " known_platforms) + message(FATAL_ERROR "${reason}\n" + "Known platforms:\n ${known_platforms}") + endif() + + if(NOT DEFINED QT_DEFAULT_PLATFORM_DEFINITIONS) + set(QT_DEFAULT_PLATFORM_DEFINITIONS "") + endif() + + set(QT_PLATFORM_DEFINITIONS ${QT_DEFAULT_PLATFORM_DEFINITIONS} + CACHE STRING "Qt platform specific pre-processor defines") +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleConfig.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleConfig.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..df99f3dda18c889c690e0fd8da3e672660f38f8b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleConfig.cmake.in @@ -0,0 +1,162 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +@PACKAGE_INIT@ + +cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_version@) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin +@extra_cmake_code@ +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake") + _qt_internal_suggest_dependency_debugging(@target@ + __qt_@target@_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "@INSTALL_CMAKE_NAMESPACE@@target@_FOUND") + set("@INSTALL_CMAKE_NAMESPACE@@target@_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND @INSTALL_CMAKE_NAMESPACE@@target@_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Targets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@AdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@ExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE @QT_CMAKE_EXPORT_NAMESPACE@@target@) instead. + set(@QT_CMAKE_EXPORT_NAMESPACE@@target@_LIBRARIES "@QT_CMAKE_EXPORT_NAMESPACE@::@target@") + + get_target_property(_@QT_CMAKE_EXPORT_NAMESPACE@@target@_OWN_INCLUDE_DIRS + @QT_CMAKE_EXPORT_NAMESPACE@::@target@ INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _@QT_CMAKE_EXPORT_NAMESPACE@@target@_OWN_INCLUDE_DIRS) + set(_@QT_CMAKE_EXPORT_NAMESPACE@@target@_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET @QT_CMAKE_EXPORT_NAMESPACE@::@target@Private) + get_target_property(_@QT_CMAKE_EXPORT_NAMESPACE@@target@_OWN_PRIVATE_INCLUDE_DIRS + @QT_CMAKE_EXPORT_NAMESPACE@::@target@Private INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _@QT_CMAKE_EXPORT_NAMESPACE@@target@_OWN_PRIVATE_INCLUDE_DIRS) + set(_@QT_CMAKE_EXPORT_NAMESPACE@@target@_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(@QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS + @QT_CMAKE_EXPORT_NAMESPACE@::@target@ INTERFACE_COMPILE_DEFINITIONS) + if(NOT @QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS) + set(@QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS @QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(@QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(@QT_CMAKE_EXPORT_NAMESPACE@@target@_COMPILE_DEFINITIONS + @QT_CMAKE_EXPORT_NAMESPACE@::@target@ INTERFACE_COMPILE_DEFINITIONS) + if(NOT @QT_CMAKE_EXPORT_NAMESPACE@@target@_COMPILE_DEFINITIONS) + set(@QT_CMAKE_EXPORT_NAMESPACE@@target@_COMPILE_DEFINITIONS "") + endif() + + set(@QT_CMAKE_EXPORT_NAMESPACE@@target@_INCLUDE_DIRS + ${_@QT_CMAKE_EXPORT_NAMESPACE@@target@_OWN_INCLUDE_DIRS}) + + set(@QT_CMAKE_EXPORT_NAMESPACE@@target@_PRIVATE_INCLUDE_DIRS + ${_@QT_CMAKE_EXPORT_NAMESPACE@@target@_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_@QT_CMAKE_EXPORT_NAMESPACE@@target@_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND @QT_CMAKE_EXPORT_NAMESPACE@@target@${_private_suffix}_INCLUDE_DIRS + ${@QT_CMAKE_EXPORT_NAMESPACE@${_module_dep}_INCLUDE_DIRS}) + list(APPEND @QT_CMAKE_EXPORT_NAMESPACE@@target@${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${@QT_CMAKE_EXPORT_NAMESPACE@${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND @QT_CMAKE_EXPORT_NAMESPACE@@target@_PRIVATE_INCLUDE_DIRS + ${@QT_CMAKE_EXPORT_NAMESPACE@${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND @QT_CMAKE_EXPORT_NAMESPACE@@target@${_private_suffix}_DEFINITIONS + ${@QT_CMAKE_EXPORT_NAMESPACE@${_module_dep}_DEFINITIONS}) + list(APPEND @QT_CMAKE_EXPORT_NAMESPACE@@target@${_private_suffix}_COMPILE_DEFINITIONS + ${@QT_CMAKE_EXPORT_NAMESPACE@${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES @QT_CMAKE_EXPORT_NAMESPACE@@target@_INCLUDE_DIRS) + list(REMOVE_DUPLICATES @QT_CMAKE_EXPORT_NAMESPACE@@target@_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES @QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS) + list(REMOVE_DUPLICATES @QT_CMAKE_EXPORT_NAMESPACE@@target@_COMPILE_DEFINITIONS) +endif() + +if (TARGET @QT_CMAKE_EXPORT_NAMESPACE@::@target@) + qt_make_features_available(@QT_CMAKE_EXPORT_NAMESPACE@::@target@) + + foreach(extra_cmake_include @extra_cmake_includes@) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Plugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Plugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "@target@") + + get_target_property(_qt_module_target_type "@INSTALL_CMAKE_NAMESPACE@::@target@" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + @INSTALL_CMAKE_NAMESPACE@::@target@ MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (@INSTALL_CMAKE_NAMESPACE@BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@BuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@BuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@VersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@VersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(@INSTALL_CMAKE_NAMESPACE@@target@_FOUND FALSE) + if(NOT DEFINED @INSTALL_CMAKE_NAMESPACE@@target@_NOT_FOUND_MESSAGE) + set(@INSTALL_CMAKE_NAMESPACE@@target@_NOT_FOUND_MESSAGE + "Target \"@QT_CMAKE_EXPORT_NAMESPACE@::@target@\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND @INSTALL_CMAKE_NAMESPACE@@target@_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Targets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleDependencies.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleDependencies.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..06de60a2826adf3cd6770dfecf70c2c8b353d689 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleDependencies.cmake.in @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure @INSTALL_CMAKE_NAMESPACE@ is found before anything else. +set(@INSTALL_CMAKE_NAMESPACE@@target@_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT @INSTALL_CMAKE_NAMESPACE@_FOUND) + find_dependency(@INSTALL_CMAKE_NAMESPACE@ @main_qt_package_version@ + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_@target@_third_party_deps "@third_party_deps@") +@third_party_deps_extra_info@ +_qt_internal_find_third_party_dependencies("@target@" __qt_@target@_third_party_deps) + +# Find Qt tool package. +set(__qt_@target@_tool_deps "@main_module_tool_deps@") +_qt_internal_find_tool_dependencies("@target@" __qt_@target@_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_@target@_target_deps "@target_deps@") +set(__qt_@target@_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("@target@" __qt_@target@_target_deps + __qt_@target@_find_dependency_paths) + +set(_@QT_CMAKE_EXPORT_NAMESPACE@@target@_MODULE_DEPENDENCIES "@qt_module_dependencies@") +set(@INSTALL_CMAKE_NAMESPACE@@target@_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleHeadersCheck.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleHeadersCheck.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f904d6ad4c6994674c411ea8a0b3d672ae9c726d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleHeadersCheck.cmake @@ -0,0 +1,34 @@ +cmake_minimum_required(VERSION 3.16) +# The PARAMETERS file should specify the following variables for the correct work of +# this script: +# HEADER_CHECK_EXCEPTIONS - path to file that contains exceptions. +# The file is created by syncqt. +# +# HEADER_CHECK_COMPILER_COMMAND_LINE - compiler command line +include("${PARAMETERS}") + +if(EXISTS ${HEADER_CHECK_EXCEPTIONS}) + file(READ ${HEADER_CHECK_EXCEPTIONS} header_check_exception_list) +endif() + +get_filename_component(header "${INPUT_HEADER_FILE}" REALPATH) +file(TO_CMAKE_PATH "${header}" header) +foreach(exception IN LISTS header_check_exception_list) + file(TO_CMAKE_PATH "${exception}" exception) + if(exception STREQUAL header) + file(WRITE "${OUTPUT_ARTIFACT}" "skipped") + return() + endif() +endforeach() + +execute_process(COMMAND ${HEADER_CHECK_COMPILER_COMMAND_LINE} + RESULT_VARIABLE result + OUTPUT_VARIABLE output + ERROR_VARIABLE output +) + +if(NOT result EQUAL 0) + message(FATAL_ERROR "${INPUT_HEADER_FILE} header check" + " failed: ${HEADER_CHECK_COMPILER_COMMAND_LINE}\n" + " ${output}") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..51ef0a1c233dfc45fd4d701667f8991699495852 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleHelpers.cmake @@ -0,0 +1,1483 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +macro(qt_internal_get_internal_add_module_keywords option_args single_args multi_args) + set(${option_args} + STATIC + EXCEPTIONS + INTERNAL_MODULE + HEADER_MODULE + DISABLE_TOOLS_EXPORT + SKIP_DEPENDS_INCLUDE + NO_MODULE_HEADERS + NO_SYNC_QT + NO_PRIVATE_MODULE + NO_CONFIG_HEADER_FILE + NO_ADDITIONAL_TARGET_INFO + NO_GENERATE_METATYPES + NO_HEADERSCLEAN_CHECK + NO_GENERATE_CPP_EXPORTS + NO_UNITY_BUILD + ${__qt_internal_sbom_optional_args} + ) + set(${single_args} + MODULE_INCLUDE_NAME + MODULE_INTERFACE_NAME + CONFIG_MODULE_NAME + PRECOMPILED_HEADER + CONFIGURE_FILE_PATH + CPP_EXPORT_HEADER_BASE_NAME + EXTERNAL_HEADERS_DIR + PRIVATE_HEADER_FILTERS + QPA_HEADER_FILTERS + RHI_HEADER_FILTERS + SSG_HEADER_FILTERS + HEADER_SYNC_SOURCE_DIRECTORY + ${__default_target_info_args} + ${__qt_internal_sbom_single_args} + ) + set(${multi_args} + QMAKE_MODULE_CONFIG + EXTRA_CMAKE_FILES + EXTRA_CMAKE_INCLUDES + EXTERNAL_HEADERS + POLICIES + ${__default_private_args} + ${__default_public_args} + ${__default_private_module_args} + ${__qt_internal_sbom_multi_args} + ) +endmacro() + +# The function helps to wrap module include paths with the header existence check. +function(qt_internal_append_include_directories_with_headers_check target list_to_append type) + string(TOLOWER "${type}" type) + string(JOIN "" has_headers_check + "$," + "_qt_module_has_${type}_headers" + ">" + ">" + ) + foreach(directory IN LISTS ARGN) + list(APPEND ${list_to_append} + "$<${has_headers_check}:${directory}>") + endforeach() + set(${list_to_append} "${${list_to_append}}" PARENT_SCOPE) +endfunction() + +# This is the main entry function for creating a Qt module, that typically +# consists of a library, public header files, private header files and configurable +# features. +# +# A CMake target with the specified target parameter is created. If the current source +# directory has a configure.cmake file, then that is also processed for feature definition +# and testing. Any features defined as well as any features coming from dependencies to +# this module are imported into the scope of the calling feature. +# +# Target is without leading "Qt". So e.g. the "QtCore" module has the target "Core". +# +# Options: +# NO_ADDITIONAL_TARGET_INFO +# Don't generate a Qt6*AdditionalTargetInfo.cmake file. +# The caller is responsible for creating one. +# +# MODULE_INTERFACE_NAME +# The custom name of the module interface. This name is used as a part of the include paths +# associated with the module and other interface names. The default value is the target name. +# If the INTERNAL_MODULE option is specified, MODULE_INTERFACE_NAME is not specified and the +# target name ends with the suffix 'Private', the MODULE_INTERFACE_NAME value defaults to the +# non-suffixed target name, e.g.: +# For the SomeInternalModulePrivate target, the MODULE_INTERFACE_NAME will be +# SomeInternalModule +# +# HEADER_MODULE +# Creates an interface library instead of following the Qt configuration default. Mutually +# exclusive with STATIC. +# +# STATIC +# Creates a static library instead of following the Qt configuration default. Mutually +# exclusive with HEADER_MODULE. +# +# EXTERNAL_HEADERS +# A explicit list of non qt headers (like 3rdparty) to be installed. +# Note this option overrides install headers used as PUBLIC_HEADER by cmake install(TARGET) +# otherwise set by syncqt. +# +# EXTERNAL_HEADERS_DIR +# A module directory with non qt headers (like 3rdparty) to be installed. +# Note this option overrides install headers used as PUBLIC_HEADER by cmake install(TARGET) +# otherwise set by syncqt. +# +# PRIVATE_HEADER_FILTERS +# The regular expressions that filter private header files out of target sources. +# The value must use the following format 'regex1|regex2|regex3'. +# +# QPA_HEADER_FILTERS +# The regular expressions that filter QPA header files out of target sources. +# The value must use the following format 'regex1|regex2|regex3'. +# +# RHI_HEADER_FILTERS +# The regular expressions that filter RHI header files out of target sources. +# The value must use the following format 'regex1|regex2|regex3'. +# +# SSG_HEADER_FILTERS +# The regular expressions that filter ssg header files out of target sources. +# The value must use the following format 'regex1|regex2|regex3'. +# +# HEADER_SYNC_SOURCE_DIRECTORY +# The source directory for header sync procedure. Header files outside this directory will be +# ignored by syncqt. The specifying this directory allows to skip the parsing of the whole +# CMAKE_CURRENT_SOURCE_DIR for the header files that needs to be synced and only parse the +# single subdirectory, that meanwhile can be outside the CMAKE_CURRENT_SOURCE_DIR tree. +function(qt_internal_add_module target) + qt_internal_get_internal_add_module_keywords( + module_option_args + module_single_args + module_multi_args + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${module_option_args}" + "${module_single_args}" + "${module_multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + set(is_internal_module FALSE) + if(arg_INTERNAL_MODULE) + set(is_internal_module TRUE) + set(arg_INTERNAL_MODULE "INTERNAL_MODULE") + set(arg_NO_PRIVATE_MODULE TRUE) + # Assume the interface name of the internal module should be the module name without the + # 'Private' suffix. + if(NOT arg_MODULE_INTERFACE_NAME) + if(target MATCHES "(.*)Private$") + set(arg_MODULE_INTERFACE_NAME "${CMAKE_MATCH_1}") + else() + message(WARNING "The internal module target should end with the 'Private' suffix.") + endif() + endif() + else() + unset(arg_INTERNAL_MODULE) + endif() + + if(NOT arg_MODULE_INTERFACE_NAME) + set(arg_MODULE_INTERFACE_NAME "${target}") + endif() + + ### Define Targets: + if(arg_HEADER_MODULE) + set(type_to_create INTERFACE) + elseif(arg_STATIC) + set(type_to_create STATIC) + else() + # Use default depending on Qt configuration. + set(type_to_create "") + endif() + + _qt_internal_add_library("${target}" ${type_to_create}) + qt_internal_mark_as_internal_library("${target}") + + get_target_property(target_type ${target} TYPE) + + set(is_interface_lib 0) + set(is_shared_lib 0) + set(is_static_lib 0) + if(target_type STREQUAL "INTERFACE_LIBRARY") + set(is_interface_lib 1) + elseif(target_type STREQUAL "STATIC_LIBRARY") + set(is_static_lib 1) + elseif(target_type STREQUAL "SHARED_LIBRARY") + set(is_shared_lib 1) + else() + message(FATAL_ERROR "Invalid target type '${target_type}' for Qt module '${target}'") + endif() + + if(NOT arg_NO_SYNC_QT AND NOT arg_NO_MODULE_HEADERS AND arg_MODULE_INCLUDE_NAME) + # qt_internal_module_info uses this property if it's set, so it must be + # specified before the qt_internal_module_info call. + set_target_properties(${target} PROPERTIES + _qt_module_include_name ${arg_MODULE_INCLUDE_NAME} + ) + endif() + + set_target_properties(${target} PROPERTIES + _qt_module_interface_name "${arg_MODULE_INTERFACE_NAME}" + _qt_package_version "${PROJECT_VERSION}" + _qt_package_name "${INSTALL_CMAKE_NAMESPACE}${target}" + ) + set(export_properties + "_qt_module_interface_name" + "_qt_package_version" + "_qt_package_name" + ) + if(NOT is_internal_module) + set_target_properties(${target} PROPERTIES + _qt_is_public_module TRUE + ) + list(APPEND export_properties + "_qt_is_public_module" + ) + if(NOT ${arg_NO_PRIVATE_MODULE}) + set_target_properties(${target} PROPERTIES + _qt_private_module_target_name "${target}Private" + ) + list(APPEND export_properties + "_qt_private_module_target_name" + ) + endif() + endif() + + set_property(TARGET ${target} APPEND PROPERTY EXPORT_PROPERTIES "${export_properties}") + + qt_internal_module_info(module "${target}") + qt_internal_add_qt_repo_known_module("${target}") + if(arg_INTERNAL_MODULE) + set_target_properties(${target} PROPERTIES _qt_is_internal_module TRUE) + set_property(TARGET ${target} APPEND PROPERTY EXPORT_PROPERTIES _qt_is_internal_module) + endif() + if(arg_HEADER_MODULE) + set_target_properties(${target} PROPERTIES _qt_is_header_module TRUE) + set_property(TARGET ${target} APPEND PROPERTY EXPORT_PROPERTIES _qt_is_header_module) + endif() + + if(NOT arg_CONFIG_MODULE_NAME) + set(arg_CONFIG_MODULE_NAME "${module_lower}") + endif() + + set(module_config_header "qt${arg_CONFIG_MODULE_NAME}-config.h") + set(module_config_private_header "qt${arg_CONFIG_MODULE_NAME}-config_p.h") + # qt-config.h/-config_p.h header files are not marked as GENERATED automatically + # for old CMake versions. Set the property explicitly here. + set_source_files_properties("${module_config_header}" "${module_config_private_header}" + PROPERTIES + GENERATED TRUE + SKIP_AUTOGEN TRUE + ) + + # Module define needs to take into account the config module name. + string(TOUPPER "${arg_CONFIG_MODULE_NAME}" module_define_infix) + string(REPLACE "-" "_" module_define_infix "${module_define_infix}") + string(REPLACE "." "_" module_define_infix "${module_define_infix}") + + set(property_prefix "INTERFACE_") + if(NOT arg_HEADER_MODULE) + set(property_prefix "") + endif() + + if(arg_INTERNAL_MODULE) + string(APPEND arg_CONFIG_MODULE_NAME "_private") + endif() + set_target_properties(${target} PROPERTIES + _qt_config_module_name "${arg_CONFIG_MODULE_NAME}" + ${property_prefix}QT_QMAKE_MODULE_CONFIG "${arg_QMAKE_MODULE_CONFIG}") + set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES _qt_config_module_name) + + set(is_framework 0) + if(QT_FEATURE_framework AND NOT ${arg_HEADER_MODULE} AND NOT ${arg_STATIC}) + set(is_framework 1) + set_target_properties(${target} PROPERTIES + FRAMEWORK TRUE + FRAMEWORK_VERSION "A" # Not based on Qt major version + MACOSX_FRAMEWORK_IDENTIFIER org.qt-project.${module} + MACOSX_FRAMEWORK_BUNDLE_VERSION ${PROJECT_VERSION} + MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR} + ) + qt_internal_get_framework_info(fw ${target}) + endif() + + if(NOT QT_FEATURE_no_direct_extern_access AND QT_FEATURE_reduce_relocations AND + UNIX AND NOT is_interface_lib) + # On x86 and x86-64 systems with ELF binaries (especially Linux), due to + # a new optimization in GCC 5.x in combination with a recent version of + # GNU binutils, compiling Qt applications with -fPIE is no longer + # enough. + # Applications now need to be compiled with the -fPIC option if the Qt option + # \"reduce relocations\" is active. + target_compile_options(${target} INTERFACE -fPIC) + if(GCC AND is_shared_lib) + target_link_options(${target} PRIVATE LINKER:-Bsymbolic-functions) + endif() + endif() + + if((FEATURE_ltcg OR CMAKE_INTERPROCEDURAL_OPTIMIZATION) AND GCC AND is_static_lib) + # CMake <= 3.19 appends -fno-fat-lto-objects for all library types if + # CMAKE_INTERPROCEDURAL_OPTIMIZATION is enabled. Static libraries need + # the opposite compiler option. + # (https://gitlab.kitware.com/cmake/cmake/-/issues/21696) + target_compile_options(${target} PRIVATE -ffat-lto-objects) + endif() + + qt_internal_add_target_aliases("${target}") + qt_skip_warnings_are_errors_when_repo_unclean("${target}") + + # No need to compile Q_IMPORT_PLUGIN-containing files for non-executables. + if(is_static_lib) + _qt_internal_disable_static_default_plugins("${target}") + endif() + + # Add _private target to link against the private headers: + set(target_private "${target}Private") + if(NOT ${arg_NO_PRIVATE_MODULE}) + add_library("${target_private}" INTERFACE) + qt_internal_add_target_aliases("${target_private}") + set_target_properties(${target_private} PROPERTIES + _qt_config_module_name ${arg_CONFIG_MODULE_NAME}_private + _qt_package_version "${PROJECT_VERSION}" + _qt_package_name "${INSTALL_CMAKE_NAMESPACE}${target}" + _qt_is_private_module TRUE + _qt_public_module_target_name "${target}" + ) + set(export_properties + "_qt_config_module_name" + "_qt_package_version" + "_qt_package_name" + "_qt_is_private_module" + "_qt_public_module_target_name" + ) + set_property(TARGET "${target_private}" APPEND PROPERTY + EXPORT_PROPERTIES "${export_properties}") + endif() + + # FIXME: This workaround is needed because the deployment logic + # for iOS and WASM just copies/embeds the directly linked library, + # which will just be a versioned symlink to the actual library. + if((UIKIT OR WASM) AND BUILD_SHARED_LIBS) + set(version_args "") + else() + set(version_args + VERSION ${PROJECT_VERSION} + SOVERSION ${PROJECT_VERSION_MAJOR}) + endif() + + if(NOT arg_HEADER_MODULE) + set_target_properties(${target} PROPERTIES + LIBRARY_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_LIBDIR}" + RUNTIME_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_BINDIR}" + ARCHIVE_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_LIBDIR}" + ${version_args} + ) + qt_set_target_info_properties(${target} ${ARGN}) + qt_handle_multi_config_output_dirs("${target}") + + if(NOT BUILD_SHARED_LIBS AND (LINUX OR VXWORKS)) + # Horrible workaround for static build failures due to incorrect static library link + # order. By increasing the multiplicity to 3, each library cycle will be repeated + # 3 times on the link line, reducing the probability of undefined symbols at + # link time. + # These failures are only observed on Linux with the ld linker (not sure about + # ld.gold). + # Allow opting out and modifying the value via cache value, in case if we urgently + # need to increase it without waiting for the qtbase change to propagate to + # other dependent repos. + # The proper fix will be to get rid of the cycles in the future. + # See QTBUG-83498 for details. + set(default_link_cycle_multiplicity "3") + if(DEFINED QT_LINK_CYCLE_MULTIPLICITY) + set(default_link_cycle_multiplicity "${QT_LINK_CYCLE_MULTIPLICITY}") + endif() + if(default_link_cycle_multiplicity) + set_property(TARGET "${target}" + PROPERTY + LINK_INTERFACE_MULTIPLICITY "${default_link_cycle_multiplicity}") + endif() + endif() + + if (arg_SKIP_DEPENDS_INCLUDE) + set_target_properties(${target} PROPERTIES _qt_module_skip_depends_include TRUE) + set_property(TARGET "${target}" APPEND PROPERTY + EXPORT_PROPERTIES _qt_module_skip_depends_include) + endif() + if(is_framework) + set_target_properties(${target} PROPERTIES + OUTPUT_NAME ${fw_name} + ) + else() + set_target_properties(${target} PROPERTIES + OUTPUT_NAME "${INSTALL_CMAKE_NAMESPACE}${module_interface_name}${QT_LIBINFIX}" + ) + endif() + + qt_set_common_target_properties(${target}) + + if (WIN32 AND BUILD_SHARED_LIBS) + _qt_internal_generate_win32_rc_file(${target}) + endif() + endif() + + # Module headers: + set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES _qt_module_has_headers) + if(${arg_NO_MODULE_HEADERS} OR ${arg_NO_SYNC_QT}) + set_target_properties("${target}" PROPERTIES + _qt_module_has_headers OFF) + else() + set_property(TARGET ${target} APPEND PROPERTY EXPORT_PROPERTIES _qt_module_include_name) + set_target_properties("${target}" PROPERTIES + _qt_module_include_name "${module_include_name}" + _qt_module_has_headers ON + ) + + set(sync_source_directory "${CMAKE_CURRENT_SOURCE_DIR}") + if(arg_HEADER_SYNC_SOURCE_DIRECTORY) + set(sync_source_directory "${arg_HEADER_SYNC_SOURCE_DIRECTORY}") + endif() + set_target_properties(${target} PROPERTIES + _qt_sync_source_directory "${sync_source_directory}") + # We should not generate export headers if module is defined as pure STATIC. + # Static libraries don't need to export their symbols, and corner cases when sources are + # also used in shared libraries, should be handled manually. + if(NOT arg_NO_GENERATE_CPP_EXPORTS AND NOT arg_STATIC AND NOT arg_HEADER_MODULE) + if(arg_CPP_EXPORT_HEADER_BASE_NAME) + set(cpp_export_header_base_name + "CPP_EXPORT_HEADER_BASE_NAME;${arg_CPP_EXPORT_HEADER_BASE_NAME}" + ) + endif() + qt_internal_generate_cpp_global_exports(${target} ${module_define_infix} + "${cpp_export_header_base_name}" + ) + endif() + + set(module_depends_header + "${module_build_interface_include_dir}/${module_include_name}Depends") + set_source_files_properties("${module_depends_header}" PROPERTIES GENERATED TRUE) + set_target_properties(${target} PROPERTIES _qt_module_depends_header + "${module_depends_header}") + if(NOT arg_HEADER_MODULE) + set(module_header "${module_build_interface_include_dir}/${module_include_name}") + set_property(TARGET "${target}" PROPERTY MODULE_HEADER + "${module_header}") + endif() + + set(qpa_filter_regex "") + if(arg_QPA_HEADER_FILTERS) + set(qpa_filter_regex "${arg_QPA_HEADER_FILTERS}") + endif() + set_target_properties(${target} + PROPERTIES _qt_module_qpa_headers_filter_regex "${qpa_filter_regex}") + + set(rhi_filter_regex "") + if(arg_RHI_HEADER_FILTERS) + set(rhi_filter_regex "${arg_RHI_HEADER_FILTERS}") + endif() + set_target_properties(${target} + PROPERTIES _qt_module_rhi_headers_filter_regex "${rhi_filter_regex}") + + set(ssg_filter_regex "") + if(arg_SSG_HEADER_FILTERS) + set(ssg_filter_regex "${arg_SSG_HEADER_FILTERS}") + endif() + set_target_properties(${target} + PROPERTIES _qt_module_ssg_headers_filter_regex "${ssg_filter_regex}") + + set(private_filter_regex ".+_p(ch)?\\.h") + if(arg_PRIVATE_HEADER_FILTERS) + set(private_filter_regex "${private_filter_regex}|${arg_PRIVATE_HEADER_FILTERS}") + endif() + set_target_properties(${target} + PROPERTIES _qt_module_private_headers_filter_regex "${private_filter_regex}") + + # If EXTERNAL_HEADERS_DIR is set we install the specified directory and keep the structure + # without taking into the account the CMake source tree and syncqt outputs. + if(arg_EXTERNAL_HEADERS_DIR) + set_property(TARGET ${target} + PROPERTY _qt_external_headers_dir "${arg_EXTERNAL_HEADERS_DIR}") + qt_install(DIRECTORY "${arg_EXTERNAL_HEADERS_DIR}/" + DESTINATION "${module_install_interface_include_dir}" + ) + endif() + endif() + + if(arg_NO_HEADERSCLEAN_CHECK OR arg_NO_MODULE_HEADERS OR arg_NO_SYNC_QT + OR NOT INPUT_headersclean) + set_target_properties("${target}" PROPERTIES _qt_no_headersclean_check ON) + endif() + + if(NOT arg_HEADER_MODULE) + # Plugin types associated to a module + if(NOT "x${arg_PLUGIN_TYPES}" STREQUAL "x") + qt_internal_add_plugin_types("${target}" "${arg_PLUGIN_TYPES}") + endif() + endif() + + if(NOT arg_HEADER_MODULE) + qt_autogen_tools_initial_setup(${target}) + endif() + + set(private_includes + "$" + "$" + ${arg_INCLUDE_DIRECTORIES} + ) + + set(public_includes "") + set(public_headers_list "public_includes") + if(is_framework) + set(public_headers_list "private_includes") + endif() + + # Make sure the BUILD_INTERFACE include paths come before the framework headers, so that the + # the compiler prefers the build dir includes. + # + # Make sure to add non-framework "build_dir/include" as an include path for moc to find the + # currently built module headers. qmake does this too. + # Framework-style include paths are found by moc when cmQtAutoMocUic.cxx detects frameworks by + # looking at an include path and detecting a "QtFoo.framework/Headers" path. + # Make sure to create such paths for both the the BUILD_INTERFACE and the INSTALL_INTERFACE. + # + # Only add syncqt headers if they exist. + # This handles cases like QmlDevToolsPrivate which do not have their own headers, but borrow + # them from another module. + if(NOT arg_NO_SYNC_QT AND NOT arg_NO_MODULE_HEADERS) + # Don't include private headers unless they exist, aka syncqt created them. + qt_internal_append_include_directories_with_headers_check(${target} + private_includes PRIVATE + "$" + "$" + ) + + list(APPEND public_includes + # For the syncqt headers + "$" + "$") + endif() + + if(is_framework) + set(fw_install_dir "${INSTALL_LIBDIR}/${fw_dir}") + set(fw_install_header_dir "${INSTALL_LIBDIR}/${fw_header_dir}") + set(fw_output_header_dir "${QT_BUILD_DIR}/${fw_install_header_dir}") + list(APPEND public_includes + # Add the framework Headers subdir, so that non-framework-style includes work. The + # BUILD_INTERFACE Headers symlink was previously claimed not to exist at the relevant + # time, and a fully specified Header path was used instead. This doesn't seem to be a + # problem anymore. + "$" + "$" + + # Add the lib/Foo.framework dir as an include path to let CMake generate + # the -F compiler flag for framework-style includes to work. + # Make sure it is added AFTER the lib/Foo.framework/Headers include path, + # to mitigate issues like QTBUG-101718 and QTBUG-101775 where an include like + # #include might cause moc to include the QtCore framework shared library + # instead of the actual header. + "$" + ) + endif() + + if(NOT arg_NO_MODULE_HEADERS AND NOT arg_NO_SYNC_QT) + # For the syncqt headers + list(APPEND ${public_headers_list} + "$") + + # To support finding Qt module includes that are not installed into the main Qt prefix. + # Use case: A Qt module built by Conan installed into a prefix other than the main prefix. + # This does duplicate the include path set on Qt6::Platform target, but CMake is smart + # enough to deduplicate the include paths on the command line. + # Frameworks are automatically handled by CMake in cmLocalGenerator::GetIncludeFlags() + # by additionally passing the 'QtFoo.framework/..' dir with an -iframework argument. + list(APPEND ${public_headers_list} "$") + endif() + list(APPEND ${public_headers_list} ${arg_PUBLIC_INCLUDE_DIRECTORIES}) + + set(defines_for_extend_target "") + + if(NOT arg_HEADER_MODULE) + list(APPEND defines_for_extend_target + QT_NO_CAST_TO_ASCII QT_ASCII_CAST_WARNINGS + QT_MOC_COMPAT #we don't need warnings from calling moc code in our generated code + QT_DEPRECATED_WARNINGS + QT_BUILDING_QT + QT_BUILD_${module_define_infix}_LIB ### FIXME: use QT_BUILD_ADDON for Add-ons or remove if we don't have add-ons anymore + ${deprecation_define} + ) + list(APPEND arg_LIBRARIES Qt::PlatformModuleInternal) + endif() + + qt_internal_add_repo_local_defines("${target}") + + if(arg_NO_UNITY_BUILD) + set(arg_NO_UNITY_BUILD "NO_UNITY_BUILD") + else() + set(arg_NO_UNITY_BUILD "") + endif() + + if(NOT arg_EXTERNAL_HEADERS) + set(arg_EXTERNAL_HEADERS "") + endif() + + _qt_internal_forward_function_args( + FORWARD_PREFIX arg + FORWARD_OUT_VAR extend_target_args + FORWARD_SINGLE + PRECOMPILED_HEADER + ) + + qt_internal_extend_target("${target}" + ${arg_NO_UNITY_BUILD} + SOURCES + ${arg_SOURCES} + ${arg_EXTERNAL_HEADERS} + NO_UNITY_BUILD_SOURCES + ${arg_NO_UNITY_BUILD_SOURCES} + INCLUDE_DIRECTORIES + ${private_includes} + SYSTEM_INCLUDE_DIRECTORIES + ${arg_SYSTEM_INCLUDE_DIRECTORIES} + PUBLIC_INCLUDE_DIRECTORIES + ${public_includes} + PUBLIC_DEFINES + ${arg_PUBLIC_DEFINES} + DEFINES + ${arg_DEFINES} + ${defines_for_extend_target} + PUBLIC_LIBRARIES ${arg_PUBLIC_LIBRARIES} + LIBRARIES ${arg_LIBRARIES} + PRIVATE_MODULE_INTERFACE ${arg_PRIVATE_MODULE_INTERFACE} + FEATURE_DEPENDENCIES ${arg_FEATURE_DEPENDENCIES} + DBUS_ADAPTOR_SOURCES ${arg_DBUS_ADAPTOR_SOURCES} + DBUS_ADAPTOR_FLAGS ${arg_DBUS_ADAPTOR_FLAGS} + DBUS_INTERFACE_SOURCES ${arg_DBUS_INTERFACE_SOURCES} + DBUS_INTERFACE_FLAGS ${arg_DBUS_INTERFACE_FLAGS} + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + PUBLIC_COMPILE_OPTIONS ${arg_PUBLIC_COMPILE_OPTIONS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + PUBLIC_LINK_OPTIONS ${arg_PUBLIC_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS} + NO_PCH_SOURCES ${arg_NO_PCH_SOURCES} + ${extend_target_args} + ) + + # The public module define is not meant to be used when building the module itself, + # it's only meant to be used for consumers of the module, + # thus we can't use qt_internal_extend_target()'s PUBLIC_DEFINES option. + target_compile_definitions(${target} INTERFACE QT_${module_define_infix}_LIB) + + if(NOT arg_EXCEPTIONS AND NOT ${arg_HEADER_MODULE}) + qt_internal_set_exceptions_flags("${target}" FALSE) + elseif(arg_EXCEPTIONS) + qt_internal_set_exceptions_flags("${target}" TRUE) + endif() + + set(configureFile "${CMAKE_CURRENT_SOURCE_DIR}/configure.cmake") + if(arg_CONFIGURE_FILE_PATH) + set(configureFile "${arg_CONFIGURE_FILE_PATH}") + endif() + if(EXISTS "${configureFile}" AND NOT arg_NO_CONFIG_HEADER_FILE) + qt_feature_module_begin( + LIBRARY "${target}" + PUBLIC_FILE "${module_config_header}" + PRIVATE_FILE "${module_config_private_header}" + PUBLIC_DEPENDENCIES ${arg_FEATURE_DEPENDENCIES} + PRIVATE_DEPENDENCIES ${arg_FEATURE_DEPENDENCIES} + ) + include(${configureFile}) + qt_feature_module_end("${target}") + + qt_internal_extend_target("${target}" + SOURCES + "${CMAKE_CURRENT_BINARY_DIR}/${module_config_header}" + "${CMAKE_CURRENT_BINARY_DIR}/${module_config_private_header}" + ) + endif() + + # Handle creation of cmake files for consumers of find_package(). + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}${target}") + qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${path_suffix}) + qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${path_suffix}) + + set(extra_cmake_files) + set(extra_cmake_includes) + if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${INSTALL_CMAKE_NAMESPACE}${target}Macros.cmake") + list(APPEND extra_cmake_files "${CMAKE_CURRENT_LIST_DIR}/${INSTALL_CMAKE_NAMESPACE}${target}Macros.cmake") + list(APPEND extra_cmake_includes "${INSTALL_CMAKE_NAMESPACE}${target}Macros.cmake") + endif() + + if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigExtras.cmake.in") + if(target STREQUAL Core) + if(NOT "${QT_NAMESPACE}" STREQUAL "") + string(MAKE_C_IDENTIFIER "${QT_NAMESPACE}" qt_namespace_sanity) + if(NOT "${QT_NAMESPACE}" STREQUAL "${qt_namespace_sanity}") + message(FATAL_ERROR "QT_NAMESPACE is not a valid C++ identifier: " + "${QT_NAMESPACE}.") + endif() + string(JOIN "" qtcore_namespace_definition + "set_property(TARGET \${__qt_core_target} " + "APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS QT_NAMESPACE=${QT_NAMESPACE})" + ) + endif() + + set(extra_cmake_code "") + # Add some variables for compatibility with Qt5 config files. + if(QT_FEATURE_reduce_exports) + string(APPEND qtcore_extra_cmake_code " +set(QT_VISIBILITY_AVAILABLE TRUE)") + endif() + if(QT_LIBINFIX) + string(APPEND qtcore_extra_cmake_code " +set(QT_LIBINFIX \"${QT_LIBINFIX}\")") + endif() + + # Store whether find_package(Qt6Foo) should succeed if Qt6FooTools is missing. + if(QT_ALLOW_MISSING_TOOLS_PACKAGES) + string(APPEND qtcore_extra_cmake_code " +set(QT_ALLOW_MISSING_TOOLS_PACKAGES TRUE)") + endif() + endif() + + configure_file("${CMAKE_CURRENT_LIST_DIR}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigExtras.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigExtras.cmake" + @ONLY) + list(APPEND extra_cmake_files "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigExtras.cmake") + list(APPEND extra_cmake_includes "${INSTALL_CMAKE_NAMESPACE}${target}ConfigExtras.cmake") + endif() + + foreach(cmake_file IN LISTS arg_EXTRA_CMAKE_FILES) + get_filename_component(basename ${cmake_file} NAME) + file(COPY ${cmake_file} DESTINATION ${config_build_dir}) + list(APPEND extra_cmake_files "${config_build_dir}/${basename}") + + # Make sure touched extra cmake files cause a reconfigure, so they get re-copied. + set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${cmake_file}") + endforeach() + list(APPEND extra_cmake_includes ${arg_EXTRA_CMAKE_INCLUDES}) + + set(extra_cmake_code "") + + if(arg_POLICIES) + set(policies "") + foreach(policy IN LISTS arg_POLICIES) + list(APPEND policies "set(QT_KNOWN_POLICY_${policy} TRUE)") + + # When building Qt, tests and examples might expect a policy to be known, but they + # won't be known depending on which scope or when a find_package(Module) with the + # respective policy is called. Check the global list of known policies to accommodate + # that. + set_property(GLOBAL APPEND PROPERTY _qt_global_known_policies "${policy}") + endforeach() + list(JOIN policies "\n" policies_str) + string(APPEND extra_cmake_code "${policies_str}\n") + endif() + + # Generate metatypes + if (NOT ${arg_NO_GENERATE_METATYPES} AND NOT target_type STREQUAL "INTERFACE_LIBRARY") + set(args "") + if(QT_WILL_INSTALL) + set(metatypes_install_dir "${INSTALL_ARCHDATADIR}/metatypes") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.31") + cmake_path(SET metatypes_install_dir NORMALIZE "${metatypes_install_dir}") + endif() + list(APPEND args + __QT_INTERNAL_INSTALL __QT_INTERNAL_INSTALL_DIR "${metatypes_install_dir}") + endif() + qt6_extract_metatypes(${target} ${args}) + endif() + + qt_internal_get_min_new_policy_cmake_version(min_new_policy_version) + qt_internal_get_max_new_policy_cmake_version(max_new_policy_version) + configure_package_config_file( + "${QT_CMAKE_DIR}/QtModuleConfig.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake" + INSTALL_DESTINATION "${config_install_dir}" + ) + + if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${INSTALL_CMAKE_NAMESPACE}${target}BuildInternals.cmake") + configure_file("${CMAKE_CURRENT_LIST_DIR}/${INSTALL_CMAKE_NAMESPACE}${target}BuildInternals.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}BuildInternals.cmake" + @ONLY) + list(APPEND extra_cmake_files "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}BuildInternals.cmake") + endif() + + write_basic_package_version_file( + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion + ) + qt_internal_write_qt_package_version_file( + "${INSTALL_CMAKE_NAMESPACE}${target}" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersion.cmake" + ) + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersion.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake" + ${extra_cmake_files} + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + + file(COPY ${extra_cmake_files} DESTINATION "${config_build_dir}") + set(exported_targets ${target}) + if(NOT ${arg_NO_PRIVATE_MODULE}) + list(APPEND exported_targets ${target_private}) + endif() + set(export_name "${INSTALL_CMAKE_NAMESPACE}${target}Targets") + + qt_install(TARGETS ${exported_targets} + EXPORT ${export_name} + RUNTIME DESTINATION ${INSTALL_BINDIR} + LIBRARY DESTINATION ${INSTALL_LIBDIR} + ARCHIVE DESTINATION ${INSTALL_LIBDIR} + FRAMEWORK DESTINATION ${INSTALL_LIBDIR} + ) + + if(BUILD_SHARED_LIBS) + qt_apply_rpaths(TARGET "${target}" INSTALL_PATH "${INSTALL_LIBDIR}" RELATIVE_RPATH) + qt_internal_apply_staging_prefix_build_rpath_workaround() + endif() + + if (ANDROID AND NOT arg_HEADER_MODULE) + # Record install library location so it can be accessed by + # qt_internal_android_dependencies without having to specify it again. + set_target_properties(${target} PROPERTIES + QT_ANDROID_MODULE_INSTALL_DIR ${INSTALL_LIBDIR}) + endif() + + qt_install(EXPORT ${export_name} + NAMESPACE ${QT_CMAKE_EXPORT_NAMESPACE}:: + DESTINATION ${config_install_dir}) + + if(NOT arg_NO_ADDITIONAL_TARGET_INFO) + qt_internal_export_additional_targets_file( + TARGETS ${exported_targets} + EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target} + CONFIG_INSTALL_DIR "${config_install_dir}") + endif() + + qt_internal_export_modern_cmake_config_targets_file( + TARGETS ${exported_targets} + EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target} + CONFIG_BUILD_DIR "${config_build_dir}" + CONFIG_INSTALL_DIR "${config_install_dir}" + ) + + qt_internal_export_genex_properties(TARGETS ${target} + EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target} + CONFIG_INSTALL_DIR "${config_install_dir}" + ) + + ### fixme: cmake is missing a built-in variable for this. We want to apply it only to modules and plugins + # that belong to Qt. + if(NOT arg_HEADER_MODULE) + qt_internal_add_link_flags_no_undefined("${target}") + endif() + + set(interface_includes "") + + # Handle cases like QmlDevToolsPrivate which do not have their own headers, but rather borrow them + # from another module. + if(NOT arg_NO_SYNC_QT AND NOT arg_NO_MODULE_HEADERS) + list(APPEND interface_includes "$") + + # syncqt does not create a private header directory like 'include/6.0/QtFoo' unless + # the module has foo_p.h header files. For QtZlib, there are no such private headers, so we + # need to make sure not to add such include paths unless the directory exists, otherwise + # consumers of the module will fail at CMake generation time stating that + # INTERFACE_INCLUDE_DIRECTORIES contains a non-existent path. + qt_internal_append_include_directories_with_headers_check(${target} + interface_includes PRIVATE + "$" + "$" + ) + + if(is_framework) + set(fw_install_private_header_dir "${INSTALL_LIBDIR}/${fw_private_header_dir}") + set(fw_install_private_module_header_dir + "${INSTALL_LIBDIR}/${fw_private_module_header_dir}") + qt_internal_append_include_directories_with_headers_check(${target} + interface_includes PRIVATE + "$" + "$" + ) + else() + qt_internal_append_include_directories_with_headers_check(${target} + interface_includes PRIVATE + "$" + "$" + ) + endif() + endif() + + if(arg_INTERNAL_MODULE) + target_include_directories("${target}" INTERFACE ${interface_includes}) + elseif(NOT ${arg_NO_PRIVATE_MODULE}) + target_include_directories("${target_private}" INTERFACE ${interface_includes}) + target_link_libraries("${target_private}" INTERFACE "${target}") + endif() + + set(debug_install_dir "${INSTALL_LIBDIR}") + if (MINGW) + set(debug_install_dir "${INSTALL_BINDIR}") + endif() + qt_enable_separate_debug_info(${target} "${debug_install_dir}") + set(pdb_install_dir "${INSTALL_BINDIR}") + if(NOT is_shared_lib) + set(pdb_install_dir "${INSTALL_LIBDIR}") + endif() + qt_internal_install_pdb_files(${target} "${pdb_install_dir}") + + if (arg_NO_PRIVATE_MODULE) + set(arg_NO_PRIVATE_MODULE "NO_PRIVATE_MODULE") + else() + unset(arg_NO_PRIVATE_MODULE) + endif() + + qt_describe_module(${target}) + + if(QT_GENERATE_SBOM) + set(sbom_args "") + + # 3rd party header modules should not be treated as Qt modules. + if(arg_IS_QT_3RD_PARTY_HEADER_MODULE) + list(APPEND sbom_args TYPE QT_THIRD_PARTY_MODULE) + else() + list(APPEND sbom_args TYPE QT_MODULE) + endif() + + qt_get_cmake_configurations(configs) + foreach(config IN LISTS configs) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + RUNTIME_PATH + "${INSTALL_BINDIR}" + "${config}" + sbom_args + ) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + LIBRARY_PATH + "${INSTALL_LIBDIR}" + "${config}" + sbom_args + ) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + ARCHIVE_PATH + "${INSTALL_LIBDIR}" + "${config}" + sbom_args + ) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + FRAMEWORK_PATH + "${INSTALL_LIBDIR}/${fw_versioned_binary_dir}" + "${config}" + sbom_args + ) + endforeach() + + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + ${__qt_internal_sbom_optional_args} + FORWARD_SINGLE + ${__qt_internal_sbom_single_args} + FORWARD_MULTI + ${__qt_internal_sbom_multi_args} + ) + + _qt_internal_extend_sbom(${target} ${sbom_args}) + endif() + + qt_add_list_file_finalizer(qt_finalize_module ${target} ${arg_INTERNAL_MODULE} ${arg_NO_PRIVATE_MODULE}) +endfunction() + +function(qt_internal_apply_apple_privacy_manifest target) + # Avoid "INTERFACE_LIBRARY targets may only have whitelisted properties" error on CMake < 3.17. + get_target_property(target_type ${target} TYPE) + if("${target_type}" STREQUAL "INTERFACE_LIBRARY") + return() + endif() + + if(APPLE) + # Privacy manifest + get_target_property(is_framework ${target} FRAMEWORK) + if(is_framework) + get_target_property(privacy_manifest ${target} _qt_privacy_manifest) + if(NOT privacy_manifest) + set(privacy_manifest + "${__qt_internal_cmake_apple_support_files_path}/PrivacyInfo.xcprivacy") + endif() + target_sources("${target}" PRIVATE "${privacy_manifest}") + set_property(TARGET "${target}" APPEND PROPERTY RESOURCE "${privacy_manifest}") + endif() + endif() +endfunction() + +function(qt_finalize_module target) + qt_internal_collect_module_headers(module_headers ${target}) + + # qt_internal_install_module_headers needs to be called before + # qt_finalize_framework_headers_copy, because the last uses the QT_COPIED_FRAMEWORK_HEADERS + # property which supposed to be updated inside every qt_internal_install_module_headers + # call. + qt_internal_add_headersclean_target(${target} "${module_headers_public}") + qt_internal_target_sync_headers(${target} "${module_headers_all}" + "${module_headers_generated}") + get_target_property(module_depends_header ${target} _qt_module_depends_header) + qt_internal_install_module_headers(${target} + PUBLIC ${module_headers_public} "${module_depends_header}" + PRIVATE ${module_headers_private} + QPA ${module_headers_qpa} + RHI ${module_headers_rhi} + SSG ${module_headers_ssg} + ) + + qt_finalize_framework_headers_copy(${target}) + qt_generate_prl_file(${target} "${INSTALL_LIBDIR}") + qt_generate_module_pri_file("${target}" ${ARGN}) + qt_internal_generate_pkg_config_file(${target}) + qt_internal_apply_apple_privacy_manifest(${target}) + _qt_internal_finalize_sbom(${target}) +endfunction() + +# Get a set of Qt module related values based on the target. +# +# The function uses the _qt_module_interface_name and _qt_module_include_name target properties to +# preform values for the output variables. _qt_module_interface_name it's the basic name of module +# without "Qtfication" and the "Private" suffix if we speak about INTERNAL_MODULEs. Typical value of +# the _qt_module_interface_name is the provided to qt_internal_add_module ${target} name, e.g. Core. +# _qt_module_interface_name is used to preform all the include paths unless the +# _qt_module_include_name property is specified. _qt_module_include_name is legacy property that +# replaces the module name in include paths and has a higher priority than the +# _qt_module_interface_name property. +# +# When doing qt_internal_module_info(foo Core) this method will set the following variables in +# the caller's scope: +# * foo with the value "QtCore" +# * foo_versioned with the value "Qt6Core" (based on major Qt version) +# * foo_upper with the value "CORE" +# * foo_lower with the value "core" +# * foo_include_name with the value"QtCore" +# Usually the module name from ${foo} is used, but the name might be different if the +# MODULE_INCLUDE_NAME argument is set when creating the module. +# * foo_versioned_include_dir with the value "QtCore/6.2.0" +# * foo_versioned_inner_include_dir with the value "QtCore/6.2.0/QtCore" +# * foo_private_include_dir with the value "QtCore/6.2.0/QtCore/private" +# * foo_qpa_include_dir with the value "QtCore/6.2.0/QtCore/qpa" +# * foo_rhi_include_dir with the value "QtCore/6.2.0/QtCore/rhi" +# * foo_ssg_include_dir with the value "QtQuick3D/6.2.0/QtQuick3D/ssg" +# * foo_interface_name the interface name of the module stored in _qt_module_interface_name +# property, e.g. Core. +# +# The function also sets a bunch of module include paths for the build and install interface. +# Variables that contains these paths start with foo_build_interface_ and foo_install_interface_ +# accordingly. +# The following variables are set in the caller's scope: +# * foo__interface_include_dir with +# qtbase_build_dir/include/QtCore for build interface and +# include/QtCore for install interface. +# * foo__interface_versioned_include_dir with +# qtbase_build_dir/include/QtCore/6.2.0 for build interface and +# include/QtCore/6.2.0 for install interface. +# * foo__versioned_inner_include_dir with +# qtbase_build_dir/include/QtCore/6.2.0/QtCore for build interface and +# include/QtCore/6.2.0/QtCore for install interface. +# * foo__private_include_dir with +# qtbase_build_dir/include/QtCore/6.2.0/QtCore/private for build interface and +# include/QtCore/6.2.0/QtCore/private for install interface. +# * foo__qpa_include_dir with +# qtbase_build_dir/include/QtCore/6.2.0/QtCore/qpa for build interface and +# include/QtCore/6.2.0/QtCore/qpa for install interface. +# * foo__rhi_include_dir with +# qtbase_build_dir/include/QtCore/6.2.0/QtCore/rhi for build interface and +# include/QtCore/6.2.0/QtCore/rhi for install interface. +# * foo__ssg_include_dir with +# qtbase_build_dir/include//x.y.z//ssg for build interface and +# include//x.y.z//ssg for install interface. +# The following values are set by the function and might be useful in caller's scope: +# * repo_install_interface_include_dir contains path to the top-level repository include directory, +# e.g. qtbase_build_dir/include +# * repo_install_interface_include_dir contains path to the non-prefixed top-level include +# directory is used for the installation, e.g. include +# Note: that for non-prefixed Qt configurations the build interface paths will start with +# /qtbase/include, e.g foo_build_interface_include_dir of the Qml module looks +# like qt_toplevel_build_dir/qtbase/include/QtQml +function(qt_internal_module_info result target) + if(result STREQUAL "repo") + message(FATAL_ERROR "'repo' keyword is reserved for internal use, please specify \ +the different base name for the module info variables.") + endif() + + get_target_property(module_interface_name ${target} _qt_module_interface_name) + if(NOT module_interface_name) + message(FATAL_ERROR "${target} is not a module.") + endif() + + qt_internal_qtfy_target(module ${module_interface_name}) + + get_target_property("${result}_include_name" ${target} _qt_module_include_name) + if(NOT ${result}_include_name) + set("${result}_include_name" "${module}") + endif() + + set("${result}_versioned_include_dir" + "${${result}_include_name}/${PROJECT_VERSION}") + set("${result}_versioned_inner_include_dir" + "${${result}_versioned_include_dir}/${${result}_include_name}") + set("${result}_private_include_dir" + "${${result}_versioned_inner_include_dir}/private") + set("${result}_qpa_include_dir" + "${${result}_versioned_inner_include_dir}/qpa") + set("${result}_rhi_include_dir" + "${${result}_versioned_inner_include_dir}/rhi") + set("${result}_ssg_include_dir" + "${${result}_versioned_inner_include_dir}/ssg") + + # Module build interface directories + set(repo_build_interface_include_dir "${QT_BUILD_DIR}/include") + set("${result}_build_interface_include_dir" + "${repo_build_interface_include_dir}/${${result}_include_name}") + set("${result}_build_interface_versioned_include_dir" + "${repo_build_interface_include_dir}/${${result}_versioned_include_dir}") + set("${result}_build_interface_versioned_inner_include_dir" + "${repo_build_interface_include_dir}/${${result}_versioned_inner_include_dir}") + set("${result}_build_interface_private_include_dir" + "${repo_build_interface_include_dir}/${${result}_private_include_dir}") + set("${result}_build_interface_qpa_include_dir" + "${repo_build_interface_include_dir}/${${result}_qpa_include_dir}") + set("${result}_build_interface_rhi_include_dir" + "${repo_build_interface_include_dir}/${${result}_rhi_include_dir}") + set("${result}_build_interface_ssg_include_dir" + "${repo_build_interface_include_dir}/${${result}_ssg_include_dir}") + + # Module install interface directories + set(repo_install_interface_include_dir "${INSTALL_INCLUDEDIR}") + set("${result}_install_interface_include_dir" + "${repo_install_interface_include_dir}/${${result}_include_name}") + set("${result}_install_interface_versioned_include_dir" + "${repo_install_interface_include_dir}/${${result}_versioned_include_dir}") + set("${result}_install_interface_versioned_inner_include_dir" + "${repo_install_interface_include_dir}/${${result}_versioned_inner_include_dir}") + set("${result}_install_interface_private_include_dir" + "${repo_install_interface_include_dir}/${${result}_private_include_dir}") + set("${result}_install_interface_qpa_include_dir" + "${repo_install_interface_include_dir}/${${result}_qpa_include_dir}") + set("${result}_install_interface_rhi_include_dir" + "${repo_install_interface_include_dir}/${${result}_rhi_include_dir}") + set("${result}_install_interface_ssg_include_dir" + "${repo_install_interface_include_dir}/${${result}_ssg_include_dir}") + + set("${result}" "${module}" PARENT_SCOPE) + set("${result}_versioned" "${module_versioned}" PARENT_SCOPE) + string(TOUPPER "${module_interface_name}" upper) + string(TOLOWER "${module_interface_name}" lower) + set("${result}_upper" "${upper}" PARENT_SCOPE) + set("${result}_lower" "${lower}" PARENT_SCOPE) + set("${result}_include_name" "${${result}_include_name}" PARENT_SCOPE) + set("${result}_versioned_include_dir" "${${result}_versioned_include_dir}" PARENT_SCOPE) + set("${result}_versioned_inner_include_dir" + "${${result}_versioned_inner_include_dir}" PARENT_SCOPE) + set("${result}_private_include_dir" "${${result}_private_include_dir}" PARENT_SCOPE) + set("${result}_qpa_include_dir" "${${result}_qpa_include_dir}" PARENT_SCOPE) + set("${result}_rhi_include_dir" "${${result}_rhi_include_dir}" PARENT_SCOPE) + set("${result}_ssg_include_dir" "${${result}_ssg_include_dir}" PARENT_SCOPE) + set("${result}_interface_name" "${module_interface_name}" PARENT_SCOPE) + + # Setting module build interface directories in parent scope + set(repo_build_interface_include_dir "${repo_build_interface_include_dir}" PARENT_SCOPE) + set("${result}_build_interface_include_dir" + "${${result}_build_interface_include_dir}" PARENT_SCOPE) + set("${result}_build_interface_versioned_include_dir" + "${${result}_build_interface_versioned_include_dir}" PARENT_SCOPE) + set("${result}_build_interface_versioned_inner_include_dir" + "${${result}_build_interface_versioned_inner_include_dir}" PARENT_SCOPE) + set("${result}_build_interface_private_include_dir" + "${${result}_build_interface_private_include_dir}" PARENT_SCOPE) + set("${result}_build_interface_qpa_include_dir" + "${${result}_build_interface_qpa_include_dir}" PARENT_SCOPE) + set("${result}_build_interface_rhi_include_dir" + "${${result}_build_interface_rhi_include_dir}" PARENT_SCOPE) + set("${result}_build_interface_ssg_include_dir" + "${${result}_build_interface_ssg_include_dir}" PARENT_SCOPE) + + # Setting module install interface directories in parent scope + set(repo_install_interface_include_dir "${repo_install_interface_include_dir}" PARENT_SCOPE) + set("${result}_install_interface_include_dir" + "${${result}_install_interface_include_dir}" PARENT_SCOPE) + set("${result}_install_interface_versioned_include_dir" + "${${result}_install_interface_versioned_include_dir}" PARENT_SCOPE) + set("${result}_install_interface_versioned_inner_include_dir" + "${${result}_install_interface_versioned_inner_include_dir}" PARENT_SCOPE) + set("${result}_install_interface_private_include_dir" + "${${result}_install_interface_private_include_dir}" PARENT_SCOPE) + set("${result}_install_interface_qpa_include_dir" + "${${result}_install_interface_qpa_include_dir}" PARENT_SCOPE) + set("${result}_install_interface_rhi_include_dir" + "${${result}_install_interface_rhi_include_dir}" PARENT_SCOPE) + set("${result}_install_interface_ssg_include_dir" + "${${result}_install_interface_ssg_include_dir}" PARENT_SCOPE) +endfunction() + +function(qt_internal_list_to_json_array out_var list_var) + set(result "") + foreach(item IN LISTS ${list_var}) + if(NOT "${result}" STREQUAL "") + string(APPEND result ", ") + endif() + string(APPEND result "\"${item}\"") + endforeach() + set("${out_var}" "[${result}]" PARENT_SCOPE) +endfunction() + +# Generate a module description file based on the template in ModuleDescription.json.in +function(qt_describe_module target) + set(path_suffix "${INSTALL_DESCRIPTIONSDIR}") + qt_path_join(build_dir ${QT_BUILD_DIR} ${path_suffix}) + qt_path_join(install_dir ${QT_INSTALL_DIR} ${path_suffix}) + + set(descfile_in "${QT_CMAKE_DIR}/ModuleDescription.json.in") + set(descfile_out "${build_dir}/${target}.json") + string(TOLOWER "${PROJECT_NAME}" lower_case_project_name) + set(cross_compilation "false") + if(CMAKE_CROSSCOMPILING) + set(cross_compilation "true") + endif() + set(extra_module_information "") + + get_target_property(target_type ${target} TYPE) + if(NOT target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(plugin_types ${target} QMAKE_MODULE_PLUGIN_TYPES) + if(plugin_types) + qt_internal_list_to_json_array(plugin_types plugin_types) + string(APPEND extra_module_information "\n \"plugin_types\": ${plugin_types},") + endif() + endif() + + get_target_property(is_internal ${target} _qt_is_internal_module) + if(is_internal) + string(APPEND extra_module_information "\n \"internal\": true,") + endif() + + set(extra_build_information "") + if(NOT QT_NAMESPACE STREQUAL "") + string(APPEND extra_build_information " + \"namespace\": \"${QT_NAMESPACE}\",") + endif() + if(ANDROID) + string(APPEND extra_build_information " + \"android\": { + \"api_version\": \"${QT_ANDROID_API_VERSION}\", + \"ndk\": { + \"version\": \"${ANDROID_NDK_REVISION}\" + } + },") + endif() + configure_file("${descfile_in}" "${descfile_out}") + + qt_install(FILES "${descfile_out}" DESTINATION "${install_dir}") +endfunction() + +function(qt_internal_generate_cpp_global_exports target module_define_infix) + cmake_parse_arguments(arg + "" + "CPP_EXPORT_HEADER_BASE_NAME" + "" ${ARGN} + ) + + qt_internal_module_info(module "${target}") + + set(header_base_name "qt${module_lower}exports") + if(arg_CPP_EXPORT_HEADER_BASE_NAME) + set(header_base_name "${arg_CPP_EXPORT_HEADER_BASE_NAME}") + endif() + # Is used as a part of the header guard define. + string(TOUPPER "${header_base_name}" header_base_name_upper) + + set(generated_header_path + "${module_build_interface_include_dir}/${header_base_name}.h" + ) + + configure_file("${QT_CMAKE_DIR}/modulecppexports.h.in" + "${generated_header_path}" @ONLY + ) + + set(${out_public_header} "${generated_header_path}" PARENT_SCOPE) + target_sources(${target} PRIVATE "${generated_header_path}") + set_source_files_properties("${generated_header_path}" PROPERTIES GENERATED TRUE) +endfunction() + +function(qt_internal_install_module_headers target) + set(options) + set(one_value_args) + set(multi_value_args PUBLIC PRIVATE QPA RHI SSG) + cmake_parse_arguments(arg "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN}) + + qt_internal_module_info(module ${target}) + + get_target_property(target_type ${target} TYPE) + set(is_interface_lib FALSE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + set(is_interface_lib TRUE) + else() + get_target_property(is_framework ${target} FRAMEWORK) + endif() + + + foreach(header_type IN LISTS multi_value_args) + if(NOT arg_${header_type}) + set(arg_${header_type} "") + endif() + endforeach() + + if(is_framework) + qt_copy_framework_headers(${target} + PUBLIC ${arg_PUBLIC} + PRIVATE ${arg_PRIVATE} + QPA ${arg_QPA} + RHI ${arg_RHI} + SSG ${arg_SSG} + ) + else() + if(arg_PUBLIC) + qt_install(FILES ${arg_PUBLIC} + DESTINATION "${module_install_interface_include_dir}") + endif() + if(arg_PRIVATE) + qt_install(FILES ${arg_PRIVATE} + DESTINATION "${module_install_interface_private_include_dir}") + endif() + if(arg_QPA) + qt_install(FILES ${arg_QPA} DESTINATION "${module_install_interface_qpa_include_dir}") + endif() + if(arg_RHI) + qt_install(FILES ${arg_RHI} DESTINATION "${module_install_interface_rhi_include_dir}") + endif() + if(arg_SSG) + qt_install(FILES ${arg_SSG} DESTINATION "${module_install_interface_ssg_include_dir}") + endif() + endif() +endfunction() + +function(qt_internal_collect_module_headers out_var target) + set(${out_var}_public "") + set(${out_var}_private "") + set(${out_var}_qpa "") + set(${out_var}_rhi "") + set(${out_var}_ssg "") + set(${out_var}_all "") + + qt_internal_get_target_sources(sources ${target}) + + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + set(source_dir "${CMAKE_CURRENT_SOURCE_DIR}") + set(binary_dir "${CMAKE_CURRENT_BINARY_DIR}") + else() + get_target_property(source_dir ${target} SOURCE_DIR) + get_target_property(binary_dir ${target} BINARY_DIR) + endif() + get_filename_component(source_dir "${source_dir}" ABSOLUTE) + get_filename_component(binary_dir "${binary_dir}" ABSOLUTE) + + get_target_property(is_3rdparty_library ${target} _qt_module_is_3rdparty_header_library) + + get_target_property(public_filter ${target} _qt_module_public_headers_filter_regex) + get_target_property(private_filter ${target} _qt_module_private_headers_filter_regex) + get_target_property(qpa_filter ${target} _qt_module_qpa_headers_filter_regex) + get_target_property(rhi_filter ${target} _qt_module_rhi_headers_filter_regex) + get_target_property(ssg_filter ${target} _qt_module_ssg_headers_filter_regex) + + set(condition_independent_headers_warning "") + foreach(file_path IN LISTS sources) + get_filename_component(file_name "${file_path}" NAME) + if(NOT file_name MATCHES ".+\\.h$") + continue() + endif() + + get_source_file_property(non_module_header ${file_path} _qt_non_module_header) + if(non_module_header) + continue() + endif() + + get_filename_component(file_path "${file_path}" ABSOLUTE) + + string(FIND "${file_path}" "${source_dir}" source_dir_pos) + if(source_dir_pos EQUAL 0) + set(is_outside_module_source_dir FALSE) + else() + set(is_outside_module_source_dir TRUE) + endif() + + get_source_file_property(is_generated "${file_path}" GENERATED) + # Skip all header files outside the module source directory, except the generated files. + if(is_outside_module_source_dir AND NOT is_generated) + continue() + endif() + + get_source_file_property(condition ${file_path} _qt_extend_target_condition) + if(NOT condition STREQUAL "" AND NOT condition STREQUAL "NOTFOUND") + list(JOIN condition " " condition_string) + string(APPEND condition_independent_headers_warning + "\nFile:\n ${file_path}" + "\nCondition:\n ${condition_string}") + endif() + + if(is_outside_module_source_dir) + set(base_dir "${binary_dir}") + else() + set(base_dir "${source_dir}") + endif() + + file(RELATIVE_PATH file_path_rel "${base_dir}" "${file_path}") + if(file_path_rel MATCHES "3rdparty/.+" AND NOT is_3rdparty_library) + set(is_3rdparty_header TRUE) + else() + set(is_3rdparty_header FALSE) + endif() + list(APPEND ${out_var}_all "${file_path}") + if(qpa_filter AND file_name MATCHES "${qpa_filter}") + list(APPEND ${out_var}_qpa "${file_path}") + elseif(rhi_filter AND file_name MATCHES "${rhi_filter}") + list(APPEND ${out_var}_rhi "${file_path}") + elseif(ssg_filter AND file_name MATCHES "${ssg_filter}") + list(APPEND ${out_var}_ssg "${file_path}") + elseif(private_filter AND file_name MATCHES "${private_filter}") + list(APPEND ${out_var}_private "${file_path}") + elseif((NOT public_filter OR file_name MATCHES "${public_filter}") + AND NOT is_3rdparty_header) + list(APPEND ${out_var}_public "${file_path}") + endif() + if(is_generated) + list(APPEND ${out_var}_generated "${file_path}") + endif() + endforeach() + + if(NOT condition_independent_headers_warning STREQUAL "" AND QT_FEATURE_developer_build) + message(AUTHOR_WARNING "Condition is ignored when adding the following header file(s) to" + " the ${target} module:" + "${condition_independent_headers_warning}" + "\nThe usage of the file(s) is not properly isolated in this or other modules according" + " to the condition. This warning is for the Qt maintainers. Please make sure that file" + " include(s) are guarded with the appropriate macros in the Qt code. If files should be" + " added to the module unconditionally, please move them to the common SOURCES section" + " in the qt_internal_add_module call.") + endif() + + + set(header_types public private qpa rhi ssg) + set(has_header_types_properties "") + foreach(header_type IN LISTS header_types) + get_target_property(current_propety_value ${target} _qt_module_has_${header_type}_headers) + if(${out_var}_${header_type}) + list(APPEND has_header_types_properties + _qt_module_has_${header_type}_headers TRUE) + endif() + + set(${out_var}_${header_type} "${${out_var}_${header_type}}" PARENT_SCOPE) + endforeach() + set(${out_var}_all "${${out_var}_all}" PARENT_SCOPE) + set(${out_var}_generated "${${out_var}_generated}" PARENT_SCOPE) + + if(has_header_types_properties) + set_target_properties(${target} PROPERTIES ${has_header_types_properties}) + endif() + set_property(TARGET ${target} APPEND PROPERTY + EXPORT_PROPERTIES + _qt_module_has_public_headers + _qt_module_has_private_headers + _qt_module_has_qpa_headers + _qt_module_has_rhi_headers + _qt_module_has_ssg_headers + ) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsConfig.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsConfig.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..b26ef5b4bf8b60ea5feee719fe03d56c7fb06ff4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsConfig.cmake.in @@ -0,0 +1,33 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +@PACKAGE_INIT@ + +cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_version@) + +include(CMakeFindDependencyMacro) + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake") +endif() + +# If *Dependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "@INSTALL_CMAKE_NAMESPACE@@target@_FOUND") + set("@INSTALL_CMAKE_NAMESPACE@@target@_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND @INSTALL_CMAKE_NAMESPACE@@target@_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Targets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@AdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@VersionlessTargets.cmake") + endif() +endif() + +foreach(extra_cmake_include @extra_cmake_includes@) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() + +@extra_cmake_statements@ diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsDependencies.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsDependencies.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..3abf900e2987f5c7e3ac5ea186cf0429c718c534 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsDependencies.cmake.in @@ -0,0 +1,16 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Find "ModuleTools" dependencies, which are other ModuleTools packages. +set(@INSTALL_CMAKE_NAMESPACE@@target@_FOUND FALSE) +set(__qt_@target@_tool_deps "@package_deps@") +foreach(__qt_@target@_target_dep ${__qt_@target@_tool_deps}) + list(GET __qt_@target@_target_dep 0 __qt_@target@_pkg) + list(GET __qt_@target@_target_dep 1 __qt_@target@_version) + + if (NOT ${__qt_@target@_pkg}_FOUND) + find_dependency(${__qt_@target@_pkg} ${__qt_@target@_version}) + endif() +endforeach() + +set(@INSTALL_CMAKE_NAMESPACE@@target@_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsVersionlessTargets.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsVersionlessTargets.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..dc890137e2514ba1129fb953e8ac809f8a9f6c99 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtModuleToolsVersionlessTargets.cmake.in @@ -0,0 +1,26 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +foreach(__qt_tool @tool_targets_non_prefixed@) + if(NOT TARGET Qt::${__qt_tool} AND TARGET Qt6::${__qt_tool}) + add_executable(Qt::${__qt_tool} IMPORTED GLOBAL) + + # Check all the usual imported location properties to find one that contains a path. + foreach(__qt_imported_location_config + IMPORTED_LOCATION + IMPORTED_LOCATION_RELEASE + IMPORTED_LOCATION_RELWITHDEBINFO + IMPORTED_LOCATION_MINSIZEREL + IMPORTED_LOCATION_DEBUG) + + get_target_property(__qt_imported_location + Qt6::${__qt_tool} ${__qt_imported_location_config}) + if(__qt_imported_location AND EXISTS "${__qt_imported_location}") + break() + endif() + endforeach() + + set_target_properties(Qt::${__qt_tool} + PROPERTIES IMPORTED_LOCATION "${__qt_imported_location}") + endif() +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtNoLinkTargetHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtNoLinkTargetHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..968e33cf50f398468d0bd264fd48fd278752fc84 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtNoLinkTargetHelpers.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_create_nolink_target target dependee_target) + if(NOT TARGET "${target}") + message(FATAL_ERROR "${target} does not exist when trying to build a nolink target.") + endif() + get_target_property(type "${target}" TYPE) + if(type STREQUAL EXECUTABLE) + message(FATAL_ERROR "${target} must be a library of some kind.") + endif() + if(type STREQUAL OBJECT_LIBRARY) + message(FATAL_ERROR "${target} must not be an object library.") + endif() + + # Strip off the namespace prefix, so from Vulkan::Vulkan to Vulkan, and then append _nolink. + string(REGEX REPLACE "^.*::" "" non_prefixed_target ${target}) + set(nolink_target "${non_prefixed_target}_nolink") + + # Create the nolink interface target, assign the properties from the original target, + # associate the nolink target with the same export which contains + # the target that uses the _nolink target. + # Also create a namespaced alias of the form ${target}::${target}_nolink which is used by + # our modules. + # Also create a Qt namespaced alias target, because when exporting via install(EXPORT) + # Vulkan::Vulkan_nolink transforms into Qt6::Vulkan_nolink, and the latter needs to be an + # accessible alias for standalone tests. + if(NOT TARGET "${nolink_target}") + add_library("${nolink_target}" INTERFACE) + set(prefixed_nolink_target "${target}_nolink") + + # When configuring an example with qmake, if QtGui is built with Vulkan support but the + # user's machine where Qt is installed doesn't have Vulkan, qmake doesn't fail saying + # that vulkan is not installed. Instead it silently configures and just doesn't add + # the include headers. + # To mimic that in CMake, if the Vulkan CMake package is not found, we shouldn't fail + # at generation time saying that the Vulkan target does not exist. Instead check with a + # genex that the target exists to query the properties, otherwise just silently continue. + # FIXME: If we figure out that such behavior should only be applied to Vulkan, and not the + # other _nolink targets, we'll have to modify this to be configurable. + set(target_exists_genex "$") + set(props_to_set INTERFACE_INCLUDE_DIRECTORIES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES + INTERFACE_COMPILE_DEFINITIONS INTERFACE_COMPILE_OPTIONS + INTERFACE_COMPILE_FEATURES) + foreach(prop ${props_to_set}) + set_target_properties( + "${nolink_target}" PROPERTIES + ${prop} $<${target_exists_genex}:$> + ) + endforeach() + + add_library(${prefixed_nolink_target} ALIAS ${nolink_target}) + add_library("${INSTALL_CMAKE_NAMESPACE}::${nolink_target}" ALIAS ${nolink_target}) + + set(export_name "${INSTALL_CMAKE_NAMESPACE}${dependee_target}Targets") + qt_install(TARGETS ${nolink_target} EXPORT ${export_name}) + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPkgConfigHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPkgConfigHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..30a3ca771914e7df41290fabdea600e1087ed3e0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPkgConfigHelpers.cmake @@ -0,0 +1,164 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_internal_collect_direct_target_dependencies target targets_out_var) + __qt_internal_walk_libs("${target}" "${targets_out_var}" _rcc_objects + "qt_direct_targets_dict" "direct_targets") + set("${targets_out_var}" "${${targets_out_var}}" PARENT_SCOPE) +endfunction() + +macro(qt_internal_set_pkg_config_cpp_flags var options flag) + set(tmpopts "${options}") + list(FILTER tmpopts EXCLUDE REGEX "\\$]+>") + list(FILTER tmpopts EXCLUDE REGEX "\\$]+>") + list(TRANSFORM tmpopts REPLACE "\\$<\\$]+>:([^,>]+)>" "\\1") + list(TRANSFORM tmpopts REPLACE "\\$]+)>" "\\1") + list(TRANSFORM tmpopts REPLACE ">" "$") + list(TRANSFORM tmpopts REPLACE "," "$") + set(${var} "$<$:${flag}$, ${flag}>>") + unset(tmpopts) +endmacro() + +# Create a Qt6*.pc file intended for pkg-config consumption. +function(qt_internal_generate_pkg_config_file module) + # TODO: PkgConfig is supported under MSVC with pkgconf (github.com/pkgconf/pkgconf) + if((NOT UNIX OR QT_FEATURE_framework) + AND NOT MINGW OR CMAKE_VERSION VERSION_LESS "3.20" OR ANDROID) + return() + endif() + if(NOT BUILD_SHARED_LIBS) + return() + endif() + + set(pkgconfig_file "${QT_CMAKE_EXPORT_NAMESPACE}${module}") + set(pkgconfig_name "${QT_CMAKE_EXPORT_NAMESPACE} ${module}") + set(pkgconfig_description "Qt ${module} module") + set(target "${QT_CMAKE_EXPORT_NAMESPACE}::${module}") + set(is_interface_library "$,INTERFACE_LIBRARY>") + # The flags macro expanded this variables so it's better to set them at + # their corresponding PkgConfig string. + set(includedir "\${includedir}") + set(mkspecsdir "\${mkspecsdir}") + + get_target_property(is_internal_module ${target} _qt_is_internal_module) + if(is_internal_module) + return() + endif() + + get_target_property(loose_link_options ${target} INTERFACE_LINK_OPTIONS) + get_target_property(loose_compile_defs ${target} INTERFACE_COMPILE_DEFINITIONS) + get_target_property(loose_include_dirs ${target} INTERFACE_INCLUDE_DIRECTORIES) + list(TRANSFORM loose_include_dirs REPLACE "${INSTALL_INCLUDEDIR}" "\${includedir}") + list(TRANSFORM loose_include_dirs REPLACE "${INSTALL_MKSPECSDIR}" "\${mkspecsdir}") + + # Remove genex wrapping around gc_sections flag because we can't evaluate genexes like + # $ in file(GENERATE). And given that .pc files don't support dynamic + # evaluation like the $ genex, distros will be expected to patch the .pc + # files according to which compiler they intend to be used with. + get_property(gc_sections_with_genex GLOBAL PROPERTY _qt_internal_gc_sections_with_genex) + get_property(gc_sections_without_genex GLOBAL PROPERTY _qt_internal_gc_sections_without_genex) + if(loose_link_options AND gc_sections_with_genex AND gc_sections_without_genex) + string(REPLACE "${gc_sections_with_genex}" "${gc_sections_without_genex}" + loose_link_options "${loose_link_options}") + endif() + + qt_internal_set_pkg_config_cpp_flags(link_options "${loose_link_options}" "") + qt_internal_set_pkg_config_cpp_flags(compile_defs "${loose_compile_defs}" -D) + qt_internal_set_pkg_config_cpp_flags(include_dirs "${loose_include_dirs}" -I) + if("${include_dirs}" MATCHES "\\${mkspecsdir}") + set(contains_mkspecs TRUE) + endif() + + # TODO: Handle macOS framework builds + qt_internal_collect_direct_target_dependencies(${target} loose_target_requires) + foreach(dep IN LISTS loose_target_requires) + if(dep MATCHES "^Qt::") + string(REGEX REPLACE "Qt" "${QT_CMAKE_EXPORT_NAMESPACE}" dep ${dep}) + elseif(NOT dep MATCHES "^${QT_CMAKE_EXPORT_NAMESPACE}::") + # TODO: Figure out a way to get non-Qt requirements PkgConfig files. + continue() + endif() + if(NOT TARGET ${dep}) + continue() + endif() + get_target_property(is_internal_module ${dep} _qt_is_internal_module) + if(is_internal_module OR dep MATCHES ".*Platform.*Internal") + continue() + endif() + get_target_property(type ${dep} TYPE) + if(type STREQUAL "INTERFACE_LIBRARY") + if(dep MATCHES "(.*)Private") + set(dep "${CMAKE_MATCH_1}") + endif() + get_target_property(type ${dep} TYPE) + endif() + string(REGEX REPLACE "::" "" req ${dep}) + if(type STREQUAL "STATIC_LIBRARY") + list(APPEND target_libs -l${req}) + else() + list(APPEND target_requires ${req}) + endif() + endforeach() + string(APPEND link_options " $, >") + + qt_path_join(path_suffix "${INSTALL_LIBDIR}" pkgconfig) + qt_path_join(build_dir "${QT_BUILD_DIR}" "${path_suffix}") + qt_path_join(install_dir "${QT_INSTALL_DIR}" "${path_suffix}") + + set(step_prefix "preliminary_pc_for_${pkgconfig_file}") + qt_path_join(template_pc "${QT_CMAKE_DIR}" PkgConfigLibrary.pc.in) + qt_path_join(pc_step1_path "${build_dir}" ${step_prefix}_step1.pc) + qt_path_join(pc_step2_path "${build_dir}" ${step_prefix}_$_step2.pc) + + configure_file("${template_pc}" "${pc_step1_path}" @ONLY) + + file(GENERATE OUTPUT "${pc_step2_path}" INPUT "${pc_step1_path}") + + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + set(rels ${configs}) + list(FILTER rels INCLUDE REGEX "(Release|RelWithDebInfo|MinSizeRel)") + if(rels) + list(GET rels 0 release) + endif() + else() + set(configs ${CMAKE_BUILD_TYPE}) + set(release ${configs}) + endif() + + foreach(config ${configs}) + if(config STREQUAL "Debug" AND CMAKE_DEBUG_POSTFIX) + set(postfix ${CMAKE_DEBUG_POSTFIX}) + elseif(NOT config STREQUAL release) + string(TOLOWER "_${config}" postfix) + else() + set(postfix "") + endif() + + set(extra_args "") + if(NOT postfix STREQUAL "") + list(APPEND extra_args "-DPOSTFIX=${postfix}") + endif() + + qt_path_join(pc_step2_path "${build_dir}" ${step_prefix}_${config}_step2.pc) + qt_path_join(final_pc_path "${build_dir}" ${pkgconfig_file}${postfix}.pc) + + add_custom_command( + OUTPUT "${final_pc_path}" + DEPENDS "${pc_step2_path}" + "${QT_CMAKE_DIR}/QtFinishPkgConfigFile.cmake" + COMMAND ${CMAKE_COMMAND} + "-DIN_FILE=${pc_step2_path}" + "-DOUT_FILE=${final_pc_path}" + ${extra_args} + -P "${QT_CMAKE_DIR}/QtFinishPkgConfigFile.cmake" + VERBATIM + COMMENT "Generating pc file for target ${target}" + ) + + # This is inspired by https://gitlab.kitware.com/cmake/cmake/-/issues/20842 + target_sources(${module} PRIVATE "${final_pc_path}") + + qt_install(FILES "${final_pc_path}" DESTINATION "${install_dir}") + endforeach() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformAndroid.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformAndroid.cmake new file mode 100644 index 0000000000000000000000000000000000000000..360d37bac640c4f9324987e62c101040c4c3841d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformAndroid.cmake @@ -0,0 +1,207 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# +# Self contained Platform Settings for Android +# +# Note: This file is used by the internal builds. +# + +# +# Variables: +# QT_ANDROID_JAR +# Location of the adroid sdk jar for java code +# QT_ANDROID_API_VERSION +# Android API version +# + +if (NOT DEFINED ANDROID_SDK_ROOT) + message(FATAL_ERROR "Please provide the location of the Android SDK directory via -DANDROID_SDK_ROOT=") +endif() + +if (NOT IS_DIRECTORY "${ANDROID_SDK_ROOT}") + message(FATAL_ERROR "Could not find ANDROID_SDK_ROOT or path is not a directory: ${ANDROID_SDK_ROOT}") +endif() + +# Get the Android SDK jar for an API version other than the one specified with +# QT_ANDROID_API_VERSION. +function(qt_get_android_sdk_jar_for_api api out_jar_location) + set(jar_location "${ANDROID_SDK_ROOT}/platforms/${api}/android.jar") + if (NOT EXISTS "${jar_location}") + message(WARNING "Could not locate Android SDK jar for api '${api}', defaulting to ${QT_ANDROID_API_VERSION}") + set(${out_jar_location} ${QT_ANDROID_JAR} PARENT_SCOPE) + else() + set(${out_jar_location} ${jar_location} PARENT_SCOPE) + endif() +endfunction() + +# Minimum recommend android SDK api version +set(QT_ANDROID_API_VERSION "android-34") + +function(qt_internal_sort_android_platforms out_var) + if(CMAKE_VERSION GREATER_EQUAL 3.18) + set(platforms ${ARGN}) + list(SORT platforms COMPARE NATURAL) + else() + # Simulate natural sorting: + # - prepend every platform with its version as three digits, zero-padded + # - regular sort + # - remove the padded version prefix + set(platforms) + foreach(platform IN LISTS ARGN) + set(version "000") + if(platform MATCHES ".*-([0-9]+)$") + set(version ${CMAKE_MATCH_1}) + string(LENGTH "${version}" version_length) + math(EXPR padding_length "3 - ${version_length}") + string(REPEAT "0" ${padding_length} padding) + string(PREPEND version ${padding}) + endif() + list(APPEND platforms "${version}~${platform}") + endforeach() + list(SORT platforms) + list(TRANSFORM platforms REPLACE "^.*~" "") + endif() + set("${out_var}" "${platforms}" PARENT_SCOPE) +endfunction() + +macro(qt_internal_get_android_platform_version out_var android_platform) + string(REGEX REPLACE ".*-([0-9]+)$" "\\1" ${out_var} "${android_platform}") +endmacro() + +# Locate the highest available platform +file(GLOB android_platforms + LIST_DIRECTORIES true + RELATIVE "${ANDROID_SDK_ROOT}/platforms" + "${ANDROID_SDK_ROOT}/platforms/*") +# If list is not empty +if(android_platforms) + qt_internal_sort_android_platforms(android_platforms ${android_platforms}) + list(REVERSE android_platforms) + list(GET android_platforms 0 android_platform_latest) + + qt_internal_get_android_platform_version(latest_platform_version + "${android_platform_latest}") + qt_internal_get_android_platform_version(required_platform_version + "${QT_ANDROID_API_VERSION}") + + if("${latest_platform_version}" VERSION_GREATER "${required_platform_version}") + set(QT_ANDROID_API_VERSION ${android_platform_latest}) + endif() +endif() + +set(QT_ANDROID_JAR "${ANDROID_SDK_ROOT}/platforms/${QT_ANDROID_API_VERSION}/android.jar") +if(NOT EXISTS "${QT_ANDROID_JAR}") + message(FATAL_ERROR + "No suitable Android SDK platform found in '${ANDROID_SDK_ROOT}/platforms'." + " Minimum version is ${QT_ANDROID_API_VERSION}" + ) +endif() + +message(STATUS "Using Android SDK API ${QT_ANDROID_API_VERSION} from ${ANDROID_SDK_ROOT}/platforms") + +# Locate Java +include(UseJava) + +# Find JDK 8.0 +find_package(Java 1.8 COMPONENTS Development REQUIRED) + +# Ensure we are using the shared version of libc++ +if(NOT ANDROID_STL STREQUAL c++_shared) + message(FATAL_ERROR "The Qt libraries on Android only supports the shared library configuration of stl. Please use -DANDROID_STL=\"c++_shared\" as configuration argument.") +endif() + +# Target properties required for android deploy tool +define_property(TARGET + PROPERTY + QT_ANDROID_DEPLOYMENT_DEPENDENCIES + BRIEF_DOCS + "Specify additional plugins that need to be deployed with the current android application" + FULL_DOCS + "By default, androiddeployqt will detect the dependencies of your application. But since run-time usage of plugins cannot be detected, there could be false positives, as your application will depend on any plugins that are potential dependencies. If you want to minimize the size of your APK, it's possible to override the automatic detection using the ANDROID_DEPLOYMENT_DEPENDENCIES variable. This should contain a list of all Qt files which need to be included, with paths relative to the Qt install root. Note that only the Qt files specified here will be included. Failing to include the correct files can result in crashes. It's also important to make sure the files are listed in the correct loading order. This variable provides a way to override the automatic detection entirely, so if a library is listed before its dependencies, it will fail to load on some devices." +) + +define_property(TARGET + PROPERTY + QT_ANDROID_EXTRA_LIBS + BRIEF_DOCS + "A list of external libraries that will be copied into your application's library folder and loaded on start-up." + FULL_DOCS + "A list of external libraries that will be copied into your application's library folder and loaded on start-up. This can be used, for instance, to enable OpenSSL in your application. Simply set the paths to the required libssl.so and libcrypto.so libraries here and OpenSSL should be enabled automatically." +) + +define_property(TARGET + PROPERTY + QT_ANDROID_EXTRA_PLUGINS + BRIEF_DOCS + "This variable can be used to specify different resources that your project has to bundle but cannot be delivered through the assets system, such as qml plugins." + FULL_DOCS + "This variable can be used to specify different resources that your project has to bundle but cannot be delivered through the assets system, such as qml plugins. When using this variable, androiddeployqt will make sure everything is packaged and deployed properly." +) + +define_property(TARGET + PROPERTY + QT_ANDROID_PACKAGE_SOURCE_DIR + BRIEF_DOCS + "This variable can be used to specify a directory where additions and modifications can be made to the default Android package template." + FULL_DOCS + "This variable can be used to specify a directory where additions and modifications can be made to the default Android package template. The androiddeployqt tool will copy the application template from Qt into the build directory, and then it will copy the contents of the ANDROID_PACKAGE_SOURCE_DIR on top of this, overwriting any existing files. The update step where parts of the source files are modified automatically to reflect your other settings is then run on the resulting merged package. If you, for instance, want to make a custom AndroidManifest.xml for your application, then place this directly into the folder specified in this variable. You can also add custom Java files in ANDROID_PACKAGE_SOURCE_DIR/src." +) + +define_property(TARGET + PROPERTY + QT_ANDROID_APPLICATION_ARGUMENTS + BRIEF_DOCS + "This variable can be used to specify command-line arguments to the Android app." + FULL_DOCS + "Specifies extra command-line arguments to the Android app using the AndroidManifest.xml with the tag android.app.arguments." +) + +define_property(TARGET + PROPERTY + QT_ANDROID_DEPLOYMENT_SETTINGS_FILE + BRIEF_DOCS + "This variable is used to specify the deployment settings JSON file for androiddeployqt." + FULL_DOCS + "This variable points to the path of the deployment settings JSON file, which holds properties required by androiddeployqt to package the Android app." +) + +define_property(TARGET + PROPERTY + QT_ANDROID_SYSTEM_LIBS_PREFIX + BRIEF_DOCS + "This variable is used to specify a path to Qt libraries on the target device in Android." + FULL_DOCS + "This variable can be used to provide a custom system library path to use for library loading lookup on Android. This is necessary when using Qt libraries installed outside an app's default native (JNI) library directory." +) + +define_property(TARGET + PROPERTY + QT_ANDROID_NO_DEPLOY_QT_LIBS + BRIEF_DOCS + "This variable is used to control whether Qt libraries should be deployed inside the APK on Android." + FULL_DOCS + "This variable can be used to exclude Qt shared libraries from being packaged inside the APK when deploying on Android. Not supported when deploying as Android Application Bundle." +) + +# Returns test execution arguments for Android targets +function(qt_internal_android_test_runner_arguments target out_test_runner out_test_arguments) + set(${out_test_runner} "${QT_HOST_PATH}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}/androidtestrunner" PARENT_SCOPE) + set(deployment_tool "${QT_HOST_PATH}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}/androiddeployqt") + + get_target_property(deployment_file ${target} QT_ANDROID_DEPLOYMENT_SETTINGS_FILE) + if (NOT deployment_file) + message(FATAL_ERROR "Target ${target} is not a valid android executable target\n") + endif() + + qt_internal_android_get_target_android_build_dir(${target} android_build_dir) + set(${out_test_arguments} + "--path" "${android_build_dir}" + "--adb" "${ANDROID_SDK_ROOT}/platform-tools/adb" + "--skip-install-root" + "--make" "\"${CMAKE_COMMAND}\" --build ${CMAKE_BINARY_DIR} --target ${target}_make_apk" + "--apk" "${android_build_dir}/${target}.apk" + "--ndk-stack" "${ANDROID_NDK_ROOT}/ndk-stack" + PARENT_SCOPE + ) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformSupport.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformSupport.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a8c08e473b11e1b822948857614c97c2da96873e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformSupport.cmake @@ -0,0 +1,90 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_set01 result) + if (${ARGN}) + set("${result}" 1 PARENT_SCOPE) + else() + set("${result}" 0 PARENT_SCOPE) + endif() +endfunction() + +qt_set01(LINUX CMAKE_SYSTEM_NAME STREQUAL "Linux") +qt_set01(HPUX CMAKE_SYSTEM_NAME STREQUAL "HPUX") +qt_set01(ANDROID CMAKE_SYSTEM_NAME STREQUAL "Android") # FIXME: How to identify this? +qt_set01(INTEGRITY CMAKE_SYSTEM_NAME STREQUAL "Integrity") # FIXME: How to identify this? +qt_set01(VXWORKS CMAKE_SYSTEM_NAME STREQUAL "VxWorks") # FIXME: How to identify this? +qt_set01(QNX CMAKE_SYSTEM_NAME STREQUAL "QNX") # FIXME: How to identify this? +qt_set01(OPENBSD CMAKE_SYSTEM_NAME STREQUAL "OpenBSD") # FIXME: How to identify this? +qt_set01(FREEBSD CMAKE_SYSTEM_NAME STREQUAL "FreeBSD") # FIXME: How to identify this? +qt_set01(NETBSD CMAKE_SYSTEM_NAME STREQUAL "NetBSD") # FIXME: How to identify this? +qt_set01(WASM CMAKE_SYSTEM_NAME STREQUAL "Emscripten" OR EMSCRIPTEN) +qt_set01(WASM64 QT_QMAKE_TARGET_MKSPEC STREQUAL "wasm-emscripten-64") +qt_set01(SOLARIS CMAKE_SYSTEM_NAME STREQUAL "SunOS") +qt_set01(HURD CMAKE_SYSTEM_NAME STREQUAL "GNU") + +# This is the only reliable way we can determine the webOS platform as the yocto recipe adds this +# compile definition into its generated toolchain.cmake file +qt_set01(WEBOS CMAKE_CXX_FLAGS MATCHES "-D__WEBOS__") + +qt_set01(BSD APPLE OR OPENBSD OR FREEBSD OR NETBSD) + +qt_set01(IOS APPLE AND CMAKE_SYSTEM_NAME STREQUAL "iOS") +qt_set01(TVOS APPLE AND CMAKE_SYSTEM_NAME STREQUAL "tvOS") +qt_set01(WATCHOS APPLE AND CMAKE_SYSTEM_NAME STREQUAL "watchOS") +qt_set01(VISIONOS APPLE AND CMAKE_SYSTEM_NAME STREQUAL "visionOS") +qt_set01(UIKIT APPLE AND (IOS OR TVOS OR WATCHOS OR VISIONOS)) +qt_set01(MACOS APPLE AND NOT UIKIT) + +qt_set01(GCC CMAKE_CXX_COMPILER_ID STREQUAL "GNU") +qt_set01(CLANG CMAKE_CXX_COMPILER_ID MATCHES "Clang|IntelLLVM") +qt_set01(APPLECLANG CMAKE_CXX_COMPILER_ID MATCHES "AppleClang") +qt_set01(IntelLLVM CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM") +qt_set01(QCC CMAKE_CXX_COMPILER_ID STREQUAL "QCC") # CMP0047 + +if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(QT_64BIT TRUE) +elseif(CMAKE_SIZEOF_VOID_P EQUAL 4) + set(QT_32BIT TRUE) +endif() + +# Parses a version string like "xx.yy.zz" and sets the major, minor and patch variables. +function(qt_parse_version_string version_string out_var_prefix) + string(REPLACE "." ";" version_list ${version_string}) + list(LENGTH version_list length) + + set(out_var "${out_var_prefix}_MAJOR") + set(value "") + if(length GREATER 0) + list(GET version_list 0 value) + list(REMOVE_AT version_list 0) + math(EXPR length "${length}-1") + endif() + set(${out_var} "${value}" PARENT_SCOPE) + + set(out_var "${out_var_prefix}_MINOR") + set(value "") + if(length GREATER 0) + list(GET version_list 0 value) + set(${out_var} "${value}" PARENT_SCOPE) + list(REMOVE_AT version_list 0) + math(EXPR length "${length}-1") + endif() + set(${out_var} "${value}" PARENT_SCOPE) + + set(out_var "${out_var_prefix}_PATCH") + set(value "") + if(length GREATER 0) + list(GET version_list 0 value) + set(${out_var} "${value}" PARENT_SCOPE) + list(REMOVE_AT version_list 0) + math(EXPR length "${length}-1") + endif() + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +# Set up the separate version components for the compiler version, to allow mapping of qmake +# conditions like 'equals(QT_GCC_MAJOR_VERSION,5)'. +if(CMAKE_CXX_COMPILER_VERSION) + qt_parse_version_string("${CMAKE_CXX_COMPILER_VERSION}" "QT_COMPILER_VERSION") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformTargetHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformTargetHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8936a455aa71b35365bd2f9696db59c7ba97fb6f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlatformTargetHelpers.cmake @@ -0,0 +1,92 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Defines the public Qt::Platform target, which serves as a dependency for all internal Qt target +# as well as user projects consuming Qt. +function(qt_internal_setup_public_platform_target) + qt_internal_get_platform_definition_include_dir( + install_interface_definition_dir + build_interface_definition_dir + ) + + ## QtPlatform Target: + qt_internal_add_platform_target(Platform) + target_include_directories(Platform + INTERFACE + $ + $ + $ + $ + ) + target_compile_definitions(Platform INTERFACE ${QT_PLATFORM_DEFINITIONS}) + + set_target_properties(Platform PROPERTIES + _qt_package_version "${PROJECT_VERSION}" + ) + set_property(TARGET Platform + APPEND PROPERTY + EXPORT_PROPERTIES "_qt_package_version") + + # When building on android we need to link against the logging library + # in order to satisfy linker dependencies. Both of these libraries are part of + # the NDK. + if (ANDROID) + target_link_libraries(Platform INTERFACE log) + endif() + + if (QT_FEATURE_stdlib_libcpp) + target_compile_options(Platform INTERFACE "$<$:-stdlib=libc++>") + set(libc_link_option "-stdlib=libc++") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(libc_link_option "$<$:-stdlib=libc++>") + endif() + target_link_options(Platform INTERFACE "${libc_link_option}") + endif() + if (QT_FEATURE_no_direct_extern_access) + target_compile_options(Platform INTERFACE "$<$:-mno-direct-extern-access>") + target_compile_options(Platform INTERFACE "$<$:-fno-direct-access-external-data>") + endif() + + qt_set_msvc_cplusplus_options(Platform INTERFACE) + + # Propagate minimum C++ 17 via Platform to Qt consumers (apps), after the global features + # are computed. + qt_set_language_standards_interface_compile_features(Platform) + + # By default enable utf8 sources for both Qt and Qt consumers. Can be opted out. + qt_enable_utf8_sources(Platform) + + # By default enable unicode on WIN32 platforms for both Qt and Qt consumers. Can be opted out. + qt_internal_enable_unicode_defines(Platform) + + # Generate a pkgconfig for Qt::Platform. + qt_internal_generate_pkg_config_file(Platform) + + qt_internal_add_sbom(Platform + TYPE QT_MODULE + IMMEDIATE_FINALIZATION + ) +endfunction() + +function(qt_internal_get_platform_definition_include_dir install_interface build_interface) + # Used by consumers of prefix builds via INSTALL_INTERFACE (relative path). + set(${install_interface} "${INSTALL_MKSPECSDIR}/${QT_QMAKE_TARGET_MKSPEC}" PARENT_SCOPE) + + # Used by qtbase in prefix builds via BUILD_INTERFACE + set(build_interface_base_dir + "${CMAKE_CURRENT_LIST_DIR}/../mkspecs" + ) + + # Used by qtbase and consumers in non-prefix builds via BUILD_INTERFACE + if(NOT QT_WILL_INSTALL) + set(build_interface_base_dir + "${QT_BUILD_DIR}/${INSTALL_MKSPECSDIR}" + ) + endif() + + get_filename_component(build_interface_dir + "${build_interface_base_dir}/${QT_QMAKE_TARGET_MKSPEC}" + ABSOLUTE + ) + set(${build_interface} "${build_interface_dir}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginConfig.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginConfig.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..ce46210a9b696739d76aa2123e8f687994d98777 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginConfig.cmake.in @@ -0,0 +1,34 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "@PROJECT_NAME@" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + +@PACKAGE_INIT@ + +cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_version@) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Targets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@AdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginDependencies.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginDependencies.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..c9caf3529b5ecc21e27cf73a18ddd6da3e1f3526 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginDependencies.cmake.in @@ -0,0 +1,21 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +set(@target@_FOUND FALSE) + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_@target@_third_party_deps "@third_party_deps@") +_qt_internal_find_third_party_dependencies("@target@" __qt_@target@_third_party_deps) + +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_@target@_target_deps "@target_deps@") +set(__qt_@target@_find_dependency_paths "@find_dependency_paths@") +_qt_internal_find_qt_dependencies("@target@" __qt_@target@_target_deps + __qt_@target@_find_dependency_paths) + +set(@target@_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..756d171f19a5693f6441c593b60b02dc22c3eba4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPluginHelpers.cmake @@ -0,0 +1,639 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Note that these are only the keywords that are unique to qt_internal_add_plugin(). +# That function also supports the keywords defined by _qt_internal_get_add_plugin_keywords(). +macro(qt_internal_get_internal_add_plugin_keywords option_args single_args multi_args) + set(${option_args} + EXCEPTIONS + ALLOW_UNDEFINED_SYMBOLS + SKIP_INSTALL + NO_UNITY_BUILD + ${__qt_internal_sbom_optional_args} + ) + set(${single_args} + OUTPUT_DIRECTORY + INSTALL_DIRECTORY + ARCHIVE_INSTALL_DIRECTORY + ${__default_target_info_args} + ${__qt_internal_sbom_single_args} + ) + set(${multi_args} + ${__default_private_args} + ${__default_public_args} + ${__qt_internal_sbom_multi_args} + DEFAULT_IF + ) +endmacro() + +# This is the main entry point for defining Qt plugins. +# A CMake target is created with the given target. +# The target name should end with "Plugin" so static plugins are linked automatically. +# The PLUGIN_TYPE parameter is needed to place the plugin into the correct plugins/ sub-directory. +function(qt_internal_add_plugin target) + qt_internal_set_qt_known_plugins("${QT_KNOWN_PLUGINS}" "${target}") + + _qt_internal_get_add_plugin_keywords( + public_option_args + public_single_args + public_multi_args + ) + qt_internal_get_internal_add_plugin_keywords( + internal_option_args + internal_single_args + internal_multi_args + ) + set(option_args ${public_option_args} ${internal_option_args}) + set(single_args ${public_single_args} ${internal_single_args}) + set(multi_args ${public_multi_args} ${internal_multi_args}) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" + "${single_args}" + "${multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + # Put this behind a cache option for now. It's too noisy for general use + # until most repos are updated. + option(QT_WARN_PLUGIN_PUBLIC_KEYWORDS "Warn if a plugin specifies a PUBLIC keyword" ON) + if(QT_WARN_PLUGIN_PUBLIC_KEYWORDS) + foreach(publicKeyword IN LISTS __default_public_args) + if(NOT "${arg_${publicKeyword}}" STREQUAL "") + string(REPLACE "PUBLIC_" "" privateKeyword "${publicKeyword}") + message(AUTHOR_WARNING + "Plugins are not intended to be linked to. " + "They should not have any public properties, but ${target} " + "sets ${publicKeyword} to the following value:\n" + " ${arg_${publicKeyword}}\n" + "Update your project to use ${privateKeyword} instead.\n") + endif() + endforeach() + endif() + + qt_remove_args(plugin_args + ARGS_TO_REMOVE + ${internal_option_args} + ${internal_single_args} + ${internal_multi_args} + ALL_ARGS + ${option_args} + ${single_args} + ${multi_args} + ARGS + ${ARGN} + ) + + # When creating a static plugin, retrieve the plugin initializer target name, but don't + # automatically propagate the plugin initializer. + list(APPEND plugin_args + __QT_INTERNAL_NO_PROPAGATE_PLUGIN_INITIALIZER + OUTPUT_TARGETS plugin_init_target + ) + + qt6_add_plugin(${target} ${plugin_args}) + qt_internal_mark_as_internal_library(${target}) + + get_target_property(target_type "${target}" TYPE) + if(plugin_init_target AND TARGET "${plugin_init_target}") + qt_internal_add_target_aliases("${plugin_init_target}") + endif() + + set(plugin_type "") + # TODO: Transitional: Remove the TYPE option handling after all repos have been converted to use + # PLUGIN_TYPE. + if(arg_TYPE) + set(plugin_type "${arg_TYPE}") + elseif(arg_PLUGIN_TYPE) + set(plugin_type "${arg_PLUGIN_TYPE}") + endif() + + if((NOT plugin_type STREQUAL "qml_plugin") AND (NOT target MATCHES "(.*)Plugin$")) + message(AUTHOR_WARNING "The internal plugin target name '${target}' should end with the 'Plugin' suffix.") + endif() + + qt_get_sanitized_plugin_type("${plugin_type}" plugin_type_escaped) + + set(output_directory_default "${QT_BUILD_DIR}/${INSTALL_PLUGINSDIR}/${plugin_type}") + set(install_directory_default "${INSTALL_PLUGINSDIR}/${plugin_type}") + + qt_internal_check_directory_or_type(OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}" "${plugin_type}" + "${output_directory_default}" output_directory) + if (NOT arg_SKIP_INSTALL) + qt_internal_check_directory_or_type(INSTALL_DIRECTORY "${arg_INSTALL_DIRECTORY}" + "${plugin_type}" + "${install_directory_default}" install_directory) + set(archive_install_directory ${arg_ARCHIVE_INSTALL_DIRECTORY}) + if (NOT archive_install_directory AND install_directory) + set(archive_install_directory "${install_directory}") + endif() + endif() + + qt_set_target_info_properties(${target} ${ARGN}) + + set_target_properties(${target} PROPERTIES + _qt_package_version "${PROJECT_VERSION}" + ) + set_property(TARGET ${target} + APPEND PROPERTY + EXPORT_PROPERTIES "_qt_package_version") + + # Override the OUTPUT_NAME that qt6_add_plugin() set, we need to account for + # QT_LIBINFIX, which is specific to building Qt. + # Make sure the Qt6 plugin library names are like they were in Qt5 qmake land. + # Whereas the Qt6 CMake target names are like the Qt5 CMake target names. + get_target_property(output_name ${target} OUTPUT_NAME) + set_property(TARGET "${target}" PROPERTY OUTPUT_NAME "${output_name}${QT_LIBINFIX}") + + # Add a custom target with the Qt5 qmake name for a more user friendly ninja experience. + if(arg_OUTPUT_NAME AND NOT TARGET "${output_name}") + # But don't create such a target if it would just differ in case from "${target}" + # and we're not using Ninja. See https://gitlab.kitware.com/cmake/cmake/-/issues/21915 + string(TOUPPER "${output_name}" uc_output_name) + string(TOUPPER "${target}" uc_target) + if(NOT uc_output_name STREQUAL uc_target OR CMAKE_GENERATOR MATCHES "^Ninja") + add_custom_target("${output_name}") + add_dependencies("${output_name}" "${target}") + endif() + endif() + + qt_set_common_target_properties("${target}") + qt_internal_add_target_aliases("${target}") + qt_skip_warnings_are_errors_when_repo_unclean("${target}") + + set_target_properties("${target}" PROPERTIES + LIBRARY_OUTPUT_DIRECTORY "${output_directory}" + RUNTIME_OUTPUT_DIRECTORY "${output_directory}" + ARCHIVE_OUTPUT_DIRECTORY "${output_directory}" + QT_PLUGIN_TYPE "${plugin_type_escaped}" + # Save the non-sanitized plugin type values for qmake consumption via .pri files. + QT_QMAKE_PLUGIN_TYPE "${plugin_type}" + ) + + qt_handle_multi_config_output_dirs("${target}") + + qt_autogen_tools_initial_setup(${target}) + + unset(plugin_install_package_suffix) + + # The generic plugins should be enabled by default. + # But platform plugins should always be disabled by default, and only one is enabled + # based on the platform (condition specified in arg_DEFAULT_IF). + if(plugin_type_escaped STREQUAL "platforms") + set(_default_plugin 0) + else() + set(_default_plugin 1) + endif() + + if(DEFINED arg_DEFAULT_IF) + if(${arg_DEFAULT_IF}) + set(_default_plugin 1) + else() + set(_default_plugin 0) + endif() + endif() + + # Save the Qt module in the plug-in's properties and vice versa + if(NOT plugin_type_escaped STREQUAL "qml_plugin") + qt_internal_get_module_for_plugin("${target}" "${plugin_type_escaped}" qt_module) + + set(qt_module_target "${QT_CMAKE_EXPORT_NAMESPACE}::${qt_module}") + if(NOT TARGET "${qt_module_target}") + message(FATAL_ERROR "Failed to associate Qt plugin with Qt module. ${qt_module_target} is not a known CMake target") + endif() + + set_target_properties("${target}" PROPERTIES QT_MODULE "${qt_module}") + set(plugin_install_package_suffix "${qt_module}") + + + get_target_property(aliased_target ${qt_module_target} ALIASED_TARGET) + if(aliased_target) + set(qt_module_target ${aliased_target}) + endif() + get_target_property(is_imported_qt_module ${qt_module_target} IMPORTED) + + if(NOT is_imported_qt_module) + # This QT_PLUGINS assignment is only used by QtPostProcessHelpers to decide if a + # QtModulePlugins.cmake file should be generated. + set_property(TARGET "${qt_module_target}" APPEND PROPERTY QT_PLUGINS "${target}") + else() + # The _qt_plugins property is considered when collecting the plugins in + # deployment process. The usecase is following: + # QtModuleX is built separately and installed, so it's imported. + # The plugin is built in some application build tree and its PLUGIN_TYPE is associated + # with QtModuleX. + set_property(TARGET "${qt_module_target}" APPEND PROPERTY _qt_plugins "${target}") + endif() + + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + get_target_property(type "${plugin_target_versioned}" TYPE) + qt_internal_add_autogen_sync_header_dependencies(${target} ${qt_module_target}) + endif() + + # Change the configuration file install location for qml plugins into the Qml package location. + if(plugin_type_escaped STREQUAL "qml_plugin" AND TARGET "${INSTALL_CMAKE_NAMESPACE}::Qml") + set(plugin_install_package_suffix "Qml/QmlPlugins") + endif() + + # Save the install package suffix as a property, so that the Dependencies file is placed + # in the correct location. + if(plugin_install_package_suffix) + set_target_properties("${target}" PROPERTIES + _qt_plugin_install_package_suffix "${plugin_install_package_suffix}") + endif() + + if(TARGET qt_plugins) + add_dependencies(qt_plugins "${target}") + endif() + + # Record plugin for current repo. + if(qt_repo_plugins AND TARGET ${qt_repo_plugins}) + add_dependencies(${qt_repo_plugins} "${target}") + endif() + + if(plugin_type STREQUAL "platforms") + if(TARGET qpa_plugins) + add_dependencies(qpa_plugins "${target}") + endif() + + if(_default_plugin AND TARGET qpa_default_plugins) + add_dependencies(qpa_default_plugins "${target}") + endif() + endif() + + set_property(TARGET "${target}" PROPERTY QT_DEFAULT_PLUGIN "${_default_plugin}") + set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES "QT_PLUGIN_CLASS_NAME;QT_PLUGIN_TYPE;QT_MODULE;QT_DEFAULT_PLUGIN") + + set(private_includes + "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_BINARY_DIR}" + # For the syncqt headers + "$" + ${arg_INCLUDE_DIRECTORIES} + ) + + set(public_includes + ${arg_PUBLIC_INCLUDE_DIRECTORIES} + ) + + if(arg_NO_UNITY_BUILD) + set(arg_NO_UNITY_BUILD "NO_UNITY_BUILD") + else() + set(arg_NO_UNITY_BUILD "") + endif() + + qt_internal_extend_target("${target}" + ${arg_NO_UNITY_BUILD} + SOURCES ${arg_SOURCES} + NO_PCH_SOURCES + ${arg_NO_PCH_SOURCES} + NO_UNITY_BUILD_SOURCES + ${arg_NO_UNITY_BUILD_SOURCES} + INCLUDE_DIRECTORIES + ${private_includes} + SYSTEM_INCLUDE_DIRECTORIES + ${arg_SYSTEM_INCLUDE_DIRECTORIES} + PUBLIC_INCLUDE_DIRECTORIES + ${public_includes} + LIBRARIES ${arg_LIBRARIES} Qt::PlatformPluginInternal + PUBLIC_LIBRARIES ${arg_PUBLIC_LIBRARIES} + DEFINES + ${arg_DEFINES} + ${deprecation_define} + PUBLIC_DEFINES + ${arg_PUBLIC_DEFINES} + FEATURE_DEPENDENCIES ${arg_FEATURE_DEPENDENCIES} + DBUS_ADAPTOR_SOURCES ${arg_DBUS_ADAPTOR_SOURCES} + DBUS_ADAPTOR_FLAGS ${arg_DBUS_ADAPTOR_FLAGS} + DBUS_INTERFACE_SOURCES ${arg_DBUS_INTERFACE_SOURCES} + DBUS_INTERFACE_FLAGS ${arg_DBUS_INTERFACE_FLAGS} + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + PUBLIC_COMPILE_OPTIONS ${arg_PUBLIC_COMPILE_OPTIONS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + PUBLIC_LINK_OPTIONS ${arg_PUBLIC_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS} + ) + + qt_internal_add_repo_local_defines("${target}") + + qt_internal_set_exceptions_flags("${target}" ${arg_EXCEPTIONS}) + + + set(qt_libs_private "") + qt_internal_get_qt_all_known_modules(known_modules) + foreach(it ${known_modules}) + list(FIND arg_LIBRARIES "Qt::${it}Private" pos) + if(pos GREATER -1) + list(APPEND qt_libs_private "Qt::${it}Private") + endif() + endforeach() + + qt_register_target_dependencies("${target}" "${arg_PUBLIC_LIBRARIES}" "${qt_libs_private}") + + if(target_type STREQUAL STATIC_LIBRARY) + if(qt_module_target) + qt_internal_link_internal_platform_for_object_library("${plugin_init_target}") + endif() + endif() + + if (NOT arg_SKIP_INSTALL) + # Handle creation of cmake files for consumers of find_package(). + # If we are part of a Qt module, the plugin cmake files are installed as part of that + # module. + # For qml plugins, they are all installed into the QtQml package location for automatic + # discovery. + if(plugin_install_package_suffix) + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}${plugin_install_package_suffix}") + else() + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}${target}") + endif() + + qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${path_suffix}) + qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${path_suffix}) + + qt_internal_export_additional_targets_file( + TARGETS ${target} ${plugin_init_target} + EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target} + CONFIG_INSTALL_DIR "${config_install_dir}") + + qt_internal_get_min_new_policy_cmake_version(min_new_policy_version) + qt_internal_get_max_new_policy_cmake_version(max_new_policy_version) + configure_package_config_file( + "${QT_CMAKE_DIR}/QtPluginConfig.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake" + INSTALL_DESTINATION "${config_install_dir}" + ) + write_basic_package_version_file( + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion + ) + qt_internal_write_qt_package_version_file( + "${INSTALL_CMAKE_NAMESPACE}${target}" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersion.cmake" + ) + + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersion.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + + # Make the export name of plugins be consistent with modules, so that + # qt_add_resource adds its additional targets to the same export set in a static Qt build. + set(export_name "${INSTALL_CMAKE_NAMESPACE}${target}Targets") + qt_install(TARGETS + "${target}" + ${plugin_init_target} + EXPORT ${export_name} + RUNTIME DESTINATION "${install_directory}" + LIBRARY DESTINATION "${install_directory}" + OBJECTS DESTINATION "${install_directory}" + ARCHIVE DESTINATION "${archive_install_directory}" + ) + qt_install(EXPORT ${export_name} + NAMESPACE ${QT_CMAKE_EXPORT_NAMESPACE}:: + DESTINATION "${config_install_dir}" + ) + if(BUILD_SHARED_LIBS) + qt_apply_rpaths(TARGET "${target}" INSTALL_PATH "${install_directory}" RELATIVE_RPATH) + qt_internal_apply_staging_prefix_build_rpath_workaround() + endif() + endif() + + if (NOT arg_ALLOW_UNDEFINED_SYMBOLS) + ### fixme: cmake is missing a built-in variable for this. We want to apply it only to + # modules and plugins that belong to Qt. + qt_internal_add_link_flags_no_undefined("${target}") + endif() + + qt_internal_add_linker_version_script(${target}) + set(finalizer_extra_args "") + if(NOT arg_SKIP_INSTALL) + list(APPEND finalizer_extra_args INSTALL_PATH "${install_directory}") + endif() + + if(QT_GENERATE_SBOM) + set(sbom_args "") + list(APPEND sbom_args TYPE QT_PLUGIN) + + qt_get_cmake_configurations(configs) + foreach(config IN LISTS configs) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + INSTALL_PATH + "${install_directory}" + "${config}" + sbom_args + ) + endforeach() + + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + ${__qt_internal_sbom_optional_args} + FORWARD_SINGLE + ${__qt_internal_sbom_single_args} + FORWARD_MULTI + ${__qt_internal_sbom_multi_args} + ) + + _qt_internal_extend_sbom(${target} ${sbom_args}) + endif() + + qt_add_list_file_finalizer(qt_finalize_plugin ${target} ${finalizer_extra_args}) + + if(NOT arg_SKIP_INSTALL) + qt_enable_separate_debug_info(${target} "${install_directory}") + qt_internal_install_pdb_files(${target} "${install_directory}") + endif() +endfunction() + +function(qt_finalize_plugin target) + cmake_parse_arguments(arg "" "INSTALL_PATH" "" ${ARGN}) + if(WIN32 AND BUILD_SHARED_LIBS) + _qt_internal_generate_win32_rc_file("${target}") + endif() + + # Generate .prl and .pri files for static plugins. + get_target_property(target_type "${target}" TYPE) + if(target_type STREQUAL STATIC_LIBRARY) + if(arg_INSTALL_PATH) + qt_generate_prl_file(${target} "${arg_INSTALL_PATH}") + endif() + + # There's no point in generating pri files for qml plugins. + # We didn't do it in Qt5 times. + get_target_property(plugin_type "${target}" QT_PLUGIN_TYPE) + if(NOT plugin_type STREQUAL "qml_plugin") + qt_generate_plugin_pri_file("${target}") + endif() + endif() + + _qt_internal_finalize_sbom(${target}) +endfunction() + +function(qt_get_sanitized_plugin_type plugin_type out_var) + # Used to handle some edge cases such as platforms/darwin + string(REGEX REPLACE "[-/]" "_" plugin_type "${plugin_type}") + set("${out_var}" "${plugin_type}" PARENT_SCOPE) +endfunction() + +# Utility function to find the module to which a plug-in belongs. +function(qt_internal_get_module_for_plugin target target_type out_var) + qt_internal_get_qt_all_known_modules(known_modules) + + qt_get_sanitized_plugin_type("${target_type}" target_type) + foreach(qt_module ${known_modules}) + get_target_property(module_type "${QT_CMAKE_EXPORT_NAMESPACE}::${qt_module}" TYPE) + # Assuming interface libraries can't have plugins. Otherwise we'll need to fix the property + # name, because the current one would be invalid for interface libraries. + if(module_type STREQUAL "INTERFACE_LIBRARY") + continue() + endif() + + get_target_property(plugin_types + "${QT_CMAKE_EXPORT_NAMESPACE}::${qt_module}" + MODULE_PLUGIN_TYPES) + if(plugin_types AND target_type IN_LIST plugin_types) + set("${out_var}" "${qt_module}" PARENT_SCOPE) + return() + endif() + endforeach() + message(FATAL_ERROR "The plug-in '${target}' does not belong to any Qt module.") +endfunction() + +function(qt_internal_add_darwin_permission_plugin permission) + string(TOLOWER "${permission}" permission_lower) + string(TOUPPER "${permission}" permission_upper) + set(permission_source_file "platform/darwin/qdarwinpermissionplugin_${permission_lower}.mm") + set(plugin_target "QDarwin${permission}PermissionPlugin") + set(plugin_name "qdarwin${permission_lower}permission") + qt_internal_add_plugin(${plugin_target} + STATIC # Force static, even in shared builds + OUTPUT_NAME ${plugin_name} + PLUGIN_TYPE permissions + DEFAULT_IF FALSE + SOURCES + ${permission_source_file} + DEFINES + QT_DARWIN_PERMISSION_PLUGIN=${permission} + LIBRARIES + Qt::Core + Qt::CorePrivate + ${FWFoundation} + NO_UNITY_BUILD # disable unity build: the same file is built with two different preprocessor defines. + ) + + # Disable PCH since CMake falls over on single .mm source targets + set_target_properties(${plugin_target} PROPERTIES + DISABLE_PRECOMPILE_HEADERS ON + ) + + # Generate plugin JSON file + set(content "{ \"Permissions\": [ \"Q${permission}Permission\" ] }") + get_target_property(plugin_build_dir "${plugin_target}" BINARY_DIR) + set(output_file "${plugin_build_dir}/${plugin_target}.json") + qt_configure_file(OUTPUT "${output_file}" CONTENT "${content}") + + # Associate required usage descriptions + set(usage_descriptions_property "_qt_info_plist_usage_descriptions") + set_target_properties(${plugin_target} PROPERTIES + ${usage_descriptions_property} "NS${permission}UsageDescription" + ) + set_property(TARGET ${plugin_target} APPEND PROPERTY + EXPORT_PROPERTIES ${usage_descriptions_property} + ) + set(usage_descriptions_genex "$, >") + set(extra_plugin_pri_content + "QT_PLUGIN.${plugin_name}.usage_descriptions = ${usage_descriptions_genex}" + ) + + # Support granular check and request implementations + set(separate_request_source_file + "${plugin_build_dir}/qdarwinpermissionplugin_${permission_lower}_request.mm") + set(separate_request_genex + "$>") + file(GENERATE OUTPUT "${separate_request_source_file}" CONTENT + " + #define BUILDING_PERMISSION_REQUEST 1 + #include \"${CMAKE_CURRENT_SOURCE_DIR}/${permission_source_file}\" + " + CONDITION "${separate_request_genex}" + ) + if(CMAKE_VERSION VERSION_LESS "3.18") + set_property(SOURCE "${separate_request_source_file}" PROPERTY GENERATED TRUE) + set_property(SOURCE "${separate_request_source_file}" PROPERTY SKIP_UNITY_BUILD_INCLUSION TRUE) + endif() + target_sources(${plugin_target} PRIVATE + "$<${separate_request_genex}:${separate_request_source_file}>" + ) + + set_property(TARGET ${plugin_target} APPEND PROPERTY + EXPORT_PROPERTIES _qt_darwin_permissison_separate_request + ) + set(permission_request_symbol "_QDarwin${permission}PermissionRequest") + set(permission_request_flag "-Wl,-u,${permission_request_symbol}") + set(has_usage_description_property "_qt_has_${plugin_target}_usage_description") + set(has_usage_description_genex "$>") + target_link_options(${plugin_target} INTERFACE + "$<$:${permission_request_flag}>") + list(APPEND extra_plugin_pri_content + "QT_PLUGIN.${plugin_name}.request_flag = $<${separate_request_genex}:${permission_request_flag}>" + ) + + # Expose properties to qmake + set_property(TARGET ${plugin_target} PROPERTY + QT_PLUGIN_PRI_EXTRA_CONTENT ${extra_plugin_pri_content} + ) +endfunction() + +# The function looks and links the static plugins that the target depends on. The function behaves +# similar to qt_import_plugins, but should be used when building Qt executable or shared libraries. +# It's expected that all dependencies are valid targets at the time when the function is called. +# If not their plugins will be not collected for linking. +function(qt_internal_import_plugins target) + set(plugin_targets "") + foreach(dep_target IN LISTS ARGN) + if(dep_target AND TARGET ${dep_target}) + get_target_property(plugins ${dep_target} _qt_plugins) + if(plugins) + list(APPEND plugin_targets ${plugins}) + else() + # Fallback should be remove in Qt 7. + get_target_property(target_type ${dep_target} TYPE) + if(NOT "${target_type}" STREQUAL "INTERFACE_LIBRARY") + get_target_property(plugins ${dep_target} QT_PLUGINS) + if(plugins) + list(APPEND plugin_targets ${plugins}) + endif() + endif() + endif() + endif() + endforeach() + + set(non_imported_plugin_targets "") + foreach(plugin_target IN LISTS plugin_targets) + if(NOT TARGET ${plugin_target} OR "${plugin_target}" IN_LIST non_imported_plugin_targets) + continue() + endif() + + get_target_property(is_imported ${plugin_target} IMPORTED) + if(NOT is_imported) + list(APPEND non_imported_plugin_targets "${plugin_target}") + endif() + endforeach() + + if(plugin_targets) + __qt_internal_collect_plugin_init_libraries("${non_imported_plugin_targets}" init_libraries) + __qt_internal_collect_plugin_libraries("${non_imported_plugin_targets}" plugin_libraries) + if(plugin_libraries OR init_libraries) + target_link_libraries(${target} PRIVATE ${plugin_libraries} ${init_libraries}) + endif() + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlugins.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlugins.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..9223bc6ceb8e2d34630ffd55282db7227927faa4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPlugins.cmake.in @@ -0,0 +1,14 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) +@QT_MODULE_PLUGIN_INCLUDES@ + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_PLUGIN_INCLUSION OFF) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION) + __qt_internal_include_plugin_packages(@QT_MODULE@) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPostProcess.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPostProcess.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4dd6269dff7f6a2a3085cd55f6d13dd259410228 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPostProcess.cmake @@ -0,0 +1,17 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +qt_internal_create_depends_files() +qt_generate_build_internals_extra_cmake_code() +qt_internal_create_plugins_auto_inclusion_files() +qt_internal_create_config_file_for_standalone_tests() + +# Needs to run after qt_internal_create_depends_files. +qt_create_tools_config_files() + +if (ANDROID) + qt_modules_process_android_dependencies() +endif() + +qt_internal_install_prl_files() +qt_internal_generate_user_facing_tools_info() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPostProcessHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPostProcessHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8ed25829ec84a82e6820ab1c1610687e69259377 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPostProcessHelpers.cmake @@ -0,0 +1,946 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_internal_write_depends_file target) + get_target_property(module_depends_header ${target} _qt_module_depends_header) + set(outfile "${module_depends_header}") + set(contents "/* This file was generated by cmake with the info from ${target} target. */\n") + string(APPEND contents "#ifdef __cplusplus /* create empty PCH in C mode */\n") + foreach (m ${ARGN}) + string(APPEND contents "# include <${m}/${m}>\n") + endforeach() + string(APPEND contents "#endif\n") + + file(GENERATE OUTPUT "${outfile}" CONTENT "${contents}") +endfunction() + +macro(qt_collect_third_party_deps target) + set(_target_is_static OFF) + get_target_property(_target_type ${target} TYPE) + if (${_target_type} STREQUAL "STATIC_LIBRARY") + set(_target_is_static ON) + endif() + unset(_target_type) + # If we are doing a non-static Qt build, we only want to propagate public dependencies. + # If we are doing a static Qt build, we need to propagate all dependencies. + set(depends_var "public_depends") + if(_target_is_static) + set(depends_var "depends") + endif() + unset(_target_is_static) + + foreach(dep ${${depends_var}} ${optional_public_depends} ${extra_third_party_deps}) + # Gather third party packages that should be found when using the Qt module. + # Also handle nolink target dependencies. + string(REGEX REPLACE "_nolink$" "" base_dep "${dep}") + if(NOT base_dep STREQUAL dep) + # Resets target name like Vulkan_nolink to Vulkan, because we need to call + # find_package(Vulkan). + set(dep ${base_dep}) + endif() + + # Strip any directory scope tokens. + __qt_internal_strip_target_directory_scope_token("${dep}" dep) + if(TARGET ${dep}) + list(FIND third_party_deps_seen ${dep} dep_seen) + + get_target_property(package_name ${dep} INTERFACE_QT_PACKAGE_NAME) + if(dep_seen EQUAL -1 AND package_name) + list(APPEND third_party_deps_seen ${dep}) + get_target_property(package_is_optional ${dep} INTERFACE_QT_PACKAGE_IS_OPTIONAL) + if(NOT package_is_optional AND dep IN_LIST optional_public_depends) + set(package_is_optional TRUE) + endif() + get_target_property(package_version ${dep} INTERFACE_QT_PACKAGE_VERSION) + if(NOT package_version) + set(package_version "") + endif() + + get_target_property(package_components ${dep} INTERFACE_QT_PACKAGE_COMPONENTS) + if(NOT package_components) + set(package_components "") + endif() + + get_target_property(package_optional_components ${dep} + INTERFACE_QT_PACKAGE_OPTIONAL_COMPONENTS) + if(NOT package_optional_components) + set(package_optional_components "") + endif() + + get_target_property(package_components_id ${dep} _qt_package_components_id) + if(package_components_id) + list(APPEND third_party_deps_package_components_ids ${package_components_id}) + endif() + + list(APPEND third_party_deps + "${package_name}\;${package_is_optional}\;${package_version}\;${package_components}\;${package_optional_components}") + endif() + endif() + endforeach() +endmacro() + +# Collect provided targets for the given list of package component ids. +# +# ${target} is merely used as a key infix to avoid name clashes in the Dependencies.cmake files. +# package_component_ids is a list of '${package_name}-${components}-${optional_components}' keys +# that are sanitized not to contain spaces or semicolons. +# +# The output is a list of variable assignments to add to the dependencies file. +# Each variable assignment is the list of provided targets for a given package component id. +# +# We use these extra assignments instead of adding the info to the existing 'third_party_deps' list +# to make the information more readable. That list already has 5 items per package, making it +# quite hard to read. +function(qt_internal_collect_third_party_dep_packages_info + target + package_components_ids + out_packages_info) + + # There might be multiple calls to find the same package, so remove the duplicates. + list(REMOVE_DUPLICATES package_components_ids) + + set(packages_info "") + + foreach(package_key IN LISTS package_components_ids) + get_cmake_property(provided_targets _qt_find_package_${package_key}_provided_targets) + if(provided_targets) + set(key "__qt_${target}_third_party_package_${package_key}_provided_targets") + string(APPEND packages_info "set(${key} \"${provided_targets}\")\n") + endif() + endforeach() + + set(${out_packages_info} "${packages_info}" PARENT_SCOPE) +endfunction() + +# Filter the dependency targets to collect unique set of the dependencies. +# non-Private and Private targets are treated as the single object in this context +# since they are defined by the same CMake package. For internal modules +# the CMake package will be always Private. +function(qt_internal_remove_qt_dependency_duplicates out_deps deps) + set(${out_deps} "") + foreach(dep ${deps}) + if(dep) + list(FIND ${out_deps} "${dep}" dep_seen) + + if(dep_seen EQUAL -1) + list(LENGTH dep len) + if(NOT (len EQUAL 2)) + message(FATAL_ERROR "List '${dep}' should look like QtFoo;version") + endif() + list(GET dep 0 dep_name) + list(GET dep 1 dep_ver) + + # Skip over Qt6 dependency, because we will manually handle it in the Dependencies + # file before everything else, to ensure that find_package(Qt6Core)-style works. + if(dep_name STREQUAL "${INSTALL_CMAKE_NAMESPACE}") + continue() + endif() + list(APPEND ${out_deps} "${dep_name}\;${dep_ver}") + endif() + endif() + endforeach() + set(${out_deps} "${${out_deps}}" PARENT_SCOPE) +endfunction() + +function(qt_internal_create_module_depends_file target) + get_target_property(target_type "${target}" TYPE) + set(is_interface_lib FALSE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + set(is_interface_lib TRUE) + endif() + + set(depends "") + if(target_type STREQUAL "STATIC_LIBRARY") + get_target_property(depends "${target}" LINK_LIBRARIES) + endif() + + get_target_property(public_depends "${target}" INTERFACE_LINK_LIBRARIES) + + unset(optional_public_depends) + if(TARGET "${target}Private") + get_target_property(optional_public_depends "${target}Private" INTERFACE_LINK_LIBRARIES) + endif() + + # Used for collecting Qt module dependencies that should be find_package()'d in + # ModuleDependencies.cmake. + get_target_property(target_deps "${target}" _qt_target_deps) + set(target_deps_seen "") + set(qt_module_dependencies "") + + if(NOT is_interface_lib) + get_target_property(extra_depends "${target}" QT_EXTRA_PACKAGE_DEPENDENCIES) + endif() + if(NOT extra_depends MATCHES "-NOTFOUND$") + list(APPEND target_deps "${extra_depends}") + endif() + + # Extra 3rd party targets who's packages should be considered dependencies. + get_target_property(extra_third_party_deps "${target}" _qt_extra_third_party_dep_targets) + if(NOT extra_third_party_deps) + set(extra_third_party_deps "") + endif() + + # Used for assembling the content of an include/Module/ModuleDepends.h header. + set(qtdeps "") + + # Used for collecting third party dependencies that should be find_package()'d in + # ModuleDependencies.cmake. + set(third_party_deps "") + set(third_party_deps_seen "") + set(third_party_deps_package_components_ids "") + + # Used for collecting Qt tool dependencies that should be find_package()'d in + # ModuleToolsDependencies.cmake. + set(tool_deps "") + set(tool_deps_seen "") + + # Used for collecting Qt tool dependencies that should be find_package()'d in + # ModuleDependencies.cmake. + set(main_module_tool_deps "") + + # Extra QtFooModuleTools packages to be added as dependencies to + # QtModuleDependencies.cmake. Needed for QtWaylandCompositor / QtWaylandClient. + if(NOT is_interface_lib) + get_target_property(extra_tools_package_dependencies "${target}" + QT_EXTRA_TOOLS_PACKAGE_DEPENDENCIES) + if(extra_tools_package_dependencies) + list(APPEND main_module_tool_deps "${extra_tools_package_dependencies}") + endif() + endif() + + qt_internal_get_qt_all_known_modules(known_modules) + + set(all_depends ${depends} ${public_depends}) + foreach (dep ${all_depends}) + # Normalize module by stripping leading "Qt::" and trailing "Private" + if (dep MATCHES "(Qt|${QT_CMAKE_EXPORT_NAMESPACE})::([-_A-Za-z0-9]+)") + set(dep "${CMAKE_MATCH_2}") + set(real_dep_target "Qt::${dep}") + + if(TARGET "${real_dep_target}") + get_target_property(is_versionless_target "${real_dep_target}" + _qt_is_versionless_target) + if(is_versionless_target) + set(real_dep_target "${QT_CMAKE_EXPORT_NAMESPACE}::${dep}") + endif() + + get_target_property(skip_module_depends_include "${real_dep_target}" + _qt_module_skip_depends_include) + if(skip_module_depends_include) + continue() + endif() + + get_target_property(module_has_headers "${real_dep_target}" + _qt_module_has_headers) + if(NOT module_has_headers) + continue() + endif() + endif() + endif() + + list(FIND known_modules "${dep}" _pos) + if (_pos GREATER -1) + qt_internal_module_info(module ${QT_CMAKE_EXPORT_NAMESPACE}::${dep}) + list(APPEND qtdeps ${module}) + + # Make the ModuleTool package depend on dep's ModuleTool package. + list(FIND tool_deps_seen ${dep} dep_seen) + if(dep_seen EQUAL -1 AND ${dep} IN_LIST QT_KNOWN_MODULES_WITH_TOOLS) + qt_internal_get_package_version_of_target("${dep}" dep_package_version) + list(APPEND tool_deps_seen ${dep}) + list(APPEND tool_deps + "${INSTALL_CMAKE_NAMESPACE}${dep}Tools\;${dep_package_version}") + endif() + endif() + endforeach() + + qt_collect_third_party_deps(${target}) + qt_internal_collect_third_party_dep_packages_info(${target} + "${third_party_deps_package_components_ids}" + packages_info) + + set(third_party_deps_extra_info "") + if(packages_info) + string(APPEND third_party_deps_extra_info "${packages_info}") + endif() + + # Add dependency to the main ModuleTool package to ModuleDependencies file. + if(${target} IN_LIST QT_KNOWN_MODULES_WITH_TOOLS) + qt_internal_get_package_version_of_target("${target}" main_module_tool_package_version) + list(APPEND main_module_tool_deps + "${INSTALL_CMAKE_NAMESPACE}${target}Tools\;${main_module_tool_package_version}") + endif() + + foreach(dep ${target_deps}) + if(NOT dep MATCHES ".+Private$" AND + dep MATCHES "${INSTALL_CMAKE_NAMESPACE}(.+)") + # target_deps contains elements that are a pair of target name and version, + # e.g. 'Core\;6.2' + # After the extracting from the target_deps list, the element becomes a list itself, + # because it loses escape symbol before the semicolon, so ${CMAKE_MATCH_1} is the list: + # Core;6.2. + # We need to store only the target name in the qt_module_dependencies variable. + list(GET CMAKE_MATCH_1 0 dep_name) + if(dep_name) + list(APPEND qt_module_dependencies "${dep_name}") + endif() + endif() + endforeach() + list(REMOVE_DUPLICATES qt_module_dependencies) + + qt_internal_remove_qt_dependency_duplicates(target_deps "${target_deps}") + + + if (DEFINED qtdeps) + list(REMOVE_DUPLICATES qtdeps) + endif() + + get_target_property(hasModuleHeaders "${target}" _qt_module_has_headers) + if (${hasModuleHeaders}) + qt_internal_write_depends_file(${target} ${qtdeps}) + endif() + + if(third_party_deps OR main_module_tool_deps OR target_deps) + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}${target}") + qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${path_suffix}) + qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${path_suffix}) + + # All module packages should look for the Qt6 package version that qtbase was originally + # built as. + qt_internal_get_package_version_of_target(Platform main_qt_package_version) + + # Configure and install ModuleDependencies file. + configure_file( + "${QT_CMAKE_DIR}/QtModuleDependencies.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Dependencies.cmake" + @ONLY + ) + + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Dependencies.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + + message(TRACE "Recorded dependencies for module: ${target}\n" + " Qt dependencies: ${target_deps}\n" + " 3rd-party dependencies: ${third_party_deps}") + endif() + if(tool_deps) + # The value of the property will be used by qt_export_tools. + set_property(TARGET "${target}" PROPERTY _qt_tools_package_deps "${tool_deps}") + endif() +endfunction() + +function(qt_internal_create_plugin_depends_file target) + get_target_property(plugin_install_package_suffix "${target}" _qt_plugin_install_package_suffix) + get_target_property(depends "${target}" LINK_LIBRARIES) + get_target_property(public_depends "${target}" INTERFACE_LINK_LIBRARIES) + get_target_property(target_deps "${target}" _qt_target_deps) + unset(optional_public_depends) + set(target_deps_seen "") + + + # Extra 3rd party targets who's packages should be considered dependencies. + get_target_property(extra_third_party_deps "${target}" _qt_extra_third_party_dep_targets) + if(NOT extra_third_party_deps) + set(extra_third_party_deps "") + endif() + + qt_collect_third_party_deps(${target}) + + qt_internal_remove_qt_dependency_duplicates(target_deps "${target_deps}") + + if(third_party_deps OR target_deps) + # Setup build and install paths + + # Plugins should look for their dependencies in their associated module package folder as + # well as the Qt6 package folder which is stored by the Qt6 package in _qt_cmake_dir. + set(find_dependency_paths "\${CMAKE_CURRENT_LIST_DIR}/..;\${_qt_cmake_dir}") + if(plugin_install_package_suffix) + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}${plugin_install_package_suffix}") + if(plugin_install_package_suffix MATCHES "/QmlPlugins") + # Qml plugins are one folder deeper. + set(find_dependency_paths "\${CMAKE_CURRENT_LIST_DIR}/../..;\${_qt_cmake_dir}") + endif() + + else() + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}${target}") + endif() + + qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${path_suffix}) + qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${path_suffix}) + + # Configure and install ModuleDependencies file. + configure_file( + "${QT_CMAKE_DIR}/QtPluginDependencies.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Dependencies.cmake" + @ONLY + ) + + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Dependencies.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + + message(TRACE "Recorded dependencies for plugin: ${target}\n" + " Qt dependencies: ${target_deps}\n" + " 3rd-party dependencies: ${third_party_deps}") + endif() +endfunction() + +function(qt_internal_create_qt6_dependencies_file) + # This is used for substitution in the configured file. + set(target "${INSTALL_CMAKE_NAMESPACE}") + + # This is the actual target we're querying. + set(actual_target Platform) + get_target_property(public_depends "${actual_target}" INTERFACE_LINK_LIBRARIES) + unset(depends) + unset(optional_public_depends) + + set(third_party_deps "") + set(third_party_deps_seen "") + set(third_party_deps_package_components_ids "") + + # We need to collect third party deps that are set on the public Platform target, + # like Threads::Threads. + # This mimics find_package part of the CONFIG += thread assignment in mkspecs/features/qt.prf. + qt_collect_third_party_deps(${actual_target}) + qt_internal_collect_third_party_dep_packages_info("${INSTALL_CMAKE_NAMESPACE}" + "${third_party_deps_package_components_ids}" + packages_info) + + set(third_party_deps_extra_info "") + if(packages_info) + string(APPEND third_party_deps_extra_info "${packages_info}") + endif() + + # For Threads we also need to write an extra variable assignment. + set(third_party_extra "") + if(third_party_deps MATCHES "Threads") + string(APPEND third_party_extra "if(NOT QT_NO_THREADS_PREFER_PTHREAD_FLAG) + set(THREADS_PREFER_PTHREAD_FLAG TRUE) +endif()") + endif() + + _qt_internal_determine_if_host_info_package_needed(platform_requires_host_info_package) + + if(platform_requires_host_info_package) + # TODO: Figure out how to make the initial QT_HOST_PATH var relocatable in relation + # to the target CMAKE_INSTALL_DIR, if at all possible to do so in a reliable way. + get_filename_component(qt_host_path_absolute "${QT_HOST_PATH}" ABSOLUTE) + get_filename_component(qt_host_path_cmake_dir_absolute + "${Qt${PROJECT_VERSION_MAJOR}HostInfo_DIR}/.." ABSOLUTE) + endif() + + if(third_party_deps OR platform_requires_host_info_package) + # Setup build and install paths. + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}") + + qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${path_suffix}) + qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${path_suffix}) + + # Configure and install QtDependencies file. + configure_file( + "${QT_CMAKE_DIR}/QtConfigDependencies.cmake.in" + "${config_build_dir}/${target}Dependencies.cmake" + @ONLY + ) + + qt_install(FILES + "${config_build_dir}/${target}Dependencies.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + endif() +endfunction() + +# Create Depends.cmake & Depends.h files for all modules and plug-ins. +function(qt_internal_create_depends_files) + qt_internal_get_qt_repo_known_modules(repo_known_modules) + + if(PROJECT_NAME STREQUAL "QtBase") + qt_internal_create_qt6_dependencies_file() + endif() + + foreach (target ${repo_known_modules}) + qt_internal_create_module_depends_file(${target}) + endforeach() + + foreach (target ${QT_KNOWN_PLUGINS}) + qt_internal_create_plugin_depends_file(${target}) + endforeach() +endfunction() + +# This function creates QtPlugins.cmake files used to include all +# the plugin Config files that belong to that module. +function(qt_internal_create_plugins_auto_inclusion_files) + # For static library builds, the plugin targets need to be available for linking. + # For shared library builds, the plugin targets are useful for deployment purposes. + qt_internal_get_qt_repo_known_modules(repo_known_modules) + + set(modules_with_plugins "") + foreach (QT_MODULE ${repo_known_modules}) + get_target_property(target_type "${QT_MODULE}" TYPE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + # No plugins are provided by a header only module. + continue() + endif() + qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${INSTALL_CMAKE_NAMESPACE}${QT_MODULE}) + qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${INSTALL_CMAKE_NAMESPACE}${QT_MODULE}) + set(QT_MODULE_PLUGIN_INCLUDES "") + + if(QT_MODULE STREQUAL "Qml") + set(QT_MODULE_PLUGIN_INCLUDES "${QT_MODULE_PLUGIN_INCLUDES} +# Qml plugin targets might have dependencies on other qml plugin targets, but the Targets.cmake +# files are included in the order that file(GLOB) returns, which means certain targets that are +# referenced might not have been created yet, and \${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE +# might be set to a message saying those targets don't exist. +# +# Postpone checking of which targets don't exist until all Qml PluginConfig.cmake files have been +# included, by including all the files one more time and checking for errors at each step. +# +# TODO: Find a better way to deal with this, perhaps by using find_package() instead of include +# for the Qml PluginConfig.cmake files. + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_QML_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_QML_PLUGIN_INCLUSION OFF) +endif() + +set(__qt_qml_plugins_config_file_list \"\") +set(__qt_qml_plugins_glob_prefixes \"\${CMAKE_CURRENT_LIST_DIR}\") + +# Allow passing additional prefixes where we will glob for PluginConfig.cmake files. +if(QT_ADDITIONAL_QML_PLUGIN_GLOB_PREFIXES) + foreach(__qt_qml_plugin_glob_prefix IN LISTS QT_ADDITIONAL_QML_PLUGIN_GLOB_PREFIXES) + if(__qt_qml_plugin_glob_prefix) + list(APPEND __qt_qml_plugins_glob_prefixes \"\${__qt_qml_plugin_glob_prefix}\") + endif() + endforeach() +endif() + +list(REMOVE_DUPLICATES __qt_qml_plugins_glob_prefixes) + +foreach(__qt_qml_plugin_glob_prefix IN LISTS __qt_qml_plugins_glob_prefixes) + file(GLOB __qt_qml_plugins_glob_config_file_list + \"\${__qt_qml_plugin_glob_prefix}/QmlPlugins/${INSTALL_CMAKE_NAMESPACE}*Config.cmake\") + if(__qt_qml_plugins_glob_config_file_list) + list(APPEND __qt_qml_plugins_config_file_list \${__qt_qml_plugins_glob_config_file_list}) + endif() +endforeach() + +if (__qt_qml_plugins_config_file_list AND NOT QT_SKIP_AUTO_QML_PLUGIN_INCLUSION) + # First round of inclusions ensure all qml plugin targets are brought into scope. + foreach(__qt_qml_plugin_config_file \${__qt_qml_plugins_config_file_list}) + include(\${__qt_qml_plugin_config_file}) + + # Temporarily unset any failure markers and mark the Qml package as found. + unset(\${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) + set(\${CMAKE_FIND_PACKAGE_NAME}_FOUND TRUE) + endforeach() + + # For the second round of inclusions, check and bail out early if there are errors. + foreach(__qt_qml_plugin_config_file \${__qt_qml_plugins_config_file_list}) + include(\${__qt_qml_plugin_config_file}) + + if(\${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) + string(APPEND \${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE + \"\nThe message was set in \${__qt_qml_plugin_config_file} \") + set(\${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + return() + endif() + endforeach() + +endif()") + endif() + + get_target_property(module_plugin_types "${QT_MODULE}" MODULE_PLUGIN_TYPES) + if(module_plugin_types OR QT_MODULE_PLUGIN_INCLUDES) + list(APPEND modules_with_plugins "${QT_MODULE}") + configure_file( + "${QT_CMAKE_DIR}/QtPlugins.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${QT_MODULE}Plugins.cmake" + @ONLY + ) + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${QT_MODULE}Plugins.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + endif() + endforeach() + if(modules_with_plugins) + message(STATUS "Generated QtModulePlugins.cmake files for the following modules:" + " ${modules_with_plugins}") + endif() +endfunction() + +function(qt_generate_install_prefixes out_var) + set(content "\n") + set(vars INSTALL_BINDIR INSTALL_INCLUDEDIR INSTALL_LIBDIR INSTALL_MKSPECSDIR INSTALL_ARCHDATADIR + INSTALL_PLUGINSDIR INSTALL_LIBEXECDIR INSTALL_QMLDIR INSTALL_DATADIR INSTALL_DOCDIR + INSTALL_TRANSLATIONSDIR INSTALL_SYSCONFDIR INSTALL_EXAMPLESDIR INSTALL_TESTSDIR + INSTALL_DESCRIPTIONSDIR INSTALL_SBOMDIR) + + foreach(var ${vars}) + get_property(docstring CACHE "${var}" PROPERTY HELPSTRING) + string(APPEND content "set(${var} \"${${var}}\" CACHE STRING \"${docstring}\" FORCE)\n") + endforeach() + + set(${out_var} "${content}" PARENT_SCOPE) +endfunction() + +function(qt_wrap_string_in_if_multi_config content out_var) + set(${out_var} " +get_property(__qt_is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +if(__qt_is_multi_config) +${content}endif() +unset(__qt_is_multi_config)\n" PARENT_SCOPE) +endfunction() + +function(qt_wrap_string_in_if_ninja_multi_config content out_var) + set(${out_var} "if(CMAKE_GENERATOR STREQUAL \"Ninja Multi-Config\") +${content}endif()\n" PARENT_SCOPE) +endfunction() + +function(qt_create_hostinfo_package) + set(package "${INSTALL_CMAKE_NAMESPACE}HostInfo") + qt_path_join(config_file_path "${QT_CONFIG_BUILD_DIR}/${package}/${package}Config.cmake") + qt_path_join(install_destination ${QT_CONFIG_INSTALL_DIR} ${package}) + set(var_prefix "QT${PROJECT_VERSION_MAJOR}_HOST_INFO_") + configure_package_config_file( + "${CMAKE_CURRENT_LIST_DIR}/QtHostInfoConfig.cmake.in" + "${config_file_path}" + INSTALL_DESTINATION "${install_destination}" + NO_SET_AND_CHECK_MACRO + NO_CHECK_REQUIRED_COMPONENTS_MACRO) + qt_install(FILES "${config_file_path}" DESTINATION "${install_destination}") +endfunction() + +function(qt_generate_build_internals_extra_cmake_code) + if(PROJECT_NAME STREQUAL "QtBase") + qt_create_hostinfo_package() + + foreach(var IN LISTS QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS "set(${var} \"${${var}}\" CACHE INTERNAL \"\")\n") + endforeach() + + set(QT_SOURCE_TREE "${QtBase_SOURCE_DIR}") + qt_path_join(extra_file_path + ${QT_CONFIG_BUILD_DIR} + ${INSTALL_CMAKE_NAMESPACE}BuildInternals/QtBuildInternalsExtra.cmake) + + if(CMAKE_BUILD_TYPE) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + " +# Used by qt_internal_set_cmake_build_type. +set(__qt_internal_initial_qt_cmake_build_type \"${CMAKE_BUILD_TYPE}\") +") + endif() + if(CMAKE_CONFIGURATION_TYPES) + string(APPEND multi_config_specific + " set(CMAKE_CONFIGURATION_TYPES \"${CMAKE_CONFIGURATION_TYPES}\" CACHE STRING \"\" FORCE)\n") + endif() + if(CMAKE_TRY_COMPILE_CONFIGURATION) + string(APPEND multi_config_specific + " set(CMAKE_TRY_COMPILE_CONFIGURATION \"${CMAKE_TRY_COMPILE_CONFIGURATION}\")\n") + endif() + if(multi_config_specific) + qt_wrap_string_in_if_multi_config( + "${multi_config_specific}" + multi_config_specific) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS "${multi_config_specific}") + endif() + + if(QT_MULTI_CONFIG_FIRST_CONFIG) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "\nset(QT_MULTI_CONFIG_FIRST_CONFIG \"${QT_MULTI_CONFIG_FIRST_CONFIG}\")\n") + endif() + + if(CMAKE_CROSS_CONFIGS) + string(APPEND ninja_multi_config_specific + " set(CMAKE_CROSS_CONFIGS \"${CMAKE_CROSS_CONFIGS}\" CACHE STRING \"\")\n") + endif() + if(CMAKE_DEFAULT_BUILD_TYPE) + string(APPEND ninja_multi_config_specific + " set(CMAKE_DEFAULT_BUILD_TYPE \"${CMAKE_DEFAULT_BUILD_TYPE}\" CACHE STRING \"\")\n") + endif() + if(CMAKE_DEFAULT_CONFIGS) + string(APPEND ninja_multi_config_specific + " set(CMAKE_DEFAULT_CONFIGS \"${CMAKE_DEFAULT_CONFIGS}\" CACHE STRING \"\")\n") + endif() + if(ninja_multi_config_specific) + qt_wrap_string_in_if_ninja_multi_config( + "${ninja_multi_config_specific}" + ninja_multi_config_specific) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS "${ninja_multi_config_specific}") + endif() + + if(DEFINED BUILD_WITH_PCH) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(BUILD_WITH_PCH \"${BUILD_WITH_PCH}\" CACHE STRING \"\")\n") + endif() + + if(DEFINED QT_IS_MACOS_UNIVERSAL) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_IS_MACOS_UNIVERSAL \"${QT_IS_MACOS_UNIVERSAL}\" CACHE BOOL \"\")\n") + endif() + + if(DEFINED QT_APPLE_SDK) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_APPLE_SDK \"${QT_APPLE_SDK}\" CACHE BOOL \"\")\n") + endif() + + if(QT_FORCE_FIND_TOOLS) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_FORCE_FIND_TOOLS \"TRUE\" CACHE BOOL \"\" FORCE)\n") + endif() + + if(QT_FORCE_BUILD_TOOLS) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_FORCE_BUILD_TOOLS \"TRUE\" CACHE BOOL \"\" FORCE)\n") + endif() + + if(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX) + file(TO_CMAKE_PATH + "${QT_INTERNAL_EXAMPLES_INSTALL_PREFIX}" examples_install_prefix) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX \"${examples_install_prefix}\" CACHE STRING \"\")\n") + endif() + + # Save the default qpa platform. + if(DEFINED QT_QPA_DEFAULT_PLATFORM) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_QPA_DEFAULT_PLATFORM \"${QT_QPA_DEFAULT_PLATFORM}\" CACHE STRING \"\")\n") + endif() + + # Save the list of default qpa platforms. + # Used by qtwayland/src/plugins/platforms/qwayland-generic/CMakeLists.txt. Otherwise + # the DEFAULT_IF condition is evaluated incorrectly. + if(DEFINED QT_QPA_PLATFORMS) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_QPA_PLATFORMS \"${QT_QPA_PLATFORMS}\" CACHE STRING \"\")\n") + endif() + + # Save minimum and policy-related CMake versions to ensure the same minimum is + # checked for when building other downstream repos (qtsvg, etc) and the policy settings + # will be consistent unless the downstream repos explicitly override them. + # Policy settings can be overridden per-repo, but the minimum CMake version is global for all of + # Qt. + qt_internal_get_supported_min_cmake_version_for_building_qt( + supported_min_version_for_building_qt) + qt_internal_get_computed_min_cmake_version_for_building_qt( + computed_min_version_for_building_qt) + qt_internal_get_min_new_policy_cmake_version(min_new_policy_version) + qt_internal_get_max_new_policy_cmake_version(max_new_policy_version) + + # Rpath related things that need to be re-used when building other repos. + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(CMAKE_INSTALL_RPATH \"${CMAKE_INSTALL_RPATH}\" CACHE STRING \"\")\n") + if(DEFINED QT_DISABLE_RPATH) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_DISABLE_RPATH \"${QT_DISABLE_RPATH}\" CACHE STRING \"\")\n") + endif() + if(DEFINED QT_EXTRA_DEFINES) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_EXTRA_DEFINES \"${QT_EXTRA_DEFINES}\" CACHE STRING \"\")\n") + endif() + if(DEFINED QT_EXTRA_INCLUDEPATHS) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_EXTRA_INCLUDEPATHS \"${QT_EXTRA_INCLUDEPATHS}\" CACHE STRING \"\")\n") + endif() + if(DEFINED QT_EXTRA_FRAMEWORKPATHS) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_EXTRA_FRAMEWORKPATHS \"${QT_EXTRA_FRAMEWORKPATHS}\" CACHE STRING \"\")\n") + endif() + if(DEFINED QT_EXTRA_LIBDIRS) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_EXTRA_LIBDIRS \"${QT_EXTRA_LIBDIRS}\" CACHE STRING \"\")\n") + endif() + if(DEFINED QT_EXTRA_RPATHS) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_EXTRA_RPATHS \"${QT_EXTRA_RPATHS}\" CACHE STRING \"\")\n") + endif() + if(DEFINED QT_DISABLE_DEPRECATED_UP_TO) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(QT_DISABLE_DEPRECATED_UP_TO \"${QT_DISABLE_DEPRECATED_UP_TO}\"" + " CACHE STRING \"\")\n") + endif() + + # Save pkg-config feature value to be able to query it internally as soon as BuildInternals + # package is loaded. This is to avoid any pkg-config package from being found when + # find_package(Qt6Core) is called in case if the feature was disabled. + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS " +if(NOT QT_SKIP_BUILD_INTERNALS_PKG_CONFIG_FEATURE) + set(FEATURE_pkg_config \"${FEATURE_pkg_config}\" CACHE BOOL \"Using pkg-config\" FORCE) +endif()\n") + + # The OpenSSL root dir needs to be saved so that repos other than qtbase (like qtopcua) can + # still successfully find_package(WrapOpenSSL) in the CI. + # qmake saves any additional include paths passed via the configure like '-I/foo' + # in mkspecs/qmodule.pri, so this file is the closest equivalent. + if(DEFINED OPENSSL_ROOT_DIR) + file(TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" openssl_root_cmake_path) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + "set(OPENSSL_ROOT_DIR \"${openssl_root_cmake_path}\" CACHE STRING \"\")\n") + endif() + + qt_generate_install_prefixes(install_prefix_content) + + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS "${install_prefix_content}") + + if(DEFINED OpenGL_GL_PREFERENCE) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + " +# Use the OpenGL_GL_PREFERENCE value qtbase was built with. But do not FORCE it. +set(OpenGL_GL_PREFERENCE \"${OpenGL_GL_PREFERENCE}\" CACHE STRING \"\") +") + endif() + + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS + " +set(QT_COPYRIGHT \"${QT_COPYRIGHT}\" CACHE STRING \"\") +") + + # Add the apple version requirements to the BuildInternals extra code, so the info is + # available when configuring a standalone test. + # Otherwise when QtSetup is included after a + # find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) + # call, Qt6ConfigExtras.cmake is not included yet, the requirements are not available and + # _qt_internal_check_apple_sdk_and_xcode_versions() would fail. + _qt_internal_export_apple_sdk_and_xcode_version_requirements(apple_requirements) + if(apple_requirements) + string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS " +${apple_requirements} +") + endif() + + qt_compute_relative_path_from_cmake_config_dir_to_prefix() + configure_file( + "${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake.in" + "${extra_file_path}" + @ONLY + ) + endif() +endfunction() + +# For every Qt module check if there any android dependencies that require +# processing. +function(qt_modules_process_android_dependencies) + qt_internal_get_qt_repo_known_modules(repo_known_modules) + foreach (target ${repo_known_modules}) + qt_internal_android_dependencies(${target}) + endforeach() +endfunction() + +function(qt_create_tools_config_files) + # Create packages like Qt6CoreTools/Qt6CoreToolsConfig.cmake. + foreach(module_name ${QT_KNOWN_MODULES_WITH_TOOLS}) + qt_export_tools("${module_name}") + endforeach() +endfunction() + +function(qt_internal_create_config_file_for_standalone_tests) + set(standalone_tests_config_dir "StandaloneTests") + qt_path_join(config_build_dir + ${QT_CONFIG_BUILD_DIR} + "${INSTALL_CMAKE_NAMESPACE}BuildInternals" "${standalone_tests_config_dir}") + qt_path_join(config_install_dir + ${QT_CONFIG_INSTALL_DIR} + "${INSTALL_CMAKE_NAMESPACE}BuildInternals" "${standalone_tests_config_dir}") + + # Filter out bundled system libraries. Otherwise when looking for their dependencies + # (like PNG for Freetype) FindWrapPNG is searched for during configuration of + # standalone tests, and it can happen that Core or Gui features are not + # imported early enough, which means FindWrapPNG will try to find a system PNG library instead + # of the bundled one. + set(modules) + foreach(m ${QT_REPO_KNOWN_MODULES}) + get_target_property(target_type "${m}" TYPE) + + # Interface libraries are never bundled system libraries (hopefully). + if(target_type STREQUAL "INTERFACE_LIBRARY") + list(APPEND modules "${m}") + continue() + endif() + + get_target_property(is_3rd_party "${m}" _qt_module_is_3rdparty_library) + if(NOT is_3rd_party) + list(APPEND modules "${m}") + endif() + endforeach() + + list(JOIN modules " " QT_REPO_KNOWN_MODULES_STRING) + string(STRIP "${QT_REPO_KNOWN_MODULES_STRING}" QT_REPO_KNOWN_MODULES_STRING) + + # Skip generating and installing file if no modules were built. This make sure not to install + # anything when build qtx11extras on macOS for example. + if(NOT QT_REPO_KNOWN_MODULES_STRING) + return() + endif() + + # Create a Config file that calls find_package on the modules that were built as part + # of the current repo. This is used for standalone tests. + qt_internal_get_standalone_parts_config_file_name(tests_config_file_name) + + # Standalone tests Config files should follow the main versioning scheme. + qt_internal_get_package_version_of_target(Platform main_qt_package_version) + + configure_file( + "${QT_CMAKE_DIR}/QtStandaloneTestsConfig.cmake.in" + "${config_build_dir}/${tests_config_file_name}" + @ONLY + ) + qt_install(FILES + "${config_build_dir}/${tests_config_file_name}" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) +endfunction() + +function(qt_internal_install_prl_files) + # Get locations relative to QT_BUILD_DIR from which prl files should be installed. + get_property(prl_install_dirs GLOBAL PROPERTY QT_PRL_INSTALL_DIRS) + + # Clear the list of install dirs so the previous values don't pollute the list of install dirs + # for the next repository in a top-level build. + set_property(GLOBAL PROPERTY QT_PRL_INSTALL_DIRS "") + + foreach(prl_install_dir ${prl_install_dirs}) + qt_install(DIRECTORY "${QT_BUILD_DIR}/${prl_install_dir}/" + DESTINATION ${prl_install_dir} + FILES_MATCHING PATTERN "*.prl" + ) + endforeach() +endfunction() + +function(qt_internal_generate_user_facing_tools_info) + if("${INSTALL_PUBLICBINDIR}" STREQUAL "") + return() + endif() + get_property(user_facing_tool_targets GLOBAL PROPERTY QT_USER_FACING_TOOL_TARGETS) + set(lines "") + foreach(target ${user_facing_tool_targets}) + get_target_property(filename ${target} OUTPUT_NAME) + if(NOT filename) + set(filename ${target}) + endif() + set(linkname ${filename}) + if(APPLE) + get_target_property(is_macos_bundle ${target} MACOSX_BUNDLE ) + if(is_macos_bundle) + set(filename "${filename}.app/Contents/MacOS/${filename}") + endif() + endif() + qt_path_join(tool_target_path "${CMAKE_INSTALL_PREFIX}" "${INSTALL_BINDIR}" "${filename}") + qt_path_join(tool_link_path "${INSTALL_PUBLICBINDIR}" "${linkname}${PROJECT_VERSION_MAJOR}") + list(APPEND lines "${tool_target_path} ${tool_link_path}") + endforeach() + string(REPLACE ";" "\n" content "${lines}") + string(APPEND content "\n") + set(out_file "${PROJECT_BINARY_DIR}/user_facing_tool_links.txt") + file(WRITE "${out_file}" "${content}") +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPrecompiledHeadersHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPrecompiledHeadersHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..33dc08ce8ce8616b76263f78a4a09243052b8f09 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPrecompiledHeadersHelpers.cmake @@ -0,0 +1,34 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_update_precompiled_header target precompiled_header) + if (precompiled_header AND BUILD_WITH_PCH) + set_property(TARGET "${target}" APPEND PROPERTY "PRECOMPILE_HEADERS" "$<$,$>:${precompiled_header}>") + endif() +endfunction() + +function(qt_update_precompiled_header_with_library target library) + if (TARGET "${library}") + get_target_property(TARGET_TYPE "${library}" TYPE) + if (NOT TARGET_TYPE STREQUAL "INTERFACE_LIBRARY") + get_target_property(HEADER "${library}" MODULE_HEADER) + qt_update_precompiled_header("${target}" "${HEADER}") + endif() + endif() +endfunction() + +function(qt_update_ignore_pch_source target sources) + if (sources) + set_source_files_properties(${sources} PROPERTIES + SKIP_PRECOMPILE_HEADERS ON + SKIP_UNITY_BUILD_INCLUSION ON) + endif() +endfunction() + +function(qt_ignore_pch_obj_c_sources target sources) + # No obj-cxx PCH support for versions lower than 3.16. + if(CMAKE_VERSION VERSION_LESS 3.16.0) + list(FILTER sources INCLUDE REGEX "\\.mm$") + qt_update_ignore_pch_source("${target}" "${sources}") + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPriHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPriHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8752c867598eec426b164819fc922fa68cf98725 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPriHelpers.cmake @@ -0,0 +1,1080 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Extracts the 3rdparty libraries for the module ${module_name} +# and stores the information in cmake language in +# ${output_root_dir}/$/${output_file_name}. +# +# This function "follows" INTERFACE_LIBRARY targets to "real" targets +# and collects defines, include dirs and lib dirs on the way. +function(qt_generate_qmake_libraries_pri_content module_name output_root_dir output_file_name) + set(content "") + + # Set up a regular expression that matches all implicit include dirs + set(implicit_include_dirs_regex "") + foreach(dir ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES}) + qt_re_escape(regex "${dir}") + list(APPEND implicit_include_dirs_regex "^${regex}$") + endforeach() + list(JOIN implicit_include_dirs_regex "|" implicit_include_dirs_regex) + + foreach(lib ${QT_QMAKE_LIBS_FOR_${module_name}}) + set(lib_targets ${QT_TARGETS_OF_QMAKE_LIB_${lib}}) + string(TOUPPER ${lib} uclib) + string(REPLACE "-" "_" uclib "${uclib}") + set(lib_defines "") + set(lib_incdir "") + set(lib_libdir "") + set(lib_libs "") + set(seen_targets "") + while(lib_targets) + list(POP_BACK lib_targets lib_target) + if(TARGET ${lib_target}) + if(${lib_target} IN_LIST seen_targets) + continue() + endif() + list(APPEND seen_targets ${lib_target}) + get_target_property(lib_target_type ${lib_target} TYPE) + if(lib_target_type MATCHES "^(INTERFACE|UNKNOWN)_LIBRARY") + get_target_property(iface_libs ${lib_target} INTERFACE_LINK_LIBRARIES) + if(iface_libs) + list(PREPEND lib_targets ${iface_libs}) + endif() + endif() + if(NOT lib_target_type STREQUAL "INTERFACE_LIBRARY") + list(APPEND lib_libs "$") + endif() + list(APPEND lib_libdir "$") + + get_target_property(skip_include_dir "${lib_target}" _qt_skip_include_dir_for_pri) + if(skip_include_dir) + set(target_include_dir "") + else() + set(target_include_dir + "$") + endif() + + list(APPEND lib_incdir "${target_include_dir}") + list(APPEND lib_defines "$") + else() + # Strip any directory scope tokens. + __qt_internal_strip_target_directory_scope_token("${lib_target}" lib_target) + + # Skip CMAKE_DIRECTORY_ID_SEP. If a target_link_libraries is applied to a target + # that was defined in a different scope, CMake appends and prepends a special + # directory id separator. Filter those out. + if(lib_target MATCHES "^::@") + continue() + + elseif(lib_target MATCHES "^\\$$") + # Extract value of LINK_ONLY genex, because it can't be used in file(GENERATE) + set(lib_target "${CMAKE_MATCH_1}") + if(lib_target) + list(PREPEND lib_targets ${lib_target}) + endif() + else() + # Regular library name, library path, or -lfoo-like flag. Check for emptiness. + if(lib_target) + list(APPEND lib_libs "${lib_target}") + endif() + endif() + endif() + endwhile() + + # Wrap in $ but not the libs, because + # we would have to preserve the right order for the linker. + foreach(sfx libdir incdir defines) + string(PREPEND lib_${sfx} "$") + endforeach() + + # Filter out implicit include directories + if(implicit_include_dirs_regex) + string(PREPEND lib_incdir "$") + endif() + + set(uccfg $>) + string(APPEND content "list(APPEND known_libs ${uclib}) +set(QMAKE_LIBS_${uclib}_${uccfg} \"${lib_libs}\") +set(QMAKE_LIBDIR_${uclib}_${uccfg} \"${lib_libdir}\") +set(QMAKE_INCDIR_${uclib}_${uccfg} \"${lib_incdir}\") +set(QMAKE_DEFINES_${uclib}_${uccfg} \"${lib_defines}\") +") + if(QT_QMAKE_LIB_DEPS_${lib}) + string(APPEND content "set(QMAKE_DEPENDS_${uclib}_CC, ${deps}) +set(QMAKE_DEPENDS_${uclib}_LD, ${deps}) +") + endif() + endforeach() + + file(GENERATE + OUTPUT "${output_root_dir}/$/${output_file_name}" + CONTENT "${content}" + ) +endfunction() + +# Retrieves the public Qt module dependencies of the given Qt module or Qt Private module. +# The returned dependencies are "config module names", not target names. +# +# PRIVATE (OPTIONAL): +# Retrieve private dependencies only. Dependencies that appear in both, LINK_LIBRARIES and +# INTERFACE_LINK_LIBRARIES are discarded. +# +function(qt_get_direct_module_dependencies target out_var) + cmake_parse_arguments(arg "PRIVATE" "" "" ${ARGN}) + set(dependencies "") + get_target_property(target_type ${target} TYPE) + if(arg_PRIVATE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + set(libs) + else() + get_target_property(libs ${target} LINK_LIBRARIES) + list(REMOVE_DUPLICATES libs) + endif() + get_target_property(public_libs ${target} INTERFACE_LINK_LIBRARIES) + list(REMOVE_DUPLICATES public_libs) + + # Remove all Qt::Foo and Qt6::Foo from libs that also appear in public_libs. + set(libs_to_remove "") + foreach(lib IN LISTS public_libs) + list(APPEND libs_to_remove "${lib}") + if(lib MATCHES "^Qt::(.*)") + list(APPEND libs_to_remove "${QT_CMAKE_EXPORT_NAMESPACE}::${CMAKE_MATCH_1}") + elseif(lib MATCHES "^{QT_CMAKE_EXPORT_NAMESPACE}::(.*)") + list(APPEND libs_to_remove "Qt::${CMAKE_MATCH_1}") + endif() + endforeach() + + list(REMOVE_DUPLICATES libs_to_remove) + list(REMOVE_ITEM libs ${libs_to_remove}) + else() + get_target_property(libs ${target} INTERFACE_LINK_LIBRARIES) + endif() + if(NOT libs) + set(libs "") + endif() + while(libs) + list(POP_FRONT libs lib) + string(GENEX_STRIP "${lib}" lib) + if(NOT lib OR NOT TARGET "${lib}") + continue() + endif() + get_target_property(lib_type ${lib} TYPE) + get_target_property(aliased_target ${lib} ALIASED_TARGET) + if(TARGET "${aliased_target}") + # If versionless target is alias, use what the alias points to. + list(PREPEND libs "${aliased_target}") + continue() + endif() + if(lib_type STREQUAL "OBJECT_LIBRARY") + # Skip object libraries, because they're already part of ${target}. + continue() + elseif(lib_type STREQUAL "STATIC_LIBRARY" AND target_type STREQUAL "SHARED_LIBRARY") + # Skip static libraries if ${target} is a shared library. + continue() + endif() + get_target_property(lib_config_module_name ${lib} "_qt_config_module_name") + if(lib_config_module_name) + list(APPEND dependencies ${lib_config_module_name}) + endif() + endwhile() + set(${out_var} ${dependencies} PARENT_SCOPE) +endfunction() + +# Return a list of qmake library names for a given list of targets. +# For example, Foo::Foo_nolink is mapped to foo/nolink. +# Also targets with the _qt_is_nolink_target property are mapped to nolink as well. +function(qt_internal_map_targets_to_qmake_libs out_var) + set(result "") + foreach(target ${ARGN}) + # Unwrap optional targets. Needed for Vulkan. + if(target MATCHES "^\\$$") + set(target ${CMAKE_MATCH_1}) + endif() + + set(is_no_link_target FALSE) + + # First case of detecting nolink targets (possibly not needed anymore) + string(REGEX REPLACE "_nolink$" "" stripped_target "${target}") + if(NOT target STREQUAL stripped_target) + set(is_no_link_target TRUE) + endif() + + # Second case of detecting nolink targets. + if(TARGET "${target}") + get_target_property(marked_as_no_link_target "${target}" _qt_is_nolink_target) + if(marked_as_no_link_target) + set(is_no_link_target TRUE) + endif() + endif() + + qt_internal_map_target_to_qmake_lib(${stripped_target} qmake_lib) + if(NOT "${qmake_lib}" STREQUAL "") + if(is_no_link_target) + string(APPEND qmake_lib "/nolink") + endif() + list(APPEND result "${qmake_lib}") + endif() + endforeach() + set(${out_var} "${result}" PARENT_SCOPE) +endfunction() + +# Retrieve the runtime dependencies of module ${target}. +# The runtime dependencies are what in CMake is called IMPORTED_LINK_DEPENDENT_LIBRARIES. +# This function returns the dependencies in out_var, separated by space. +# +# PUBLIC_DEPENDENCIES: +# List of the module's public dependencies. +# The dependencies are expected to be config module names. +# +# PUBLIC (OPTIONAL): +# Specifies that target is a public module. +# If not specified, a private module is assumed. +# +function(qt_internal_get_module_run_dependencies out_var target) + cmake_parse_arguments(arg "PUBLIC" "" "PUBLIC_DEPENDENCIES" ${ARGN}) + + # Private dependencies of the module are runtime dependencies. + qt_get_direct_module_dependencies(${target} run_dependencies PRIVATE) + + # If ${target} is a public module then public dependencies + # of the private module are also runtime dependencies. + if(arg_PUBLIC AND TARGET ${target}Private) + qt_get_direct_module_dependencies(${target}Private qt_for_private) + + # FooPrivate depends on Foo, but we must not record this dependency in run_depends. + get_target_property(config_module_name ${target} _qt_config_module_name) + list(REMOVE_ITEM qt_for_private ${config_module_name}) + + list(APPEND run_dependencies ${qt_for_private}) + endif() + + list(REMOVE_DUPLICATES run_dependencies) + + # If foo-private is a private dependency and foo is a public dependency, + # we don't have to add foo-private as runtime dependency. + set(deps_to_remove "") + foreach(dep IN LISTS run_dependencies) + if(NOT dep MATCHES "(.*)_private$") + continue() + endif() + + # Is foo a public dependency? + list(FIND arg_PUBLIC_DEPENDENCIES "${CMAKE_MATCH_1}" idx) + if(idx GREATER -1) + list(APPEND deps_to_remove "${dep}") + endif() + endforeach() + if(NOT "${deps_to_remove}" STREQUAL "") + list(REMOVE_ITEM run_dependencies ${deps_to_remove}) + endif() + + list(JOIN run_dependencies " " run_dependencies) + set("${out_var}" "${run_dependencies}" PARENT_SCOPE) +endfunction() + +# Generates module .pri files for consumption by qmake +function(qt_generate_module_pri_file target) + set(flags INTERNAL_MODULE NO_PRIVATE_MODULE) + set(options) + set(multiopts) + cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN}) + + qt_internal_module_info(module "${target}") + set(pri_files) + + set(property_prefix) + + get_target_property(target_type ${target} TYPE) + set(is_interface_lib FALSE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + set(is_interface_lib TRUE) + endif() + if(is_interface_lib) + set(property_prefix "INTERFACE_") + endif() + + get_target_property(enabled_features "${target}" + "${property_prefix}QT_ENABLED_PUBLIC_FEATURES") + get_target_property(disabled_features "${target}" + "${property_prefix}QT_DISABLED_PUBLIC_FEATURES") + get_target_property(enabled_private_features "${target}" + "${property_prefix}QT_ENABLED_PRIVATE_FEATURES") + get_target_property(disabled_private_features "${target}" + "${property_prefix}QT_DISABLED_PRIVATE_FEATURES") + qt_correct_features(enabled_features "${enabled_features}") + qt_correct_features(disabled_features "${disabled_features}") + qt_correct_features(enabled_private_features "${enabled_private_features}") + qt_correct_features(disabled_private_features "${disabled_private_features}") + + get_target_property(module_internal_config "${target}" + "${property_prefix}QT_MODULE_INTERNAL_CONFIG") + get_target_property(module_pri_extra_content "${target}" + "${property_prefix}QT_MODULE_PRI_EXTRA_CONTENT") + get_target_property(module_ldflags "${target}" + "${property_prefix}QT_MODULE_LDFLAGS") + get_target_property(module_depends "${target}" + "${property_prefix}QT_MODULE_DEPENDS") + + foreach(var enabled_features disabled_features enabled_private_features disabled_private_features + module_internal_config module_pri_extra_content module_ldflags module_depends) + if(${var} STREQUAL "${var}-NOTFOUND") + set(${var} "") + else() + string (REPLACE ";" " " ${var} "${${var}}") + endif() + endforeach() + + list(APPEND module_internal_config v2) + + if(arg_INTERNAL_MODULE) + list(APPEND module_internal_config internal_module) + endif() + get_target_property(target_type ${target} TYPE) + if (NOT target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(is_fw ${target} FRAMEWORK) + if(is_fw) + list(APPEND module_internal_config lib_bundle) + endif() + endif() + if(target_type STREQUAL "STATIC_LIBRARY") + list(APPEND module_internal_config staticlib) + endif() + + if(QT_FEATURE_ltcg) + list(APPEND module_internal_config ltcg) + endif() + + list(JOIN module_internal_config " " joined_module_internal_config) + + get_target_property(config_module_name ${target} _qt_config_module_name) + get_target_property(qmake_module_config ${target} ${property_prefix}QT_QMAKE_MODULE_CONFIG) + if (is_interface_lib) + list(APPEND qmake_module_config "no_link") + endif() + if(qmake_module_config) + string(REPLACE ";" " " module_build_config "${qmake_module_config}") + set(module_build_config "\nQT.${config_module_name}.CONFIG = ${module_build_config}") + else() + set(module_build_config "") + endif() + + if(is_fw) + qt_internal_get_framework_info(fw ${target}) + set(framework_base_path "$$QT_MODULE_LIB_BASE") + set(public_module_includes "${framework_base_path}/${fw_header_dir}") + set(public_module_frameworks "${framework_base_path}") + set(private_module_includes "${framework_base_path}/${fw_private_header_dir} \ +${framework_base_path}/${fw_private_module_header_dir}") + else() + set(public_module_includes "$$QT_MODULE_INCLUDE_BASE $$QT_MODULE_INCLUDE_BASE/${module}") + set(public_module_frameworks "") + set(private_module_includes "$$QT_MODULE_INCLUDE_BASE/${module_versioned_include_dir} \ +$$QT_MODULE_INCLUDE_BASE/${module_versioned_inner_include_dir}") + endif() + + if(is_interface_lib) + set(module_name_in_pri "") + else() + get_target_property(module_name_in_pri ${target} OUTPUT_NAME) + endif() + + get_target_property(hasModuleHeaders ${target} _qt_module_has_headers) + if (NOT hasModuleHeaders) + unset(public_module_includes) + unset(private_module_includes) + endif() + + set(pri_data_cmake_file "qt_lib_${config_module_name}_private.cmake") + + set(config_module_name_base "${config_module_name}") + + if (arg_INTERNAL_MODULE) + # Internal module pri needs to provide private headers + set(public_module_includes "${public_module_includes} ${private_module_includes}") + endif() + + qt_path_join(target_path ${QT_BUILD_DIR} ${INSTALL_MKSPECSDIR}/modules) + + unset(private_module_frameworks) + if(is_interface_lib) + set(module_plugin_types "") + else() + get_target_property(module_plugin_types ${target} QMAKE_MODULE_PLUGIN_TYPES) + if(module_plugin_types) + list(JOIN module_plugin_types " " module_plugin_types) + else() + set(module_plugin_types "") + endif() + endif() + + set(module_plugin_types_assignment "") + if(module_plugin_types) + set(module_plugin_types_assignment + "\nQT.${config_module_name}.plugin_types = ${module_plugin_types}") + endif() + + qt_get_direct_module_dependencies(${target} public_module_dependencies_list) + list(JOIN public_module_dependencies_list " " public_module_dependencies) + set(public_module_dependencies "${module_depends} ${public_module_dependencies}") + + qt_path_join(pri_file_name "${target_path}" "qt_lib_${config_module_name}.pri") + list(APPEND pri_files "${pri_file_name}") + + # Don't use $ genex because that + # will compute the transitive list of all defines for a module (so Gui would get Core + #defines too). Instead query just the public defines on the target. + get_target_property(target_defines "${target}" INTERFACE_COMPILE_DEFINITIONS) + + # We must filter out expressions of the form $, because + # 1. They cannot be used in file(GENERATE) content. + # 2. They refer to the consuming target we have no access to here. + list(FILTER target_defines EXCLUDE REGEX "\\$]+>") + list(JOIN target_defines " " joined_target_defines) + + set(extra_assignments "") + if(NOT QT_BUILD_SHARED_LIBS AND target STREQUAL Gui) + set(extra_assignments "\nQT_DEFAULT_QPA_PLUGIN = q${QT_QPA_DEFAULT_PLATFORM}") + endif() + + # Map the public dependencies of the target to qmake library names. + get_target_property(dep_targets ${target} INTERFACE_LINK_LIBRARIES) + qt_internal_map_targets_to_qmake_libs(module_uses ${dep_targets}) + list(JOIN module_uses " " joined_module_uses) + + # Retrieve the public module's runtime dependencies. + qt_internal_get_module_run_dependencies(public_module_run_dependencies ${target} + PUBLIC + PUBLIC_DEPENDENCIES "${public_module_dependencies_list}") + + set(content "QT.${config_module_name}.VERSION = ${PROJECT_VERSION} +QT.${config_module_name}.name = ${module} +QT.${config_module_name}.module = ${module_name_in_pri} +QT.${config_module_name}.libs = $$QT_MODULE_LIB_BASE +QT.${config_module_name}.ldflags = ${module_ldflags} +QT.${config_module_name}.includes = ${public_module_includes} +QT.${config_module_name}.frameworks = ${public_module_frameworks} +QT.${config_module_name}.bins = $$QT_MODULE_BIN_BASE${module_plugin_types_assignment} +QT.${config_module_name}.depends = ${public_module_dependencies} +") + if(NOT "${public_module_run_dependencies}" STREQUAL "") + string(APPEND content + "QT.${config_module_name}.run_depends = ${public_module_run_dependencies}\n") + endif() + string(APPEND content + "QT.${config_module_name}.uses = ${joined_module_uses} +QT.${config_module_name}.module_config = ${joined_module_internal_config}${module_build_config} +QT.${config_module_name}.DEFINES = ${joined_target_defines} +QT.${config_module_name}.enabled_features = ${enabled_features} +QT.${config_module_name}.disabled_features = ${disabled_features}${extra_assignments} +QT_CONFIG += ${enabled_features} +QT_MODULES += ${config_module_name_base} +${module_pri_extra_content} +") + file(GENERATE OUTPUT "${pri_file_name}" CONTENT "${content}") + + if (NOT arg_NO_PRIVATE_MODULE AND NOT arg_INTERNAL_MODULE) + set(pri_data_cmake_file "qt_lib_${config_module_name}_private.cmake") + qt_generate_qmake_libraries_pri_content(${config_module_name} "${CMAKE_CURRENT_BINARY_DIR}" + ${pri_data_cmake_file}) + + set(private_pri_file_name "qt_lib_${config_module_name}_private.pri") + + set(private_module_dependencies "") + if(NOT is_interface_lib) + qt_get_direct_module_dependencies(${target}Private private_module_dependencies) + endif() + list(JOIN private_module_dependencies " " private_module_dependencies) + + # Private modules always have internal_module config set, as per qmake. + list(APPEND module_internal_config internal_module) + list(JOIN module_internal_config " " joined_module_internal_config) + + # Map the public dependencies of the private module to qmake library names. + get_target_property(dep_targets ${target}Private INTERFACE_LINK_LIBRARIES) + qt_internal_map_targets_to_qmake_libs(private_module_uses ${dep_targets}) + list(JOIN private_module_uses " " joined_private_module_uses) + + # Retrieve the private module's runtime dependencies. + qt_internal_get_module_run_dependencies(private_module_run_dependencies ${target}Private + PUBLIC_DEPENDENCIES "${dep_targets}") + + # Generate a preliminary qt_lib_XXX_private.pri file + set(content + "QT.${config_module_name}_private.VERSION = ${PROJECT_VERSION} +QT.${config_module_name}_private.name = ${module} +QT.${config_module_name}_private.module = +QT.${config_module_name}_private.libs = $$QT_MODULE_LIB_BASE +QT.${config_module_name}_private.includes = ${private_module_includes} +QT.${config_module_name}_private.frameworks = ${private_module_frameworks} +QT.${config_module_name}_private.depends = ${private_module_dependencies} +") + if(NOT "${private_module_run_dependencies}" STREQUAL "") + string(APPEND content + "QT.${config_module_name}_private.run_depends = ${private_module_run_dependencies} +") + endif() + string(APPEND content + "QT.${config_module_name}_private.uses = ${joined_private_module_uses} +QT.${config_module_name}_private.module_config = ${joined_module_internal_config} +QT.${config_module_name}_private.enabled_features = ${enabled_private_features} +QT.${config_module_name}_private.disabled_features = ${disabled_private_features}") + file(GENERATE + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${private_pri_file_name}" + CONTENT "${content}") + + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + else() + set(configs ${CMAKE_BUILD_TYPE}) + endif() + set(inputs "${CMAKE_CURRENT_BINARY_DIR}/${private_pri_file_name}") + foreach(cfg ${configs}) + list(APPEND inputs "${CMAKE_CURRENT_BINARY_DIR}/${cfg}/${pri_data_cmake_file}") + endforeach() + + qt_path_join(private_pri_file_path "${target_path}" "${private_pri_file_name}") + list(APPEND pri_files "${private_pri_file_path}") + + set(library_prefixes ${CMAKE_SHARED_LIBRARY_PREFIX} ${CMAKE_STATIC_LIBRARY_PREFIX}) + set(library_suffixes + ${CMAKE_SHARED_LIBRARY_SUFFIX} + ${CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES} + ${CMAKE_STATIC_LIBRARY_SUFFIX}) + if(MSVC) + set(link_library_flag "-l") + file(TO_CMAKE_PATH "$ENV{LIB};${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}" implicit_link_directories) + else() + set(link_library_flag ${CMAKE_LINK_LIBRARY_FLAG}) + set(implicit_link_directories ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}) + endif() + add_custom_command( + OUTPUT "${private_pri_file_path}" + DEPENDS ${inputs} + "${QT_CMAKE_DIR}/QtGenerateLibPri.cmake" + "${QT_CMAKE_DIR}/QtGenerateLibHelpers.cmake" + COMMAND ${CMAKE_COMMAND} "-DIN_FILES=${inputs}" "-DOUT_FILE=${private_pri_file_path}" + "-DLIBRARY_PREFIXES=${library_prefixes}" + "-DLIBRARY_SUFFIXES=${library_suffixes}" + "-DLINK_LIBRARY_FLAG=${link_library_flag}" + "-DCONFIGS=${configs}" + "-DIMPLICIT_LINK_DIRECTORIES=${implicit_link_directories}" + -P "${QT_CMAKE_DIR}/QtGenerateLibPri.cmake" + VERBATIM) + # add_dependencies has no effect when adding interface libraries. So need to add the + # '_lib_pri' targets to ALL to make sure that the related rules executed. + unset(add_pri_target_to_all) + if(is_interface_lib) + set(add_pri_target_to_all ALL) + endif() + add_custom_target(${target}_lib_pri ${add_pri_target_to_all} + DEPENDS "${private_pri_file_path}") + add_dependencies(${target} ${target}_lib_pri) + endif() + + qt_install(FILES "${pri_files}" DESTINATION ${INSTALL_MKSPECSDIR}/modules) +endfunction() + +# Generates qt_ext_XXX.pri files for consumption by qmake +function(qt_generate_3rdparty_lib_pri_file target lib pri_file_var) + if(NOT lib) + # Don't write a pri file for projects that don't set QMAKE_LIB_NAME yet. + return() + endif() + + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + else() + set(configs ${CMAKE_BUILD_TYPE}) + endif() + + file(GENERATE + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/$/qt_ext_${lib}.cmake" + CONTENT "set(cfg $) +set(incdir $) +set(defines $) +set(libs $) +") + + set(inputs "") + foreach(cfg ${configs}) + list(APPEND inputs "${CMAKE_CURRENT_BINARY_DIR}/${cfg}/qt_ext_${lib}.cmake") + endforeach() + + qt_path_join(pri_target_path ${QT_BUILD_DIR} ${INSTALL_MKSPECSDIR}/modules) + qt_path_join(pri_file "${pri_target_path}" "qt_ext_${lib}.pri") + qt_path_join(qt_build_libdir ${QT_BUILD_DIR} ${INSTALL_LIBDIR}) + add_custom_command( + OUTPUT "${pri_file}" + DEPENDS ${inputs} "${QT_CMAKE_DIR}/QtGenerateExtPri.cmake" + COMMAND ${CMAKE_COMMAND} "-DIN_FILES=${inputs}" "-DOUT_FILE=${pri_file}" -DLIB=${lib} + "-DCONFIGS=${configs}" + "-DQT_BUILD_LIBDIR=${qt_build_libdir}" + -P "${QT_CMAKE_DIR}/QtGenerateExtPri.cmake" + VERBATIM) + add_custom_target(${target}_ext_pri DEPENDS "${pri_file}") + add_dependencies(${target} ${target}_ext_pri) + set(${pri_file_var} ${pri_file} PARENT_SCOPE) +endfunction() + +# Generates qt_plugin_XXX.pri files for consumption by qmake +# +# QT_PLUGIN.XXX.EXTENDS is set to "-" for the following plugin types: +# - generic +# - platform, if the plugin is not the default QPA plugin +# Otherwise, this variable is empty. +function(qt_generate_plugin_pri_file target) + get_target_property(plugin_name ${target} OUTPUT_NAME) + get_target_property(plugin_type ${target} QT_PLUGIN_TYPE) + get_target_property(qmake_plugin_type ${target} QT_QMAKE_PLUGIN_TYPE) + get_target_property(default_plugin ${target} QT_DEFAULT_PLUGIN) + get_target_property(plugin_class_name ${target} QT_PLUGIN_CLASS_NAME) + get_target_property(plugin_pri_extra_content ${target} QT_PLUGIN_PRI_EXTRA_CONTENT) + + foreach(var plugin_pri_extra_content) + if(${var} STREQUAL "${var}-NOTFOUND") + set(${var} "") + else() + string(REPLACE ";" "\n" ${var} "${${var}}") + endif() + endforeach() + + set(plugin_extends "") + if(NOT default_plugin) + set(plugin_extends "-") + endif() + + set(plugin_deps "") + get_target_property(target_deps ${target} _qt_target_deps) + foreach(dep ${target_deps}) + list(GET dep 0 dep_name) + qt_get_qmake_module_name(dep_name ${dep_name}) + list(APPEND plugin_deps ${dep_name}) + endforeach() + list(REMOVE_DUPLICATES plugin_deps) + list(JOIN plugin_deps " " plugin_deps) + + list(APPEND module_config v2) + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "STATIC_LIBRARY") + list(APPEND module_config staticlib) + endif() + list(JOIN module_config " " module_config) + + qt_path_join(pri_target_path ${QT_BUILD_DIR} ${INSTALL_MKSPECSDIR}/modules) + qt_path_join(pri_file "${pri_target_path}" "qt_plugin_${plugin_name}.pri") + + set(content "QT_PLUGIN.${plugin_name}.TYPE = ${qmake_plugin_type} +QT_PLUGIN.${plugin_name}.EXTENDS = ${plugin_extends} +QT_PLUGIN.${plugin_name}.DEPENDS = ${plugin_deps} +QT_PLUGIN.${plugin_name}.CLASS_NAME = ${plugin_class_name} +QT_PLUGIN.${plugin_name}.module_config = ${module_config} +QT_PLUGINS += ${plugin_name} +${plugin_pri_extra_content}" +) + + file(GENERATE OUTPUT "${pri_file}" CONTENT "${content}") + + qt_install(FILES "${pri_file}" DESTINATION "${INSTALL_MKSPECSDIR}/modules") +endfunction() + +# Creates mkspecs/qconfig.pri which contains public global features among other things. +function(qt_generate_global_config_pri_file) + qt_path_join(qconfig_pri_target_path ${PROJECT_BINARY_DIR} ${INSTALL_MKSPECSDIR}) + qt_path_join(qconfig_pri_target_path "${qconfig_pri_target_path}" "qconfig.pri") + + get_target_property(enabled_features GlobalConfig INTERFACE_QT_ENABLED_PUBLIC_FEATURES) + get_target_property(disabled_features GlobalConfig INTERFACE_QT_DISABLED_PUBLIC_FEATURES) + + qt_correct_features(corrected_enabled_features "${enabled_features}") + qt_correct_features(corrected_disabled_features "${disabled_features}") + + string (REPLACE ";" " " corrected_enabled_features "${corrected_enabled_features}") + string (REPLACE ";" " " corrected_disabled_features "${corrected_disabled_features}") + + # Add some required CONFIG entries. + set(config_entries "") + if(CMAKE_BUILD_TYPE STREQUAL Debug) + list(APPEND config_entries "debug") + elseif(CMAKE_BUILD_TYPE STREQUAL Release) + list(APPEND config_entries "release") + endif() + list(APPEND config_entries "${qt_build_config_type}") + string (REPLACE ";" " " config_entries "${config_entries}") + + get_target_property(public_config GlobalConfig INTERFACE_QT_QMAKE_PUBLIC_CONFIG) + get_target_property(qt_public_config GlobalConfig INTERFACE_QT_QMAKE_PUBLIC_QT_CONFIG) + qt_correct_config(corrected_public_config "${public_config}") + qt_correct_config(corrected_qt_public_config "${qt_public_config}") + qt_guess_qmake_build_config(qmake_build_config) + list(APPEND corrected_qt_public_config ${qmake_build_config}) + + list(JOIN corrected_public_config " " public_config_joined) + list(JOIN corrected_qt_public_config " " qt_public_config_joined) + + set(content "") + if(GCC OR CLANG AND NOT "${CMAKE_SYSROOT}" STREQUAL "") + string(APPEND content "!host_build { + QMAKE_CFLAGS += --sysroot=\$\$[QT_SYSROOT] + QMAKE_CXXFLAGS += --sysroot=\$\$[QT_SYSROOT] + QMAKE_LFLAGS += --sysroot=\$\$[QT_SYSROOT] +} +") + endif() + + if(CMAKE_CROSSCOMPILING) + string(APPEND content "host_build { + QT_ARCH = ${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_ARCH} + QT_BUILDABI = ${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BUILDABI} + QT_TARGET_ARCH = ${TEST_architecture_arch} + QT_TARGET_BUILDABI = ${TEST_buildAbi} +} else { + QT_ARCH = ${TEST_architecture_arch} + QT_BUILDABI = ${TEST_buildAbi} + QT_LIBCPP_ABI_TAG = ${TEST_libcppabiTag} +} +") + else() + string(APPEND content "QT_ARCH = ${TEST_architecture_arch} +QT_BUILDABI = ${TEST_buildAbi} +QT_LIBCPP_ABI_TAG = ${TEST_libcppabiTag} +") + endif() + + string(APPEND content "QT.global.enabled_features = ${corrected_enabled_features} +QT.global.disabled_features = ${corrected_disabled_features} +QT.global.disabled_features += release build_all +QT_CONFIG += ${qt_public_config_joined} +CONFIG += ${config_entries} ${public_config_joined} +QT_VERSION = ${PROJECT_VERSION} +QT_MAJOR_VERSION = ${PROJECT_VERSION_MAJOR} +QT_MINOR_VERSION = ${PROJECT_VERSION_MINOR} +QT_PATCH_VERSION = ${PROJECT_VERSION_PATCH} +") + + set(extra_statements "") + if(QT_NAMESPACE) + list(APPEND extra_statements "QT_NAMESPACE = ${QT_NAMESPACE}") + endif() + + if(QT_LIBINFIX) + list(APPEND extra_statements "QT_LIBINFIX = ${QT_LIBINFIX}") + endif() + + if(APPLECLANG) + set(compiler_version_major_var_name "QT_APPLE_CLANG_MAJOR_VERSION") + set(compiler_version_minor_var_name "QT_APPLE_CLANG_MINOR_VERSION") + set(compiler_version_patch_var_name "QT_APPLE_CLANG_PATCH_VERSION") + elseif(IntelLLVM) + set(compiler_version_major_var_name "QT_INTELLLVM_MAJOR_VERSION") + set(compiler_version_minor_var_name "QT_INTELLLVM_MINOR_VERSION") + set(compiler_version_patch_var_name "QT_INTELLLVM_PATCH_VERSION") + elseif(CLANG) + set(compiler_version_major_var_name "QT_CLANG_MAJOR_VERSION") + set(compiler_version_minor_var_name "QT_CLANG_MINOR_VERSION") + set(compiler_version_patch_var_name "QT_CLANG_PATCH_VERSION") + elseif(GCC) + set(compiler_version_major_var_name "QT_GCC_MAJOR_VERSION") + set(compiler_version_minor_var_name "QT_GCC_MINOR_VERSION") + set(compiler_version_patch_var_name "QT_GCC_PATCH_VERSION") + elseif(MSVC) + set(compiler_version_major_var_name "QT_MSVC_MAJOR_VERSION") + set(compiler_version_minor_var_name "QT_MSVC_MINOR_VERSION") + set(compiler_version_patch_var_name "QT_MSVC_PATCH_VERSION") + endif() + + if(compiler_version_major_var_name) + list(APPEND extra_statements + "${compiler_version_major_var_name} = ${QT_COMPILER_VERSION_MAJOR}") + list(APPEND extra_statements + "${compiler_version_minor_var_name} = ${QT_COMPILER_VERSION_MINOR}") + list(APPEND extra_statements + "${compiler_version_patch_var_name} = ${QT_COMPILER_VERSION_PATCH}") + endif() + + if(APPLE) + list(APPEND extra_statements "QT_MAC_SDK_VERSION = ${QT_MAC_SDK_VERSION}") + if(NOT CMAKE_SYSTEM_NAME OR CMAKE_SYSTEM_NAME STREQUAL "Darwin") + # macOS + list(APPEND extra_statements + "QMAKE_MACOSX_DEPLOYMENT_TARGET = ${CMAKE_OSX_DEPLOYMENT_TARGET}") + list(APPEND extra_statements + "QT_MAC_SDK_VERSION_MIN = ${QT_SUPPORTED_MIN_MACOS_SDK_VERSION}") + list(APPEND extra_statements + "QT_MAC_SDK_VERSION_MAX = ${QT_SUPPORTED_MAX_MACOS_SDK_VERSION}") + elseif(CMAKE_SYSTEM_NAME STREQUAL iOS) + list(APPEND extra_statements + "QMAKE_IOS_DEPLOYMENT_TARGET = ${CMAKE_OSX_DEPLOYMENT_TARGET}") + list(APPEND extra_statements + "QT_MAC_SDK_VERSION_MIN = ${QT_SUPPORTED_MIN_IOS_SDK_VERSION}") + list(APPEND extra_statements + "QT_MAC_SDK_VERSION_MAX = ${QT_SUPPORTED_MAX_IOS_SDK_VERSION}") + endif() + + if (CMAKE_OSX_ARCHITECTURES) + list(APPEND architectures "${CMAKE_OSX_ARCHITECTURES}") + string (REPLACE ";" " " architectures "${architectures}") + else() + set(architectures "$$QT_ARCH") + endif() + list(APPEND extra_statements "QT_ARCHS = ${architectures}") + endif() + + if(WASM) + list(APPEND extra_statements + "QT_EMCC_VERSION = ${EMCC_VERSION}") + endif() + if(extra_statements) + string(REPLACE ";" "\n" extra_statements "${extra_statements}") + string(APPEND content "\n${extra_statements}\n") + endif() + + file(GENERATE + OUTPUT "${qconfig_pri_target_path}" + CONTENT "${content}" + ) + qt_install(FILES "${qconfig_pri_target_path}" DESTINATION ${INSTALL_MKSPECSDIR}) +endfunction() + +# Creates mkspecs/qdevice.pri which contains target device information for cross-builds. +# The content of QT_QMAKE_DEVICE_OPTIONS is written verbatim into qdevice.pri. +function(qt_generate_global_device_pri_file) + if(NOT CMAKE_CROSSCOMPILING) + return() + endif() + + qt_path_join(qdevice_pri_target_path ${PROJECT_BINARY_DIR} ${INSTALL_MKSPECSDIR} "qdevice.pri") + + set(content "") + foreach(opt ${QT_QMAKE_DEVICE_OPTIONS}) + string(APPEND content "${opt}\n") + endforeach() + + # Write android specific device info. + if(ANDROID) + file(TO_CMAKE_PATH ${ANDROID_SDK_ROOT} ANDROID_SDK_ROOT) + string(APPEND content "DEFAULT_ANDROID_SDK_ROOT = ${ANDROID_SDK_ROOT}\n") + file(TO_CMAKE_PATH ${ANDROID_NDK} ANDROID_NDK) + string(APPEND content "DEFAULT_ANDROID_NDK_ROOT = ${ANDROID_NDK}\n") + + set(android_platform "android-28") + if(ANDROID_PLATFORM) + set(android_platform "${ANDROID_PLATFORM}") + elseif(ANDROID_NATIVE_API_LEVEL) + set(android_platform "android-${ANDROID_NATIVE_API_LEVEL}") + endif() + string(APPEND content "DEFAULT_ANDROID_PLATFORM = ${android_platform}\n") + + string(APPEND content "DEFAULT_ANDROID_NDK_HOST = ${ANDROID_HOST_TAG}\n") + + # TODO: QTBUG-80943 When we eventually support Android multi-abi, this should be changed. + string(APPEND content "DEFAULT_ANDROID_ABIS = ${ANDROID_ABI}\n") + + if(QT_ANDROID_JAVAC_SOURCE) + string(APPEND content "ANDROID_JAVAC_SOURCE_VERSION = ${QT_ANDROID_JAVAC_SOURCE}\n") + endif() + if(QT_ANDROID_JAVAC_TARGET) + string(APPEND content "ANDROID_JAVAC_TARGET_VERSION = ${QT_ANDROID_JAVAC_TARGET}\n") + endif() + endif() + + if(QT_APPLE_SDK) + string(APPEND content "QMAKE_MAC_SDK = ${QT_APPLE_SDK}\n") + endif() + + set(gcc_machine_dump "") + if(TEST_machine_tuple) + set(gcc_machine_dump "${TEST_machine_tuple}") + endif() + string(APPEND content "GCC_MACHINE_DUMP = ${gcc_machine_dump}\n") + + file(GENERATE OUTPUT "${qdevice_pri_target_path}" CONTENT "${content}") + qt_install(FILES "${qdevice_pri_target_path}" DESTINATION ${INSTALL_MKSPECSDIR}) +endfunction() + +function(qt_get_build_parts out_var) + set(parts "libs") + + if(QT_BUILD_EXAMPLES AND QT_BUILD_EXAMPLES_BY_DEFAULT) + list(APPEND parts "examples") + endif() + + if(QT_BUILD_TESTS AND QT_BUILD_TESTS_BY_DEFAULT) + list(APPEND parts "tests") + endif() + + if(NOT CMAKE_CROSSCOMPILING OR QT_FORCE_BUILD_TOOLS) + list(APPEND parts "tools") + endif() + + set(${out_var} ${parts} PARENT_SCOPE) +endfunction() + +# Creates mkspecs/qmodule.pri which contains private global features among other things. +function(qt_generate_global_module_pri_file) + qt_path_join(qmodule_pri_target_path ${PROJECT_BINARY_DIR} ${INSTALL_MKSPECSDIR}) + qt_path_join(qmodule_pri_target_path "${qmodule_pri_target_path}" "qmodule.pri") + + get_target_property(enabled_features GlobalConfig INTERFACE_QT_ENABLED_PRIVATE_FEATURES) + get_target_property(disabled_features GlobalConfig INTERFACE_QT_DISABLED_PRIVATE_FEATURES) + + qt_correct_features(corrected_enabled_features "${enabled_features}") + qt_correct_features(corrected_disabled_features "${disabled_features}") + + string (REPLACE ";" " " corrected_enabled_features "${corrected_enabled_features}") + string (REPLACE ";" " " corrected_disabled_features "${corrected_disabled_features}") + + set(corrected_private_config "") + get_target_property(private_config GlobalConfig INTERFACE_QT_QMAKE_PRIVATE_CONFIG) + qt_correct_config(corrected_private_config "${private_config}") + list(JOIN corrected_private_config " " private_config_joined) + + set(content "") + if(DEFINED QT_EXTRA_DEFINES) + list(JOIN QT_EXTRA_DEFINES " " value) + string(APPEND content "EXTRA_DEFINES += ${value}\n") + endif() + if(DEFINED QT_EXTRA_INCLUDEPATHS) + qt_to_qmake_path_list(value ${QT_EXTRA_INCLUDEPATHS}) + string(APPEND content "EXTRA_INCLUDEPATH += ${value}\n") + endif() + if(DEFINED QT_EXTRA_LIBDIRS) + qt_to_qmake_path_list(value ${QT_EXTRA_LIBDIRS}) + string(APPEND content "EXTRA_LIBDIR += ${value}\n") + endif() + if(DEFINED QT_EXTRA_FRAMEWORKPATHS) + qt_to_qmake_path_list(value ${QT_EXTRA_FRAMEWORKPATHS}) + string(APPEND content "EXTRA_FRAMEWORKPATH += ${value}\n") + endif() + + set(arch "${TEST_architecture_arch}") + list(JOIN TEST_subarch_result " " subarchs) + if(CMAKE_CROSSCOMPILING) + set(host_arch "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_ARCH}") + list(JOIN QT${PROJECT_VERSION_MAJOR}_HOST_INFO_SUBARCHS " " host_subarchs) + string(APPEND content "host_build { + QT_CPU_FEATURES.${host_arch} = ${host_subarchs} +} else { + QT_CPU_FEATURES.${arch} = ${subarchs} +} +") + else() + string(APPEND content "QT_CPU_FEATURES.${arch} = ${subarchs}\n") + endif() + + string(APPEND content "QT.global_private.enabled_features = ${corrected_enabled_features} +QT.global_private.disabled_features = ${corrected_disabled_features} +CONFIG += ${private_config_joined} +") + if(PKG_CONFIG_FOUND) + string(APPEND content "PKG_CONFIG_EXECUTABLE = ${PKG_CONFIG_EXECUTABLE}\n") + endif() + + string(APPEND content "QT_COORD_TYPE = ${QT_COORD_TYPE}\n") + + qt_get_build_parts(build_parts) + string(REPLACE ";" " " build_parts "${build_parts}") + string(APPEND content "QT_BUILD_PARTS = ${build_parts}\n") + + if(QT_EXTRA_RPATHS) + list(JOIN QT_EXTRA_RPATHS " " extra_rpaths) + string(APPEND content "EXTRA_RPATHS += ${extra_rpaths}") + endif() + + set(preliminary_pri_root "${CMAKE_CURRENT_BINARY_DIR}/mkspecs/preliminary") + set(pri_data_cmake_file "qmodule.cmake") + qt_generate_qmake_libraries_pri_content(global ${preliminary_pri_root} ${pri_data_cmake_file}) + + # Generate a preliminary qmodule.pri file + set(preliminary_pri_file_path "${preliminary_pri_root}/qmodule.pri") + file(GENERATE + OUTPUT ${preliminary_pri_file_path} + CONTENT "${content}" + ) + + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + else() + set(configs ${CMAKE_BUILD_TYPE}) + endif() + set(inputs ${preliminary_pri_file_path}) + foreach(cfg ${configs}) + list(APPEND inputs "${preliminary_pri_root}/${cfg}/${pri_data_cmake_file}") + endforeach() + + set(library_prefixes ${CMAKE_SHARED_LIBRARY_PREFIX} ${CMAKE_STATIC_LIBRARY_PREFIX}) + set(library_suffixes + ${CMAKE_SHARED_LIBRARY_SUFFIX} + ${CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES} + ${CMAKE_STATIC_LIBRARY_SUFFIX}) + if(MSVC) + set(link_library_flag "-l") + file(TO_CMAKE_PATH "$ENV{LIB};${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}" implicit_link_directories) + else() + set(link_library_flag ${CMAKE_LINK_LIBRARY_FLAG}) + set(implicit_link_directories ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}) + endif() + add_custom_command( + OUTPUT "${qmodule_pri_target_path}" + DEPENDS ${inputs} + "${QT_CMAKE_DIR}/QtGenerateLibPri.cmake" + "${QT_CMAKE_DIR}/QtGenerateLibHelpers.cmake" + COMMAND ${CMAKE_COMMAND} "-DIN_FILES=${inputs}" "-DOUT_FILE=${qmodule_pri_target_path}" + "-DLIBRARY_PREFIXES=${library_prefixes}" + "-DLIBRARY_SUFFIXES=${library_suffixes}" + "-DLINK_LIBRARY_FLAG=${link_library_flag}" + "-DCONFIGS=${configs}" + "-DIMPLICIT_LINK_DIRECTORIES=${implicit_link_directories}" + -P "${QT_CMAKE_DIR}/QtGenerateLibPri.cmake" + VERBATIM) + add_custom_target(qmodule_pri DEPENDS "${qmodule_pri_target_path}") + qt_install(FILES "${qmodule_pri_target_path}" DESTINATION ${INSTALL_MKSPECSDIR}) +endfunction() + +function(qt_correct_features out_var features) + set(corrected_features "") + foreach(feature ${features}) + get_property(feature_original_name GLOBAL PROPERTY "QT_FEATURE_ORIGINAL_NAME_${feature}") + list(APPEND corrected_features "${feature_original_name}") + endforeach() + set(${out_var} ${corrected_features} PARENT_SCOPE) +endfunction() + +# Get original names for config values (which correspond to feature names) and use them if they +# exist, otherwise just use the config value (which might be the case when a config value has +# a custom name). +function(qt_correct_config out_var config) + set(corrected_config "") + foreach(name ${config}) + # Is the config value a known feature? + get_property(feature_original_name GLOBAL PROPERTY "QT_FEATURE_ORIGINAL_NAME_${name}") + if(feature_original_name) + list(APPEND corrected_config "${feature_original_name}") + continue() + endif() + + # Is the config value a negated known feature, e.g. no_foo? + # Then add the config value no-foo. + if(name MATCHES "^no_(.*)") + get_property(feature_original_name GLOBAL PROPERTY + "QT_FEATURE_ORIGINAL_NAME_${CMAKE_MATCH_1}") + if(feature_original_name) + list(APPEND corrected_config "no-${feature_original_name}") + continue() + endif() + endif() + + # The config value is no known feature. Add the value as is. + list(APPEND corrected_config "${name}") + endforeach() + set(${out_var} ${corrected_config} PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPrlHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPrlHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7ccff1a12a5667d45dbc93abd74ea0cc07144f0d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPrlHelpers.cmake @@ -0,0 +1,216 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Collects the library dependencies of a target. +# As well as rcc object file dependencies. +# This takes into account transitive usage requirements. +function(qt_collect_libs target libs_out_var rcc_objects_out_var) + __qt_internal_walk_libs("${target}" "${libs_out_var}" + "${rcc_objects_out_var}" "qt_collect_libs_dict" "collect_libs") + set("${libs_out_var}" "${${libs_out_var}}" PARENT_SCOPE) + + set(${rcc_objects_out_var} "${${rcc_objects_out_var}}" PARENT_SCOPE) + +endfunction() + +# Generate a qmake .prl file for the given target. +# The install_dir argument is a relative path, for example "lib". +function(qt_generate_prl_file target install_dir) + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "INTERFACE_LIBRARY") + return() + endif() + + unset(prl_config) + set(is_static FALSE) + if(target_type STREQUAL "STATIC_LIBRARY") + list(APPEND prl_config static) + set(is_static TRUE) + elseif(target_type STREQUAL "SHARED_LIBRARY") + list(APPEND prl_config shared) + endif() + if (NOT target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(is_fw ${target} FRAMEWORK) + if(is_fw) + list(APPEND prl_config lib_bundle) + endif() + endif() + list(JOIN prl_config " " prl_config) + + set(rcc_objects "") + set(prl_step1_content_libs "") + if(NOT is_static AND WIN32) + # Do nothing. Prl files for shared libraries on Windows shouldn't have the libs listed, + # as per qt_build_config.prf and the conditional CONFIG+=explicitlib assignment. + else() + set(prl_libs "") + qt_collect_libs(${target} prl_libs prl_rcc_objects) + if(prl_libs) + set(prl_step1_content_libs "QMAKE_PRL_LIBS_FOR_CMAKE = ${prl_libs}\n") + endif() + if(prl_rcc_objects) + list(APPEND rcc_objects ${prl_rcc_objects}) + endif() + endif() + + if(rcc_objects AND QT_WILL_INSTALL) + list(TRANSFORM rcc_objects PREPEND "$$[QT_INSTALL_PREFIX]/") + endif() + + # Generate a preliminary .prl file that contains absolute paths to all libraries + if(MINGW) + # For MinGW, qmake doesn't have a lib prefix in prl files. + set(prefix_for_final_prl_name "") + else() + set(prefix_for_final_prl_name "$") + endif() + + # For frameworks, the prl file should be placed under the Resources subdir. + get_target_property(is_framework ${target} FRAMEWORK) + if(is_framework) + get_target_property(fw_version ${target} FRAMEWORK_VERSION) + string(APPEND prefix_for_final_prl_name "Versions/${fw_version}/Resources/") + endif() + + # What follows is a complicated setup for generating configuration-specific + # prl files. It has to be this way, because add_custom_command doesn't support + # generator expressions in OUTPUT or DEPENDS. + # To circumvent that, we create well known file names with file(GENERATE) + # with configuration specific content, which are then fed to add_custom_command + # that uses these genex-less file names. The actual command will extract the info + # from the configuration-specific files, and create a properly named final prl file. + + # The file is named according to a pattern, that is then used in the + # add_custom_command. + set(prl_step1_name_prefix "preliminary_prl_for_${target}_step1_") + set(prl_step1_name_suffix ".prl" ) + qt_path_join(prl_step1_path + "${CMAKE_CURRENT_BINARY_DIR}" + "${prl_step1_name_prefix}$${prl_step1_name_suffix}") + + # Same, except instead of containing the prl contents, it will contain the final prl file + # name computed via a generator expression. + set(prl_meta_info_name_prefix "preliminary_prl_meta_info_for_${target}_") + set(prl_meta_info_name_suffix ".txt") + qt_path_join(prl_meta_info_path + "${CMAKE_CURRENT_BINARY_DIR}" + "${prl_meta_info_name_prefix}$${prl_meta_info_name_suffix}") + + # The final prl file name that will be embedded in the file above. + set(final_prl_file_name "${prefix_for_final_prl_name}$") + if(ANDROID) + string(APPEND final_prl_file_name "_${CMAKE_ANDROID_ARCH_ABI}") + endif() + string(APPEND final_prl_file_name ".prl") + qt_path_join(final_prl_file_path "${QT_BUILD_DIR}/${install_dir}" "${final_prl_file_name}") + + # Generate the prl content and its final file name into configuration specific files + # whose names we know, and can be used in add_custom_command. + set(prl_step1_content + "RCC_OBJECTS = ${rcc_objects} +QMAKE_PRL_TARGET = $ +QMAKE_PRL_TARGET_PATH_FOR_CMAKE = $ +QMAKE_PRL_CONFIG = ${prl_config} +QMAKE_PRL_VERSION = ${PROJECT_VERSION} +${prl_step1_content_libs} +") + + file(GENERATE + OUTPUT "${prl_step1_path}" + CONTENT "${prl_step1_content}") + file(GENERATE + OUTPUT "${prl_meta_info_path}" + CONTENT + "FINAL_PRL_FILE_PATH = ${final_prl_file_path}") + + set(library_prefixes ${CMAKE_SHARED_LIBRARY_PREFIX} ${CMAKE_STATIC_LIBRARY_PREFIX}) + set(library_suffixes + ${CMAKE_SHARED_LIBRARY_SUFFIX} + ${CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES} + ${CMAKE_STATIC_LIBRARY_SUFFIX}) + + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + else() + set(configs ${CMAKE_BUILD_TYPE}) + endif() + + set(qt_lib_dirs "${QT_BUILD_DIR}/${INSTALL_LIBDIR}") + if(QT_WILL_INSTALL) + list(APPEND qt_lib_dirs + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_LIBDIR}") + endif() + + set(qt_plugin_dirs "${QT_BUILD_DIR}/${INSTALL_PLUGINSDIR}") + if(QT_WILL_INSTALL) + list(APPEND qt_plugin_dirs + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_PLUGINSDIR}") + endif() + + set(qt_qml_dirs "${QT_BUILD_DIR}/${INSTALL_QMLDIR}") + if(QT_WILL_INSTALL) + list(APPEND qt_qml_dirs + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_QMLDIR}") + endif() + + foreach(config ${configs}) + # Output file for dependency tracking, and which will contain the final content. + qt_path_join(prl_step2_path + "${CMAKE_CURRENT_BINARY_DIR}" "preliminary_prl_for_${target}_step2_${config}.prl") + + # Input dependency names that are constructed for each config manually + # (no genexes allowed). + qt_path_join(prl_step1_path + "${CMAKE_CURRENT_BINARY_DIR}" + "${prl_step1_name_prefix}${config}${prl_step1_name_suffix}") + qt_path_join(prl_meta_info_path + "${CMAKE_CURRENT_BINARY_DIR}" + "${prl_meta_info_name_prefix}${config}${prl_meta_info_name_suffix}") + if(MSVC) + set(link_library_flag "-l") + file(TO_CMAKE_PATH "$ENV{LIB};${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}" implicit_link_directories) + else() + set(link_library_flag ${CMAKE_LINK_LIBRARY_FLAG}) + set(implicit_link_directories ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}) + endif() + add_custom_command( + OUTPUT "${prl_step2_path}" + DEPENDS "${prl_step1_path}" + "${prl_meta_info_path}" + "${QT_CMAKE_DIR}/QtFinishPrlFile.cmake" + "${QT_CMAKE_DIR}/QtGenerateLibHelpers.cmake" + COMMAND ${CMAKE_COMMAND} + "-DIN_FILE=${prl_step1_path}" + "-DIN_META_FILE=${prl_meta_info_path}" + "-DOUT_FILE=${prl_step2_path}" + "-DLIBRARY_PREFIXES=${library_prefixes}" + "-DLIBRARY_SUFFIXES=${library_suffixes}" + "-DLINK_LIBRARY_FLAG=${link_library_flag}" + "-DQT_LIB_DIRS=${qt_lib_dirs}" + "-DQT_PLUGIN_DIRS=${qt_plugin_dirs}" + "-DQT_QML_DIRS=${qt_qml_dirs}" + "-DIMPLICIT_LINK_DIRECTORIES=${implicit_link_directories}" + -P "${QT_CMAKE_DIR}/QtFinishPrlFile.cmake" + VERBATIM + COMMENT "Generating prl file for target ${target}" + ) + + # Tell the target to depend on the preliminary prl file, to ensure the custom command + # is executed. As a side-effect, this will also create the final prl file that + # is named appropriately. It should not be specified as a BYPRODUCT. + # This allows proper per-file dependency tracking, without having to resort on a POST_BUILD + # step, which means that relinking would happen as well as transitive rebuilding of any + # dependees. + # This is inspired by https://gitlab.kitware.com/cmake/cmake/-/issues/20842 + target_sources(${target} PRIVATE "${prl_step2_path}") + endforeach() + + # Installation of the .prl file happens globally elsewhere, + # because we have no clue here what the actual file name is. + # What we know however, is the directory where the prl file is created. + # Save that for later, to install all prl files from that directory. + get_property(prl_install_dirs GLOBAL PROPERTY QT_PRL_INSTALL_DIRS) + if(NOT install_dir IN_LIST prl_install_dirs) + set_property(GLOBAL APPEND PROPERTY QT_PRL_INSTALL_DIRS "${install_dir}") + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtProcessConfigureArgs.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtProcessConfigureArgs.cmake new file mode 100644 index 0000000000000000000000000000000000000000..516661ba2a7a081eef3794396233e0892fd217dd --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtProcessConfigureArgs.cmake @@ -0,0 +1,1140 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This script reads Qt configure arguments from config.opt, +# translates the arguments to CMake arguments and calls CMake. +# +# This file is to be used in CMake script mode with the following variables set: +# OPTFILE: A text file containing the options that were passed to configure +# with one option per line. +# MODULE_ROOT: The source directory of the module to be built. +# If empty, qtbase/top-level is assumed. +# TOP_LEVEL: TRUE, if this is a top-level build. + +include(${CMAKE_CURRENT_LIST_DIR}/QtFeatureCommon.cmake) +include(${CMAKE_CURRENT_LIST_DIR}/QtBuildInformation.cmake) + +cmake_policy(SET CMP0007 NEW) +cmake_policy(SET CMP0057 NEW) + +set(cmake_args "") +macro(push) + list(APPEND cmake_args ${ARGN}) +endmacro() + +macro(pop_path_argument) + list(POP_FRONT configure_args path) + string(REGEX REPLACE "^\"(.*)\"$" "\\1" path "${path}") + file(TO_CMAKE_PATH "${path}" path) +endmacro() + +function(is_non_empty_valid_arg arg value) + if(value STREQUAL "") + message(FATAL_ERROR "Value supplied to command line option '${arg}' is empty.") + elseif(value MATCHES "^-.*") + message(FATAL_ERROR + "Value supplied to command line option '${arg}' is invalid: ${value}") + endif() +endfunction() + +function(warn_in_per_repo_build arg) + if(NOT TOP_LEVEL) + message(WARNING "Command line option ${arg} is only effective in top-level builds") + endif() +endfunction() + +function(is_valid_qt_hex_version arg version) + if(NOT version MATCHES "^0x[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]$") + message(FATAL_ERROR "Incorrect version ${version} specified for ${arg}") + endif() +endfunction() + +if("${MODULE_ROOT}" STREQUAL "") + # If MODULE_ROOT is not set, assume that we want to build qtbase or top-level. + get_filename_component(MODULE_ROOT ".." ABSOLUTE BASE_DIR "${CMAKE_CURRENT_LIST_DIR}") + set(qtbase_or_top_level_build TRUE) +else() + # If MODULE_ROOT is passed without drive letter, we try to add it to the path. + # The check is necessary; otherwise, `get_filename_component` returns an empty string. + if(NOT MODULE_ROOT STREQUAL ".") + get_filename_component(MODULE_ROOT "." REALPATH BASE_DIR "${MODULE_ROOT}") + endif() + set(qtbase_or_top_level_build FALSE) +endif() +set(configure_filename "configure.cmake") +set(commandline_filename "qt_cmdline.cmake") +if(TOP_LEVEL) + get_filename_component(MODULE_ROOT "../.." ABSOLUTE BASE_DIR "${CMAKE_CURRENT_LIST_DIR}") + file(GLOB commandline_files "${MODULE_ROOT}/*/${commandline_filename}") + if(EXISTS "${MODULE_ROOT}/${commandline_filename}") + list(PREPEND commandline_files "${MODULE_ROOT}/${commandline_filename}") + endif() +else() + set(commandline_files "${MODULE_ROOT}/${commandline_filename}") +endif() +file(STRINGS "${OPTFILE}" configure_args) + +# list(TRANSFORM ...) unexpectedly removes semicolon escaping in list items. So the list arguments +# seem to be broken. The 'bracket argument' suppresses this behavior. Right before forwarding +# command line arguments to the cmake call, 'bracket arguments' are replaced by escaped semicolons +# back. +list(TRANSFORM configure_args REPLACE ";" "[[;]]") + +list(FILTER configure_args EXCLUDE REGEX "^[ \t]*$") +list(TRANSFORM configure_args STRIP) +unset(generator) +set(auto_detect_compiler TRUE) +set(auto_detect_generator ${qtbase_or_top_level_build}) +set(no_prefix_option FALSE) +unset(device_options) +unset(options_json_file) +set_property(GLOBAL PROPERTY UNHANDLED_ARGS "") +while(NOT "${configure_args}" STREQUAL "") + list(POP_FRONT configure_args raw_arg) + + # Condense '--foo-bar' arguments into '-foo-bar'. + string(REGEX REPLACE "^--([^-])" "-\\1" arg "${raw_arg}") + + if(arg STREQUAL "-cmake-generator") + list(POP_FRONT configure_args generator) + elseif(arg STREQUAL "-cmake-use-default-generator") + set(auto_detect_generator FALSE) + elseif(arg STREQUAL "-no-guess-compiler") + set(auto_detect_compiler FALSE) + elseif(arg STREQUAL "-list-features") + set(list_features TRUE) + elseif(arg MATCHES "^-h(elp)?$") + set(display_module_help TRUE) + elseif(arg STREQUAL "-write-options-for-conan") + list(POP_FRONT configure_args options_json_file) + elseif(arg STREQUAL "-skip") + warn_in_per_repo_build("${arg}") + list(POP_FRONT configure_args qtrepos) + is_non_empty_valid_arg("${arg}" "${qtrepos}") + list(TRANSFORM qtrepos REPLACE "," ";") + foreach(qtrepo IN LISTS qtrepos) + push("-DBUILD_${qtrepo}=OFF") + endforeach() + elseif(arg STREQUAL "-skip-tests") + list(POP_FRONT configure_args qtrepos) + is_non_empty_valid_arg("${arg}" "${qtrepos}") + list(TRANSFORM qtrepos REPLACE "," ";") + foreach(qtrepo IN LISTS qtrepos) + push("-DQT_BUILD_TESTS_PROJECT_${qtrepo}=OFF") + endforeach() + elseif(arg STREQUAL "-skip-examples") + list(POP_FRONT configure_args qtrepos) + is_non_empty_valid_arg("${arg}" "${qtrepos}") + list(TRANSFORM qtrepos REPLACE "," ";") + foreach(qtrepo IN LISTS qtrepos) + push("-DQT_BUILD_EXAMPLES_PROJECT_${qtrepo}=OFF") + endforeach() + elseif(arg STREQUAL "-submodules") + warn_in_per_repo_build("${arg}") + list(POP_FRONT configure_args submodules) + is_non_empty_valid_arg("${arg}" "${submodules}") + list(TRANSFORM submodules REPLACE "," "[[;]]") + push("-DQT_BUILD_SUBMODULES=${submodules}") + elseif(arg STREQUAL "-qt-host-path") + pop_path_argument() + push("-DQT_HOST_PATH=${path}") + elseif(arg STREQUAL "-hostdatadir") + pop_path_argument() + if(NOT path MATCHES "(^|/)mkspecs$") + string(APPEND path "/mkspecs") + endif() + push("-DINSTALL_MKSPECSDIR=${path}") + elseif(arg STREQUAL "-developer-build") + set(developer_build TRUE) + push("-DFEATURE_developer_build=ON") + elseif(arg STREQUAL "-no-prefix") + set(no_prefix_option TRUE) + push("-DFEATURE_no_prefix=ON") + elseif(arg STREQUAL "-cmake-file-api") + set(cmake_file_api TRUE) + elseif(arg STREQUAL "-no-cmake-file-api") + set(cmake_file_api FALSE) + elseif(arg STREQUAL "-verbose") + list(APPEND cmake_args "--log-level=STATUS") + elseif(arg STREQUAL "-disable-deprecated-up-to") + list(POP_FRONT configure_args version) + is_valid_qt_hex_version("${arg}" "${version}") + push("-DQT_DISABLE_DEPRECATED_UP_TO=${version}") + elseif(raw_arg STREQUAL "--") + # Everything after this argument will be passed to CMake verbatim. + list(APPEND cmake_args "${configure_args}") + break() + else() + set_property(GLOBAL APPEND PROPERTY UNHANDLED_ARGS "${raw_arg}") + endif() +endwhile() + +# Read the specified manually generator value from CMake command line. +# The '-cmake-generator' argument has higher priority than CMake command line. +if(NOT generator) + set(is_next_arg_generator_name FALSE) + foreach(arg IN LISTS cmake_args) + if(is_next_arg_generator_name) + set(is_next_arg_generator_name FALSE) + if(NOT arg MATCHES "^-.*") + set(generator "${arg}") + set(auto_detect_generator FALSE) + endif() + elseif(arg MATCHES "^-G(.*)") + set(generator "${CMAKE_MATCH_1}") + if(generator) + set(auto_detect_generator FALSE) + else() + set(is_next_arg_generator_name TRUE) + endif() + endif() + endforeach() +endif() + +# Attempt to detect the generator type, either single or multi-config +if("${generator}" STREQUAL "Xcode" + OR "${generator}" STREQUAL "Ninja Multi-Config" + OR "${generator}" MATCHES "^Visual Studio") + set(multi_config ON) +else() + set(multi_config OFF) +endif() + +# Tell the build system we are configuring via the configure script so we can act on that. +# The cache variable is unset at the end of configuration. +push("-DQT_INTERNAL_CALLED_FROM_CONFIGURE:BOOL=TRUE") + +if(FRESH_REQUESTED) + push("-DQT_INTERNAL_FRESH_REQUESTED:BOOL=TRUE") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24") + push("--fresh") + else() + file(REMOVE_RECURSE "${CMAKE_BINARY_DIR}/CMakeCache.txt" + "${CMAKE_BINARY_DIR}/CMakeFiles") + endif() +endif() + +#################################################################################################### +# Define functions/macros that are called in configure.cmake files +# +# Every function that's called in a configure.cmake file must be defined here. +# Most are empty stubs. +#################################################################################################### + +set_property(GLOBAL PROPERTY COMMANDLINE_KNOWN_FEATURES "") + +function(qt_feature feature) + cmake_parse_arguments(arg "" "PURPOSE;SECTION;" "" ${ARGN}) + set_property(GLOBAL APPEND PROPERTY COMMANDLINE_KNOWN_FEATURES "${feature}") + set_property(GLOBAL PROPERTY COMMANDLINE_FEATURE_PURPOSE_${feature} "${arg_PURPOSE}") + set_property(GLOBAL PROPERTY COMMANDLINE_FEATURE_SECTION_${feature} "${arg_SECTION}") +endfunction() + +function(find_package) + message(FATAL_ERROR "find_package must not be used directly in configure.cmake. " + "Use qt_find_package or guard the call with an if(NOT QT_CONFIGURE_RUNNING) block.") +endfunction() + +macro(defstub name) + function(${name}) + endfunction() +endmacro() + +defstub(qt_add_qmake_lib_dependency) +defstub(qt_config_compile_test) +defstub(qt_config_compile_test_machine_tuple) +defstub(qt_config_compile_test_x86simd) +defstub(qt_config_compiler_supports_flag_test) +defstub(qt_config_linker_supports_flag_test) +defstub(qt_configure_add_report_entry) +defstub(qt_configure_add_summary_build_mode) +defstub(qt_configure_add_summary_build_parts) +defstub(qt_configure_add_summary_build_type_and_config) +defstub(qt_configure_add_summary_entry) +defstub(qt_configure_add_summary_section) +defstub(qt_configure_end_summary_section) +defstub(qt_extra_definition) +defstub(qt_feature_config) +defstub(qt_feature_definition) +defstub(qt_find_package) +defstub(set_package_properties) +defstub(qt_qml_find_python) +defstub(qt_set01) +defstub(qt_internal_check_if_linker_is_available) +defstub(qt_internal_add_sbom) +defstub(qt_internal_extend_sbom) +defstub(qt_internal_sbom_add_license) +defstub(qt_internal_extend_sbom_dependencies) +defstub(qt_find_package_extend_sbom) + +#################################################################################################### +# Define functions/macros that are called in qt_cmdline.cmake files +#################################################################################################### + +unset(commandline_known_options) +unset(commandline_custom_handlers) +set(commandline_nr_of_prefixes 0) + +macro(qt_commandline_subconfig subconfig) + list(APPEND commandline_subconfigs "${subconfig}") +endmacro() + +macro(qt_commandline_custom handler) + list(APPEND commandline_custom_handlers ${handler}) +endmacro() + +function(qt_commandline_option name) + set(options CONTROLS_FEATURE) + set(oneValueArgs TYPE NAME VALUE) + set(multiValueArgs VALUES MAPPING) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(commandline_known_options "${commandline_known_options};${name}" PARENT_SCOPE) + set(commandline_option_${name} "${arg_TYPE}" PARENT_SCOPE) + set(input_name ${name}) + if(NOT "${arg_NAME}" STREQUAL "") + set(input_name ${arg_NAME}) + set(commandline_option_${name}_variable "${arg_NAME}" PARENT_SCOPE) + endif() + set(mapping_type "${arg_TYPE}") + if(arg_CONTROLS_FEATURE) + set(mapping_type "boolean") + endif() + set_property(GLOBAL PROPERTY INPUTTYPE_${input_name} "${mapping_type}") + if(NOT "${arg_VALUE}" STREQUAL "") + set(commandline_option_${name}_value "${arg_VALUE}" PARENT_SCOPE) + endif() + if(arg_VALUES) + set(commandline_option_${name}_values ${arg_VALUES} PARENT_SCOPE) + elseif(arg_MAPPING) + set(commandline_option_${name}_mapping ${arg_MAPPING} PARENT_SCOPE) + endif() +endfunction() + +# Add the common command line options for every qt repo. +macro(qt_add_common_commandline_options) + qt_commandline_option(headersclean TYPE boolean) + qt_commandline_option(sbom TYPE boolean) + qt_commandline_option(sbom-json TYPE boolean) + qt_commandline_option(sbom-json-required TYPE boolean) + qt_commandline_option(sbom-verify TYPE boolean) + qt_commandline_option(sbom-verify-required TYPE boolean) +endmacro() + +function(qt_commandline_prefix arg var) + set(idx ${commandline_nr_of_prefixes}) + set(commandline_prefix_${idx} "${arg}" "${var}" PARENT_SCOPE) + math(EXPR n "${commandline_nr_of_prefixes} + 1") + set(commandline_nr_of_prefixes ${n} PARENT_SCOPE) +endfunction() + +# Check the following variable in configure.cmake files to guard code that is not covered by the +# stub functions above. +set(QT_CONFIGURE_RUNNING ON) + + +#################################################################################################### +# Load qt_cmdline.cmake files +#################################################################################################### + +qt_add_common_commandline_options() + +while(commandline_files) + list(POP_FRONT commandline_files commandline_file) + get_filename_component(commandline_file_directory "${commandline_file}" DIRECTORY) + set(configure_file "${commandline_file_directory}/${configure_filename}") + unset(commandline_subconfigs) + if(EXISTS "${configure_file}") + include("${configure_file}") + endif() + if(EXISTS "${commandline_file}") + include("${commandline_file}") + endif() + + if(commandline_subconfigs) + list(TRANSFORM commandline_subconfigs PREPEND "${commandline_file_directory}/") + list(TRANSFORM commandline_subconfigs APPEND "/${commandline_filename}") + list(PREPEND commandline_files "${commandline_subconfigs}") + endif() +endwhile() + +get_property(commandline_known_features GLOBAL PROPERTY COMMANDLINE_KNOWN_FEATURES) + +#################################################################################################### +# Process the data from the qt_cmdline.cmake files +#################################################################################################### + +function(qtConfAddNote) + message(${ARGV}) +endfunction() + +function(qtConfAddWarning) + message(WARNING ${ARGV}) +endfunction() + +function(qtConfAddError) + message(FATAL_ERROR ${ARGV}) +endfunction() + +set_property(GLOBAL PROPERTY CONFIG_INPUTS "") + +function(qtConfCommandlineSetInput name val) + if(NOT "${commandline_option_${name}_variable}" STREQUAL "") + set(name "${commandline_option_${name}_variable}") + endif() + if(NOT "${INPUT_${name}}" STREQUAL "") + set(oldval "${INPUT_${name}}") + if("${oldval}" STREQUAL "${val}") + qtConfAddNote("Option '${name}' with value '${val}' was specified twice") + else() + qtConfAddNote("Overriding option '${name}' with '${val}' (was: '${oldval}')") + endif() + endif() + + set_property(GLOBAL PROPERTY INPUT_${name} "${val}") + set_property(GLOBAL APPEND PROPERTY CONFIG_INPUTS ${name}) +endfunction() + +function(qtConfCommandlineAppendInput name val) + get_property(oldval GLOBAL PROPERTY INPUT_${name}) + if(NOT "${oldval}" STREQUAL "") + string(PREPEND val "${oldval};") + endif() + qtConfCommandlineSetInput(${name} "${val}") +endfunction() + +function(qtConfCommandlineSetInputType input_name type_name) + set_property(GLOBAL PROPERTY INPUTTYPE_${input_name} "${type_name}") +endfunction() + +function(qtConfCommandlineSetBooleanInput name val) + qtConfCommandlineSetInput(${name} ${val}) + qtConfCommandlineSetInputType(${name} boolean) +endfunction() + +function(qtConfCommandlineEnableFeature name) + qtConfCommandlineSetBooleanInput(${name} yes) +endfunction() + +function(qtConfCommandlineDisableFeature name) + qtConfCommandlineSetBooleanInput(${name} no) +endfunction() + +function(qtConfValidateValue opt val out_var) + set(${out_var} TRUE PARENT_SCOPE) + + set(valid_values ${commandline_option_${arg}_values}) + list(LENGTH valid_values n) + if(n EQUAL 0) + return() + endif() + + foreach(v ${valid_values}) + if(val STREQUAL v) + return() + endif() + endforeach() + + set(${out_var} FALSE PARENT_SCOPE) + list(JOIN valid_values " " valid_values_str) + qtConfAddError("Invalid value '${val}' supplied to command line option '${opt}'." + "\nAllowed values: ${valid_values_str}\n") +endfunction() + +function(qt_commandline_mapped_enum_value opt key out_var) + unset(result) + set(mapping ${commandline_option_${opt}_mapping}) + while(mapping) + list(POP_FRONT mapping mapping_key) + list(POP_FRONT mapping mapping_value) + if(mapping_key STREQUAL key) + set(result "${mapping_value}") + break() + endif() + endwhile() + set(${out_var} "${result}" PARENT_SCOPE) +endfunction() + +function(qtConfHasNextCommandlineArg out_var) + get_property(args GLOBAL PROPERTY UNHANDLED_ARGS) + list(LENGTH args n) + if(n GREATER 0) + set(result TRUE) + else() + set(result FALSE) + endif() + set(${out_var} ${result} PARENT_SCOPE) +endfunction() + +function(qtConfPeekNextCommandlineArg out_var) + get_property(args GLOBAL PROPERTY UNHANDLED_ARGS) + list(GET args 0 result) + set(${out_var} ${result} PARENT_SCOPE) +endfunction() + +function(qtConfGetNextCommandlineArg out_var) + get_property(args GLOBAL PROPERTY UNHANDLED_ARGS) + list(POP_FRONT args result) + set_property(GLOBAL PROPERTY UNHANDLED_ARGS ${args}) + set(${out_var} ${result} PARENT_SCOPE) +endfunction() + +function(qt_commandline_boolean arg val nextok) + if("${val}" STREQUAL "") + set(val "yes") + endif() + if(NOT val STREQUAL "yes" AND NOT val STREQUAL "no") + message(FATAL_ERROR "Invalid value '${val}' given for boolean command line option '${arg}'.") + endif() + qtConfCommandlineSetInput("${arg}" "${val}") +endfunction() + +function(qt_commandline_string arg val nextok) + if(nextok) + qtConfGetNextCommandlineArg(val) + if("${val}" MATCHES "^-") + qtConfAddError("No value supplied to command line options '${opt}'.") + endif() + endif() + qtConfValidateValue("${opt}" "${val}" success) + if(success) + qtConfCommandlineSetInput("${opt}" "${val}") + endif() +endfunction() + +function(qt_commandline_optionalString arg val nextok) + if("${val}" STREQUAL "") + if(nextok) + qtConfPeekNextCommandlineArg(val) + endif() + if(val MATCHES "^-.*|[A-Z0-9_+]=.*" OR val STREQUAL "") + set(val "yes") + else() + qtConfGetNextCommandlineArg(val) + endif() + endif() + qtConfValidateValue("${arg}" "${val}" success) + if(success) + qtConfCommandlineSetInput("${arg}" "${val}") + endif() +endfunction() + +function(qt_commandline_addString arg val nextok) + if("${val}" STREQUAL "" AND nextok) + qtConfGetNextCommandlineArg(val) + endif() + if(val MATCHES "^-.*" OR val STREQUAL "") + qtConfAddError("No value supplied to command line option '${arg}'.") + endif() + qtConfValidateValue("${arg}" "${val}" success) + if(success) + if(DEFINED command_line_option_${arg}_variable) + set(arg ${command_line_option_${arg}_variable}) + endif() + set_property(GLOBAL APPEND PROPERTY "INPUT_${arg}" "${val}") + set_property(GLOBAL APPEND PROPERTY CONFIG_INPUTS ${arg}) + endif() +endfunction() + +function(qt_commandline_enum arg val nextok) + if("${val}" STREQUAL "") + set(val "yes") + endif() + unset(mapped) + if(DEFINED "commandline_option_${arg}_mapping") + qt_commandline_mapped_enum_value("${arg}" "${val}" mapped) + elseif(DEFINED "commandline_option_${arg}_values") + if(val IN_LIST commandline_option_${arg}_values) + set(mapped ${val}) + endif() + endif() + if("${mapped}" STREQUAL "") + qtConfAddError("Invalid value '${val}' supplied to command line option '${arg}'.") + endif() + qtConfCommandlineSetInput("${arg}" "${mapped}") +endfunction() + +function(qt_commandline_void arg val nextok) + if(NOT "${val}" STREQUAL "") + qtConfAddError("Command line option '${arg}' expects no argument ('${val}' given).") + endif() + if(DEFINED commandline_option_${arg}_value) + set(val ${commandline_option_${arg}_value}) + endif() + if("${val}" STREQUAL "") + set(val yes) + endif() + qtConfCommandlineSetInput("${arg}" "${val}") +endfunction() + +function(qt_call_function func) + set(call_code "${func}(") + math(EXPR n "${ARGC} - 1") + foreach(i RANGE 1 ${n}) + string(APPEND call_code "\"${ARGV${i}}\" ") + endforeach() + string(APPEND call_code ")") + string(REPLACE "\\" "\\\\" call_code "${call_code}") + if(${CMAKE_VERSION} VERSION_LESS "3.18.0") + set(incfile qt_tmp_func_call.cmake) + file(WRITE "${incfile}" "${call_code}") + include(${incfile}) + file(REMOVE "${incfile}") + else() + cmake_language(EVAL CODE "${call_code}") + endif() +endfunction() + +if(display_module_help) + message([[ +Options: + -help, -h ............ Display this help screen + + -feature- ... Enable + -no-feature- Disable [none] + -list-features ....... List available features. Note that some features + have dedicated command line options as well. +]]) + + set(help_file "${MODULE_ROOT}/config_help.txt") + if(EXISTS "${help_file}") + file(READ "${help_file}" content) + message("${content}") + endif() + + return() +endif() + +if(list_features) + unset(lines) + foreach(feature ${commandline_known_features}) + get_property(section GLOBAL PROPERTY COMMANDLINE_FEATURE_SECTION_${feature}) + get_property(purpose GLOBAL PROPERTY COMMANDLINE_FEATURE_PURPOSE_${feature}) + if(purpose) + if(NOT "${section}" STREQUAL "") + string(APPEND section ": ") + endif() + qt_configure_get_padded_string("${feature}" "${section}${purpose}" line + PADDING_LENGTH 25 MIN_PADDING 1) + list(APPEND lines "${line}") + endif() + endforeach() + list(SORT lines) + list(JOIN lines "\n" lines) + message("${lines}") + return() +endif() + +function(write_options_json_file) + if(qtbase_or_top_level_build) + # Add options that are handled directly by this script. + qt_commandline_option(qt-host-path TYPE string) + qt_commandline_option(no-guess-compiler TYPE void) + endif() + + set(indent " ") + set(content + "{" + "${indent}\"options\": {") + string(APPEND indent " ") + list(LENGTH commandline_known_options commandline_known_options_length) + set(i 1) + foreach(opt ${commandline_known_options}) + list(APPEND content "${indent}\"${opt}\": {") + string(APPEND indent " ") + list(APPEND content "${indent}\"type\": \"${commandline_option_${opt}}\",") + if(NOT "${commandline_option_${opt}_values}" STREQUAL "") + set(values "${commandline_option_${opt}_values}") + list(TRANSFORM values PREPEND "\"") + list(TRANSFORM values APPEND "\"") + list(JOIN values ", " values) + list(APPEND content "${indent}\"values\": [${values}]") + elseif(NOT "${commandline_option_${opt}_mapping}" STREQUAL "") + list(LENGTH commandline_option_${opt}_mapping last) + math(EXPR last "${last} - 1") + set(values "") + list(APPEND content "${indent}\"values\": [") + foreach(k RANGE 0 "${last}" 2) + list(GET commandline_option_${opt}_mapping ${k} value) + list(APPEND values ${value}) + endforeach() + list(TRANSFORM values PREPEND "\"") + list(TRANSFORM values APPEND "\"") + list(JOIN values ", " values) + list(APPEND content + "${indent} ${values}" + "${indent}]") + else() + list(APPEND content "${indent}\"values\": []") + endif() + string(SUBSTRING "${indent}" 4 -1 indent) + math(EXPR i "${i} + 1") + if(i LESS commandline_known_options_length) + list(APPEND content "${indent}},") + else() + list(APPEND content "${indent}}") + endif() + endforeach() + string(SUBSTRING "${indent}" 4 -1 indent) + + set(features ${commandline_known_features}) + list(TRANSFORM features PREPEND "\"") + list(TRANSFORM features APPEND "\"") + list(JOIN features ", " features) + + list(APPEND content + "${indent}}," + "${indent}\"features\": [${features}]" + "}") + string(REPLACE ";" "\n" content "${content}") + file(WRITE "${options_json_file}" "${content}") +endfunction() + +if(options_json_file) + write_options_json_file() + return() +endif() + +set(cmake_var_assignments) + +while(1) + qtConfHasNextCommandlineArg(has_next) + if(NOT has_next) + break() + endif() + qtConfGetNextCommandlineArg(arg) + + set(handled FALSE) + foreach(func ${commandline_custom_handlers}) + qt_call_function("qt_commandline_${func}" handled "${arg}") + if(handled) + break() + endif() + endforeach() + if(handled) + continue() + endif() + + # Handle variable assignments + if(arg MATCHES "^([a-zA-Z0-9_][a-zA-Z0-9_-]*)=(.*)") + list(APPEND cmake_var_assignments "${arg}") + continue() + endif() + + # parse out opt and val + set(nextok FALSE) + if(arg MATCHES "^--?enable-(.*)") + set(opt "${CMAKE_MATCH_1}") + set(val "yes") + # Handle builtin [-no]-feature-xxx + elseif(arg MATCHES "^--?(no-)?feature-(.*)") + set(opt "${CMAKE_MATCH_2}") + if(NOT opt IN_LIST commandline_known_features) + qtConfAddError("Enabling/Disabling unknown feature '${opt}'.") + endif() + if("${CMAKE_MATCH_1}" STREQUAL "") + set(val "ON") + else() + set(val "OFF") + endif() + qt_feature_normalize_name("${opt}" normalized_feature_name) + push(-DFEATURE_${normalized_feature_name}=${val}) + continue() + elseif(arg MATCHES "^--?(disable|no)-(.*)") + set(opt "${CMAKE_MATCH_2}") + set(val "no") + elseif(arg MATCHES "^--([^=]+)=(.*)") + set(opt "${CMAKE_MATCH_1}") + set(val "${CMAKE_MATCH_2}") + elseif(arg MATCHES "^--(.*)") + set(opt "${CMAKE_MATCH_1}") + unset(val) + elseif(arg MATCHES "^-(.*)") + set(nextok TRUE) + set(opt "${CMAKE_MATCH_1}") + unset(val) + if(NOT DEFINED commandline_option_${opt} AND opt MATCHES "(qt|system)-(.*)") + set(opt "${CMAKE_MATCH_2}") + set(val "${CMAKE_MATCH_1}") + endif() + else() + qtConfAddError("Invalid command line parameter '${arg}'.") + endif() + + set(type ${commandline_option_${opt}}) + if("${type}" STREQUAL "") + # No match in the regular options, try matching the prefixes + math(EXPR n "${commandline_nr_of_prefixes} - 1") + foreach(i RANGE ${n}) + list(GET commandline_prefix_${i} 0 pfx) + if(arg MATCHES "^-${pfx}(.*)") + list(GET commandline_prefix_${i} 1 opt) + set(val "${CMAKE_MATCH_1}") + set(type addString) + break() + endif() + endforeach() + endif() + + if("${type}" STREQUAL "") + qtConfAddError("Unknown command line option '${arg}'.") + endif() + + if(NOT COMMAND "qt_commandline_${type}") + qtConfAddError("Unknown type '${type}' for command line option '${opt}'.") + endif() + qt_call_function("qt_commandline_${type}" "${opt}" "${val}" "${nextok}") +endwhile() + +#################################################################################################### +# Translate some of the INPUT_xxx values to CMake arguments +#################################################################################################### + +# Turn the global properties into proper variables +get_property(config_inputs GLOBAL PROPERTY CONFIG_INPUTS) +list(REMOVE_DUPLICATES config_inputs) +foreach(var ${config_inputs}) + get_property(INPUT_${var} GLOBAL PROPERTY INPUT_${var}) + if("${commandline_input_type}" STREQUAL "") + get_property(commandline_input_${var}_type GLOBAL PROPERTY INPUTTYPE_${var}) + endif() +endforeach() + +macro(drop_input name) + list(REMOVE_ITEM config_inputs ${name}) +endmacro() + +macro(translate_boolean_input name cmake_var) + if("${INPUT_${name}}" STREQUAL "yes") + push("-D${cmake_var}=ON") + drop_input(${name}) + elseif("${INPUT_${name}}" STREQUAL "no") + push("-D${cmake_var}=OFF") + drop_input(${name}) + endif() +endmacro() + +macro(translate_string_input name cmake_var) + if(DEFINED INPUT_${name}) + push("-D${cmake_var}=${INPUT_${name}}") + drop_input(${name}) + endif() +endmacro() + +macro(translate_path_input name cmake_var) + if(DEFINED INPUT_${name}) + set(path "${INPUT_${name}}") + string(REGEX REPLACE "^\"(.*)\"$" "\\1" path "${path}") + file(TO_CMAKE_PATH "${path}" path) + push("-D${cmake_var}=${path}") + drop_input(${name}) + endif() +endmacro() + +macro(translate_list_input name cmake_var) + if(DEFINED INPUT_${name}) + list(JOIN INPUT_${name} "[[;]]" value) + list(APPEND cmake_args "-D${cmake_var}=${value}") + drop_input(${name}) + endif() +endmacro() + +# Check whether to guess the compiler for the given language. +# +# Sets ${out_var} to FALSE if one of the following holds: +# - the environment variable ${env_var} is non-empty +# - the CMake variable ${cmake_var} is set on the command line +# +# Otherwise, ${out_var} is set to TRUE. +function(check_whether_to_guess_compiler out_var env_var cmake_var) + set(result TRUE) + if(NOT "$ENV{${env_var}}" STREQUAL "") + set(result FALSE) + else() + set(filtered_args ${cmake_args}) + list(FILTER filtered_args INCLUDE REGEX "^(-D)?${cmake_var}=") + if(NOT "${filtered_args}" STREQUAL "") + set(result FALSE) + endif() + endif() + set(${out_var} ${result} PARENT_SCOPE) +endfunction() + +# Try to guess the mkspec from the -platform configure argument. +function(guess_compiler_from_mkspec) + if(NOT auto_detect_compiler) + return() + endif() + + check_whether_to_guess_compiler(guess_c_compiler CC CMAKE_C_COMPILER) + check_whether_to_guess_compiler(guess_cxx_compiler CXX CMAKE_CXX_COMPILER) + if(NOT guess_c_compiler AND NOT guess_cxx_compiler) + return() + endif() + + string(REGEX MATCH "(^|;)-DQT_QMAKE_TARGET_MKSPEC=\([^;]+\)" m "${cmake_args}") + set(mkspec ${CMAKE_MATCH_2}) + set(c_compiler "") + set(cxx_compiler "") + if(mkspec MATCHES "-clang-msvc$") + set(c_compiler "clang-cl") + set(cxx_compiler "clang-cl") + elseif(mkspec MATCHES "-clang(-|$)" AND NOT mkspec MATCHES "android") + set(c_compiler "clang") + set(cxx_compiler "clang++") + elseif(mkspec MATCHES "-msvc(-|$)") + set(c_compiler "cl") + set(cxx_compiler "cl") + endif() + if(guess_c_compiler AND NOT c_compiler STREQUAL "") + push("-DCMAKE_C_COMPILER=${c_compiler}") + endif() + if(guess_cxx_compiler AND NOT cxx_compiler STREQUAL "") + push("-DCMAKE_CXX_COMPILER=${cxx_compiler}") + endif() + if(mkspec MATCHES "-libc\\+\\+$") + push("-DFEATURE_stdlib_libcpp=ON") + endif() + set(cmake_args "${cmake_args}" PARENT_SCOPE) +endfunction() + +function(check_qt_build_parts type) + set(input "INPUT_${type}") + set(buildFlag "TRUE") + if("${type}" STREQUAL "nomake") + set(buildFlag "FALSE") + endif() + + list(APPEND knownParts "tests" "examples" "benchmarks" "manual-tests" "minimal-static-tests") + + foreach(part ${${input}}) + if(part IN_LIST knownParts) + qt_feature_normalize_name("${part}" partUpperCase) + string(TOUPPER "${partUpperCase}" partUpperCase) + push("-DQT_BUILD_${partUpperCase}=${buildFlag}") + continue() + elseif("${part}" STREQUAL "tools" AND "${type}" STREQUAL "make") + # default true ignored + continue() + endif() + qtConfAddWarning("'-${type} ${part}' is not implemented yet.") + endforeach() + set(cmake_args "${cmake_args}" PARENT_SCOPE) +endfunction() + +drop_input(commercial) +drop_input(confirm-license) +translate_boolean_input(precompile_header BUILD_WITH_PCH) +translate_boolean_input(unity_build QT_UNITY_BUILD) +translate_string_input(unity_build_batch_size QT_UNITY_BUILD_BATCH_SIZE) +translate_boolean_input(ccache QT_USE_CCACHE) +translate_boolean_input(vcpkg QT_USE_VCPKG) +translate_boolean_input(sbom QT_GENERATE_SBOM) +translate_boolean_input(sbom-json QT_SBOM_GENERATE_JSON) +translate_boolean_input(sbom-json-required QT_SBOM_REQUIRE_GENERATE_JSON) +translate_boolean_input(sbom-verify QT_SBOM_VERIFY) +translate_boolean_input(sbom-verify-required QT_SBOM_REQUIRE_VERIFY) +translate_boolean_input(shared BUILD_SHARED_LIBS) +translate_boolean_input(warnings_are_errors WARNINGS_ARE_ERRORS) +translate_boolean_input(qtinlinenamespace QT_INLINE_NAMESPACE) +translate_string_input(qt_namespace QT_NAMESPACE) +translate_string_input(qt_libinfix QT_LIBINFIX) +translate_string_input(qreal QT_COORD_TYPE) +translate_path_input(prefix CMAKE_INSTALL_PREFIX) +translate_path_input(extprefix CMAKE_STAGING_PREFIX) +foreach(kind bin lib archdata libexec qml data doc sysconf examples tests) + string(TOUPPER ${kind} uc_kind) + translate_path_input(${kind}dir INSTALL_${uc_kind}DIR) +endforeach() +translate_path_input(headerdir INSTALL_INCLUDEDIR) +translate_path_input(plugindir INSTALL_PLUGINSDIR) +translate_path_input(translationdir INSTALL_TRANSLATIONSDIR) +translate_path_input(sbomdir INSTALL_SBOMDIR) + +if(NOT "${INPUT_device}" STREQUAL "") + push("-DQT_QMAKE_TARGET_MKSPEC=devices/${INPUT_device}") + drop_input(device) +endif() +translate_string_input(platform QT_QMAKE_TARGET_MKSPEC) +translate_string_input(xplatform QT_QMAKE_TARGET_MKSPEC) +guess_compiler_from_mkspec() +translate_string_input(qpa_default_platform QT_QPA_DEFAULT_PLATFORM) +translate_list_input(qpa_platforms QT_QPA_PLATFORMS) + +translate_path_input(android-sdk ANDROID_SDK_ROOT) +translate_path_input(android-ndk ANDROID_NDK_ROOT) +if(DEFINED INPUT_android-ndk-platform) + drop_input(android-ndk-platform) + push("-DANDROID_PLATFORM=${INPUT_android-ndk-platform}") +endif() +if(DEFINED INPUT_android-abis) + if(INPUT_android-abis MATCHES ",") + qtConfAddError("The -android-abis option cannot handle more than one ABI " + "when building with CMake.") + endif() + translate_string_input(android-abis ANDROID_ABI) +endif() +translate_string_input(android-javac-source QT_ANDROID_JAVAC_SOURCE) +translate_string_input(android-javac-target QT_ANDROID_JAVAC_TARGET) + +translate_string_input(sdk QT_APPLE_SDK) + +drop_input(make) +drop_input(nomake) +translate_boolean_input(install-examples-sources QT_INSTALL_EXAMPLES_SOURCES) + +check_qt_build_parts(nomake) +check_qt_build_parts(make) + +drop_input(debug) +drop_input(release) +drop_input(debug_and_release) +drop_input(force_debug_info) +unset(build_configs) +if(INPUT_debug) + set(build_configs Debug) +elseif("${INPUT_debug}" STREQUAL "no") + set(build_configs Release) +elseif(INPUT_debug_and_release) + set(build_configs Release Debug) +endif() +if(INPUT_force_debug_info) + list(TRANSFORM build_configs REPLACE "^Release$" "RelWithDebInfo") +endif() + +# Code coverage handling +drop_input(gcov) +if(INPUT_gcov) + if(NOT "${INPUT_coverage}" STREQUAL "") + if(NOT "${INPUT_coverage}" STREQUAL "gcov") + qtConfAddError("The -gcov argument is provided, but -coverage is set" + " to ${INPUT_coverage}") + endif() + else() + set(INPUT_coverage "gcov") + list(APPEND config_inputs coverage) + endif() +endif() +if(NOT "${INPUT_coverage}" STREQUAL "") + if(build_configs) + if(NOT "Debug" IN_LIST build_configs) + qtConfAddError("The -coverage argument requires Qt configured with 'Debug' config.") + endif() + else() + set(build_configs "Debug") + endif() +endif() + +list(LENGTH build_configs nr_of_build_configs) +if(nr_of_build_configs EQUAL 1 AND NOT multi_config) + push("-DCMAKE_BUILD_TYPE=${build_configs}") +elseif(nr_of_build_configs GREATER 1 OR multi_config) + set(multi_config ON) + string(REPLACE ";" "[[;]]" escaped_build_configs "${build_configs}") + # We must not use the push macro here to avoid variable expansion. + # That would destroy our escaping. + list(APPEND cmake_args "-DCMAKE_CONFIGURATION_TYPES=${escaped_build_configs}") +endif() + +drop_input(ltcg) +if("${INPUT_ltcg}" STREQUAL "yes") + foreach(config ${build_configs}) + string(TOUPPER "${config}" ucconfig) + if(NOT ucconfig STREQUAL "DEBUG") + push("-DCMAKE_INTERPROCEDURAL_OPTIMIZATION_${ucconfig}=ON") + endif() + endforeach() +endif() + +translate_list_input(device-option QT_QMAKE_DEVICE_OPTIONS) +translate_list_input(defines QT_EXTRA_DEFINES) +translate_list_input(fpaths QT_EXTRA_FRAMEWORKPATHS) +translate_list_input(includes QT_EXTRA_INCLUDEPATHS) +translate_list_input(lpaths QT_EXTRA_LIBDIRS) +translate_list_input(rpaths QT_EXTRA_RPATHS) + +if(cmake_file_api OR (developer_build AND NOT DEFINED cmake_file_api)) + foreach(file cache-v2 cmakeFiles-v1 codemodel-v2 toolchains-v1) + file(WRITE "${CMAKE_BINARY_DIR}/.cmake/api/v1/query/${file}" "") + endforeach() +endif() + +# Translate unhandled input variables to either -DINPUT_foo=value or -DFEATURE_foo=ON/OFF. If the +# input's name matches a feature name and the corresponding command-line option's type is boolean +# then we assume it's controlling a feature. +foreach(input ${config_inputs}) + qt_feature_normalize_name("${input}" cmake_input) + if("${commandline_input_${input}_type}" STREQUAL "boolean" + AND input IN_LIST commandline_known_features) + translate_boolean_input("${input}" "FEATURE_${cmake_input}") + else() + push("-DINPUT_${cmake_input}=${INPUT_${input}}") + endif() +endforeach() + +if(no_prefix_option AND DEFINED INPUT_prefix) + qtConfAddError("Can't specify both -prefix and -no-prefix options at the same time.") +endif() + +if(NOT generator AND auto_detect_generator) + find_program(ninja ninja) + if(ninja) + set(generator Ninja) + if(multi_config) + string(APPEND generator " Multi-Config") + endif() + else() + if(CMAKE_HOST_UNIX) + set(generator "Unix Makefiles") + elseif(CMAKE_HOST_WIN32) + find_program(msvc_compiler cl.exe) + if(msvc_compiler) + set(generator "NMake Makefiles") + find_program(jom jom) + if(jom) + string(APPEND generator " JOM") + endif() + else() + set(generator "MinGW Makefiles") + endif() + endif() + endif() +endif() + +if(multi_config + AND NOT "${generator}" STREQUAL "Xcode" + AND NOT "${generator}" STREQUAL "Ninja Multi-Config" + AND NOT "${generator}" MATCHES "^Visual Studio") + message(FATAL_ERROR "Multi-config build is only supported by Xcode, Ninja Multi-Config and \ +Visual Studio generators. Current generator is \"${generator}\". +Note: Use '-cmake-generator ' option to specify the generator manually.") +endif() + +if(generator) + push(-G "${generator}") +endif() + +# Add CMake variable assignments near the end to allow users to overwrite what configure sets. +foreach(arg IN LISTS cmake_var_assignments) + push("-D${arg}") +endforeach() + +push("${MODULE_ROOT}") + +if(INPUT_sysroot) + qtConfAddWarning("The -sysroot option is deprecated and no longer has any effect. " + "It is recommended to use a toolchain file instead, i.e., " + "-DCMAKE_TOOLCHAIN_FILE=. " + "Alternatively, you may use -DCMAKE_SYSROOT option " + "to pass the sysroot to CMake.\n") +endif() + +# Restore the escaped semicolons in arguments that are lists +list(TRANSFORM cmake_args REPLACE "\\[\\[;\\]\\]" "\\\\;") + +execute_process(COMMAND "${CMAKE_COMMAND}" ${cmake_args} + COMMAND_ECHO STDOUT + RESULT_VARIABLE exit_code) +if(NOT exit_code EQUAL 0) + message(FATAL_ERROR "CMake exited with code ${exit_code}.") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtProperties.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtProperties.cmake new file mode 100644 index 0000000000000000000000000000000000000000..40b481d6f08c3d16cd902fe0b5ef719bccab7994 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtProperties.cmake @@ -0,0 +1,111 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +define_property(TARGET + PROPERTY + QT_PLUGINS + BRIEF_DOCS + "List of Qt plug-ins associated with a given Qt module." + FULL_DOCS + "This is a property on Qt modules. + For instance, sqlite;odbc for Sql" +) + +define_property(TARGET + PROPERTY + MODULE_PLUGIN_TYPES + BRIEF_DOCS + "List of plugin categories associated to the Qt module" + FULL_DOCS + "This is a property on Qt modules. + For instance, sqldrivers for Sql." +) + +define_property(TARGET + PROPERTY + QT_PLUGIN_CLASS_NAME + BRIEF_DOCS + "Class name of the Qt plug-in" + FULL_DOCS + "This is a property on Qt plug-ins. + For instance, QICOPlugin for the qico plug-in" +) + +define_property(TARGET + PROPERTY + QT_PLUGIN_TYPE + BRIEF_DOCS + "Type of the Qt plug-in" + FULL_DOCS + "This is a property on Qt plug-ins. + For example, the value of the QT_PLUGIN_TYPE property on the qico plugin is \"imageformats\"" +) + +define_property(TARGET + PROPERTY + QT_MODULE + BRIEF_DOCS + "Qt module associated with a plug-in." + FULL_DOCS + "This is a property on Qt plug-ins. + For instance, Sql for qsqlite" +) + +define_property(TARGET + PROPERTY + QT_DEFAULT_PLUGIN + BRIEF_DOCS + "Indicates whether a plug-in is added by default." + FULL_DOCS + "This is a property on Qt plug-ins. + It is mainly used to indicate if a plug-in should be added + to the default set of plug-ins when building a static app - + for instance, which QPA should be linked." +) + +define_property(TARGET + PROPERTY + QT_QML_MODULE_TARGET_PATH + BRIEF_DOCS + "Specifies the target path for a qml module" + FULL_DOCS + "Specifies the target path for a qml module" +) + +define_property(TARGET + PROPERTY + QT_QML_MODULE_URI + BRIEF_DOCS + "Specifies the URI for a qml module" + FULL_DOCS + "Specifies the URI for a qml module" +) + +define_property(TARGET + PROPERTY + QT_RESOURCE_PREFIX + BRIEF_DOCS + "Specifies the default Qt resource prefix." + FULL_DOCS + "When using qt_add_resource() without a PREFIX, then prefix of this target property + will be used." +) + +define_property(TARGET + PROPERTY + QT_QML_MODULE_VERSION + BRIEF_DOCS + "Specifies the qml module's version." + FULL_DOCS + "Specifies the qml module's version." +) + +define_property(GLOBAL + PROPERTY + QT_TARGETS_FOLDER + BRIEF_DOCS + "Name of the FOLDER for targets internally created by AUTOGEN and Qt's CMake API." + FULL_DOCS + "This property is used to initialize AUTOGEN_TARGETS_FOLDER and the FOLDER property of + internal targets created by Qt's CMake commands." +) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicAppleHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicAppleHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..45c114e9f68b072577fea11908f10f3275004013 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicAppleHelpers.cmake @@ -0,0 +1,1016 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(_qt_internal_handle_ios_launch_screen target) + # Check if user provided a launch screen path via a variable. + set(launch_screen "") + + # Check if the project provided a launch screen path via a variable. + # This variable is currently in Technical Preview. + if(QT_IOS_LAUNCH_SCREEN) + set(launch_screen "${QT_IOS_LAUNCH_SCREEN}") + endif() + + # Check if the project provided a launch screen path via a target property, it takes precedence + # over the variable. + # This property is currently in Technical Preview. + get_target_property(launch_screen_from_prop "${target}" QT_IOS_LAUNCH_SCREEN) + if(launch_screen_from_prop) + set(launch_screen "${launch_screen_from_prop}") + endif() + + # If the project hasn't provided a launch screen file path, use a copy of the template + # that qmake uses. + # It needs to be a copy because configure_file can't handle all the escaped double quotes + # present in the qmake template file. + set(is_default_launch_screen FALSE) + if(NOT launch_screen AND NOT QT_NO_SET_DEFAULT_IOS_LAUNCH_SCREEN) + set(is_default_launch_screen TRUE) + set(launch_screen + "${__qt_internal_cmake_apple_support_files_path}/LaunchScreen.storyboard") + endif() + + # Check that the launch screen exists. + if(launch_screen) + if(NOT IS_ABSOLUTE "${launch_screen}") + message(FATAL_ERROR + "Provided launch screen value should be an absolute path: '${launch_screen}'") + endif() + + if(NOT EXISTS "${launch_screen}") + message(FATAL_ERROR + "Provided launch screen file does not exist: '${launch_screen}'") + endif() + endif() + + if(launch_screen AND NOT QT_NO_ADD_IOS_LAUNCH_SCREEN_TO_BUNDLE) + get_filename_component(launch_screen_name "${launch_screen}" NAME) + + # Make a copy of the default launch screen template for this target and replace the + # label inside the template with the target name. + if(is_default_launch_screen) + # Configure our default template and place it in the build dir. + set(launch_screen_in_path "${launch_screen}") + + string(MAKE_C_IDENTIFIER "${target}" target_identifier) + set(launch_screen_out_dir + "${CMAKE_CURRENT_BINARY_DIR}/.qt/launch_screen_storyboards/${target_identifier}") + + set(launch_screen_out_path + "${launch_screen_out_dir}/${launch_screen_name}") + + file(MAKE_DIRECTORY "${launch_screen_out_dir}") + + configure_file("${launch_screen_in_path}" "${launch_screen_out_path}" COPYONLY) + + set(final_launch_screen_path "${launch_screen_out_path}") + else() + set(final_launch_screen_path "${launch_screen}") + endif() + + # Add the launch screen storyboard file as a source file, otherwise CMake doesn't consider + # it as a resource file and MACOSX_PACKAGE_LOCATION processing will be skipped. + target_sources("${target}" PRIVATE "${final_launch_screen_path}") + + # Ensure Xcode compiles the storyboard file and installs the compiled storyboard .nib files + # into the app bundle. + # We use target_sources and the MACOSX_PACKAGE_LOCATION source file property for that + # instead of the RESOURCE target property, becaues the latter could potentially end up + # needlessly installing the source storyboard file. + # + # We can't rely on policy CMP0118 since user project controls it. + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${target}) + endif() + set_source_files_properties("${final_launch_screen_path}" ${scope_args} + PROPERTIES MACOSX_PACKAGE_LOCATION Resources) + + # Save the launch screen name, so its value is added as an UILaunchStoryboardName entry + # in the Qt generated Info.plist file. + # Xcode expects an Info.plist storyboard entry without an extension. + get_filename_component(launch_screen_base_name "${launch_screen}" NAME_WE) + set_target_properties("${target}" PROPERTIES + _qt_ios_launch_screen_name "${launch_screen_name}" + _qt_ios_launch_screen_base_name "${launch_screen_base_name}" + _qt_ios_launch_screen_path "${final_launch_screen_path}") + endif() +endfunction() + +function(_qt_internal_find_ios_development_team_id out_var) + get_property(team_id GLOBAL PROPERTY _qt_internal_ios_development_team_id) + get_property(team_id_computed GLOBAL PROPERTY _qt_internal_ios_development_team_id_computed) + if(team_id_computed) + # Just in case if the value is non-empty but still booly FALSE. + if(NOT team_id) + set(team_id "") + endif() + set("${out_var}" "${team_id}" PARENT_SCOPE) + return() + endif() + + set_property(GLOBAL PROPERTY _qt_internal_ios_development_team_id_computed "TRUE") + + set(home_dir "$ENV{HOME}") + set(xcode_preferences_path "${home_dir}/Library/Preferences/com.apple.dt.Xcode.plist") + + # Extract the first account name (email) from the user's Xcode preferences + message(DEBUG "Trying to extract an Xcode development team id from '${xcode_preferences_path}'") + execute_process(COMMAND "/usr/libexec/PlistBuddy" + -x -c "print IDEProvisioningTeams" "${xcode_preferences_path}" + OUTPUT_VARIABLE teams_xml + ERROR_VARIABLE plist_error) + + # Parsing state. + set(is_free "") + set(current_team_id "") + set(parsing_is_free FALSE) + set(parsing_team_id FALSE) + set(first_team_id "") + + # Parse the xml output and return the first encountered non-free team id. If no non-free team id + # is found, return the first encountered free team id. + # If no team is found, return an empty string. + # + # Example input: + # + # + # marty@planet.local + # + # + # isFreeProvisioningTeam + # + # teamID + # AAA + # ... + # + # + # isFreeProvisioningTeam + # + # teamID + # BBB + # ... + # + # + # + # + if(teams_xml AND NOT plist_error) + string(REPLACE "\n" ";" teams_xml_lines "${teams_xml}") + + foreach(xml_line ${teams_xml_lines}) + string(STRIP "${xml_line}" xml_line) + if(xml_line STREQUAL "") + # Clean any previously found values when a new team dict is matched. + set(is_free "") + set(current_team_id "") + + elseif(xml_line STREQUAL "isFreeProvisioningTeam") + set(parsing_is_free TRUE) + + elseif(parsing_is_free) + set(parsing_is_free FALSE) + + if(xml_line MATCHES "true") + set(is_free TRUE) + else() + set(is_free FALSE) + endif() + + elseif(xml_line STREQUAL "teamID") + set(parsing_team_id TRUE) + + elseif(parsing_team_id) + set(parsing_team_id FALSE) + if(xml_line MATCHES "([^<]+)") + set(current_team_id "${CMAKE_MATCH_1}") + else() + continue() + endif() + + string(STRIP "${current_team_id}" current_team_id) + + # If this is the first team id we found so far, remember that, regardless if's free + # or not. + if(NOT first_team_id AND current_team_id) + set(first_team_id "${current_team_id}") + endif() + + # Break early if we found a non-free team id and use it, because we prefer + # a non-free team for signing, just like qmake. + if(NOT is_free AND current_team_id) + set(first_team_id "${current_team_id}") + break() + endif() + endif() + endforeach() + endif() + + if(NOT first_team_id) + message(DEBUG "Failed to extract an Xcode development team id.") + set("${out_var}" "" PARENT_SCOPE) + else() + message(DEBUG "Successfully extracted the first encountered Xcode development team id.") + set_property(GLOBAL PROPERTY _qt_internal_ios_development_team_id "${first_team_id}") + set("${out_var}" "${first_team_id}" PARENT_SCOPE) + endif() +endfunction() + +function(_qt_internal_get_apple_bundle_identifier_prefix out_var) + get_property(prefix GLOBAL PROPERTY _qt_internal_ios_bundle_identifier_prefix) + get_property(prefix_computed GLOBAL PROPERTY + _qt_internal_ios_bundle_identifier_prefix_computed) + if(prefix_computed) + # Just in case if the value is non-empty but still booly FALSE. + if(NOT prefix) + set(prefix "") + endif() + set("${out_var}" "${prefix}" PARENT_SCOPE) + return() + endif() + + set_property(GLOBAL PROPERTY _qt_internal_ios_bundle_identifier_prefix_computed "TRUE") + + set(home_dir "$ENV{HOME}") + set(xcode_preferences_path "${home_dir}/Library/Preferences/com.apple.dt.Xcode.plist") + + message(DEBUG "Trying to extract the default bundle identifier prefix from Xcode preferences.") + execute_process(COMMAND "/usr/libexec/PlistBuddy" + -c "print IDETemplateOptions:bundleIdentifierPrefix" + "${xcode_preferences_path}" + OUTPUT_VARIABLE prefix + ERROR_VARIABLE prefix_error) + if(prefix AND NOT prefix_error) + message(DEBUG "Successfully extracted the default bundle identifier prefix.") + string(STRIP "${prefix}" prefix) + else() + message(DEBUG "Failed to extract the default bundle identifier prefix.") + endif() + + if(prefix AND NOT prefix_error) + set_property(GLOBAL PROPERTY _qt_internal_ios_bundle_identifier_prefix "${prefix}") + set("${out_var}" "${prefix}" PARENT_SCOPE) + else() + set("${out_var}" "" PARENT_SCOPE) + endif() +endfunction() + +function(_qt_internal_escape_rfc_1034_identifier value out_var) + # According to https://datatracker.ietf.org/doc/html/rfc1034#section-3.5 + # we can only use letters, digits, dot (.) and hyphens (-). + # Underscores are not allowed. + string(REGEX REPLACE "[^A-Za-z0-9.]" "-" value "${value}") + + set("${out_var}" "${value}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_get_default_apple_bundle_identifier target out_var) + _qt_internal_get_apple_bundle_identifier_prefix(prefix) + if(NOT prefix) + set(prefix "com.yourcompany") + + # For a better out-of-the-box experience, try to create a unique prefix by appending + # the sha1 of the team id, if one is found. + _qt_internal_find_ios_development_team_id(team_id) + if(team_id) + string(SHA1 hash "${team_id}") + string(SUBSTRING "${hash}" 0 8 infix) + string(APPEND prefix ".${infix}") + endif() + + if(CMAKE_GENERATOR STREQUAL "Xcode") + message(WARNING + "No organization bundle identifier prefix could be retrieved from Xcode preferences. \ + This can lead to code signing issues due to a non-unique bundle \ + identifier. Please set up an organization prefix by creating a new project within \ + Xcode, or consider providing a custom bundle identifier by specifying the \ + MACOSX_BUNDLE_GUI_IDENTIFIER or XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER property." + ) + endif() + endif() + + # Escape the prefix according to rfc 1034, it's important for code-signing. If an invalid + # identifier is used, calling xcodebuild on the command line says that no provisioning profile + # could be found, with no additional error message. If one opens the generated project with + # Xcode and clicks on 'Try again' to get a new profile, it shows a semi-useful error message + # that the identifier is invalid. + _qt_internal_escape_rfc_1034_identifier("${prefix}" prefix) + + if(CMAKE_GENERATOR STREQUAL "Xcode") + set(identifier "${prefix}.$(PRODUCT_NAME:rfc1034identifier)") + else() + set(identifier "${prefix}.${target}") + endif() + + set("${out_var}" "${identifier}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_set_placeholder_apple_bundle_version target) + # If user hasn't provided neither a bundle version nor a bundle short version string for the + # app, set a placeholder value for both which will add them to the generated Info.plist file. + # This is required so that the app launches in the simulator (but apparently not for running + # on-device). + get_target_property(bundle_version "${target}" MACOSX_BUNDLE_BUNDLE_VERSION) + get_target_property(bundle_short_version "${target}" MACOSX_BUNDLE_SHORT_VERSION_STRING) + + if(NOT MACOSX_BUNDLE_BUNDLE_VERSION AND + NOT MACOSX_BUNDLE_SHORT_VERSION_STRING AND + NOT bundle_version AND + NOT bundle_short_version AND + NOT QT_NO_SET_XCODE_BUNDLE_VERSION + ) + get_target_property(version "${target}" VERSION) + if(NOT version) + set(version "${PROJECT_VERSION}") + if(NOT version) + set(version "1.0.0") + endif() + endif() + + # Use x.y for short version and x.y.z for full version + # Any versions longer than this will fail App Store + # submission. + string(REPLACE "." ";" version_list ${version}) + list(LENGTH version_list version_list_length) + list(GET version_list 0 version_major) + set(bundle_short_version "${version_major}") + if(version_list_length GREATER 1) + list(GET version_list 1 version_minor) + string(APPEND bundle_short_version ".${version_minor}") + endif() + set(bundle_version "${bundle_short_version}") + if(version_list_length GREATER 2) + list(GET version_list 2 version_patch) + string(APPEND bundle_version ".${version_patch}") + endif() + + + if(NOT CMAKE_XCODE_ATTRIBUTE_MARKETING_VERSION + AND NOT QT_NO_SET_XCODE_ATTRIBUTE_MARKETING_VERSION + AND NOT CMAKE_XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION + AND NOT QT_NO_SET_XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION + AND CMAKE_GENERATOR STREQUAL "Xcode") + get_target_property(marketing_version "${target}" + XCODE_ATTRIBUTE_MARKETING_VERSION) + get_target_property(current_project_version "${target}" + XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION) + if(NOT marketing_version AND NOT current_project_version) + set_target_properties("${target}" + PROPERTIES + XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION "${bundle_version}" + XCODE_ATTRIBUTE_MARKETING_VERSION "${bundle_short_version}" + ) + set(bundle_version "$(CURRENT_PROJECT_VERSION)") + set(bundle_short_version "$(MARKETING_VERSION)") + endif() + endif() + + set_target_properties("${target}" + PROPERTIES + MACOSX_BUNDLE_BUNDLE_VERSION "${bundle_version}" + MACOSX_BUNDLE_SHORT_VERSION_STRING "${bundle_short_version}" + ) + endif() +endfunction() + +function(_qt_internal_set_xcode_development_team_id target) + # If user hasn't provided a development team id, try to find the first one specified + # in the Xcode preferences. + if(NOT CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM AND NOT QT_NO_SET_XCODE_DEVELOPMENT_TEAM_ID) + get_target_property(existing_team_id "${target}" XCODE_ATTRIBUTE_DEVELOPMENT_TEAM) + if(NOT existing_team_id) + _qt_internal_find_ios_development_team_id(team_id) + set_target_properties("${target}" + PROPERTIES XCODE_ATTRIBUTE_DEVELOPMENT_TEAM "${team_id}") + endif() + endif() +endfunction() + +function(_qt_internal_set_apple_bundle_identifier target) + # Skip all logic if requested. + if(QT_NO_SET_XCODE_BUNDLE_IDENTIFIER) + return() + endif() + + # There are two fields to consider: the CFBundleIdentifier key (ie., cmake_bundle_identifier) + # to be written to Info.plist and the PRODUCT_BUNDLE_IDENTIFIER (ie., xcode_bundle_identifier) + # property to set in the Xcode project. The `cmake_bundle_identifier` set by + # MACOSX_BUNDLE_GUI_IDENTIFIER applies to both Xcode, and other generators, while + # `xcode_bundle_identifier` set by XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER is + # Xcode specific. + # + # If Ninja is the generator, we set the value of `MACOSX_BUNDLE_GUI_IDENTIFIER` + # and don't touch the `XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER`. + # If Xcode is the generator, we set the value of `XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER`, + # and additionally, to silence a Xcode's warning, we set the `MACOSX_BUNDLE_GUI_IDENTIFIER` to + # `${PRODUCT_BUNDLE_IDENTIFIER}` so that Xcode could sort it out. + + get_target_property(existing_cmake_bundle_identifier "${target}" + MACOSX_BUNDLE_GUI_IDENTIFIER) + get_target_property(existing_xcode_bundle_identifier "${target}" + XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER) + + set(is_cmake_bundle_identifier_given FALSE) + if(existing_cmake_bundle_identifier) + set(is_cmake_bundle_identifier_given TRUE) + elseif(MACOSX_BUNDLE_GUI_IDENTIFIER) + set(is_cmake_bundle_identifier_given TRUE) + set(existing_cmake_bundle_identifier ${MACOSX_BUNDLE_GUI_IDENTIFIER}) + endif() + + set(is_xcode_bundle_identifier_given FALSE) + if(existing_xcode_bundle_identifier) + set(is_xcode_bundle_identifier_given TRUE) + elseif(CMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER) + set(is_xcode_bundle_identifier_given TRUE) + set(existing_xcode_bundle_identifier ${CMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER}) + endif() + + if(is_cmake_bundle_identifier_given + AND is_xcode_bundle_identifier_given + AND NOT existing_cmake_bundle_identifier STREQUAL existing_xcode_bundle_identifier) + message(WARNING + "MACOSX_BUNDLE_GUI_IDENTIFIER and XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER " + "are set to different values. You only need to set one of them. ") + endif() + + if(NOT is_xcode_bundle_identifier_given + AND NOT is_cmake_bundle_identifier_given) + _qt_internal_get_default_apple_bundle_identifier("${target}" bundle_id) + elseif(is_cmake_bundle_identifier_given) + set(bundle_id ${existing_cmake_bundle_identifier}) + elseif(is_xcode_bundle_identifier_given) + set(bundle_id ${existing_xcode_bundle_identifier}) + endif() + + if(CMAKE_GENERATOR STREQUAL "Xcode") + set_target_properties("${target}" + PROPERTIES + XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "${bundle_id}" + MACOSX_BUNDLE_GUI_IDENTIFIER "$(PRODUCT_BUNDLE_IDENTIFIER)") + else() + set_target_properties("${target}" + PROPERTIES + MACOSX_BUNDLE_GUI_IDENTIFIER "${bundle_id}") + endif() +endfunction() + +function(_qt_internal_set_xcode_targeted_device_family target) + if(NOT CMAKE_XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY + AND NOT QT_NO_SET_XCODE_TARGETED_DEVICE_FAMILY) + get_target_property(existing_device_family + "${target}" XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY) + if(NOT existing_device_family) + set(device_family_iphone_and_ipad "1,2") + set_target_properties("${target}" + PROPERTIES + XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY + "${device_family_iphone_and_ipad}") + endif() + endif() +endfunction() + +function(_qt_internal_set_xcode_code_sign_style target) + if(NOT CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_STYLE + AND NOT QT_NO_SET_XCODE_CODE_SIGN_STYLE) + get_target_property(existing_code_style + "${target}" XCODE_ATTRIBUTE_CODE_SIGN_STYLE) + if(NOT existing_code_style) + set(existing_code_style "Automatic") + set_target_properties("${target}" + PROPERTIES + XCODE_ATTRIBUTE_CODE_SIGN_STYLE + "${existing_code_style}") + endif() + endif() +endfunction() + +# Workaround for https://gitlab.kitware.com/cmake/cmake/-/issues/15183 +function(_qt_internal_set_xcode_install_path target) + if(NOT CMAKE_XCODE_ATTRIBUTE_INSTALL_PATH + AND NOT QT_NO_SET_XCODE_INSTALL_PATH) + get_target_property(existing_install_path + "${target}" XCODE_ATTRIBUTE_INSTALL_PATH) + if(NOT existing_install_path) + set_target_properties("${target}" + PROPERTIES + XCODE_ATTRIBUTE_INSTALL_PATH + "$(inherited)") + endif() + endif() +endfunction() + +# Explicitly set the debug information format for each build configuration to match the values +# of a new project created via Xcode directly. This ensures debug information is included during +# archiving. +function(_qt_internal_set_xcode_debug_information_format target) + if(NOT DEFINED CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT + AND NOT QT_NO_SET_XCODE_DEBUG_INFORMATION_FORMAT) + get_target_property(existing "${target}" XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT) + if(NOT existing) + # The CMake Xcode generator searches for [variant=${config}], removes that substring, + # and generates the attribute only for the config that is specified as the "variant". + set_target_properties("${target}" PROPERTIES + "XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT[variant=Debug]" "dwarf") + set_target_properties("${target}" PROPERTIES + "XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT[variant=Release]" "dwarf-with-dsym") + set_target_properties("${target}" PROPERTIES + "XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT[variant=MinSizeRel]" "dwarf-with-dsym") + set_target_properties("${target}" PROPERTIES + "XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT[variant=RelWithDebInfo]" + "dwarf-with-dsym") + endif() + endif() +endfunction() + +# Make sure to always generate debug symbols, to match the values of a new project created via +# Xcode directly. +function(_qt_internal_set_xcode_generate_debugging_symbols target) + if(NOT DEFINED CMAKE_XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS + AND NOT QT_NO_SET_XCODE_GCC_GENERATE_DEBUGGING_SYMBOLS) + get_target_property(existing "${target}" XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS) + if(NOT existing) + set_target_properties("${target}" PROPERTIES + "XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS" "YES") + endif() + endif() +endfunction() + +# CMake generates a project where this setting is set to an absolute path build dir. +# Provide an opt-in to work around an Xcode issue where archiving does not find the project dSYMs +# unless the configuration build dir starts with $(BUILD_DIR) or is set to $(inherited). +# It is an opt-in, because it breaks certain CMake behavior like $ genex +# evaluation as well as ignoring the value of CMAKE_RUNTIME_OUTPUT_DIRECTORY. +# So projects have to do it at their own risk. +function(_qt_internal_set_xcode_configuration_build_dir target) + if(QT_USE_RISKY_DSYM_ARCHIVING_WORKAROUND) + set_target_properties("${target}" PROPERTIES + XCODE_ATTRIBUTE_CONFIGURATION_BUILD_DIR "$(inherited)") + endif() +endfunction() + +function(_qt_internal_set_xcode_bundle_display_name target) + # We want the value of CFBundleDisplayName to be ${PRODUCT_NAME}, but we can't put that + # into the Info.plist.in template file directly, because the implicit configure_file(Info.plist) + # done by CMake is not using the @ONLY option, so CMake would treat the assignment as + # variable expansion. Escaping using backslashes does not help. + # Work around it by assigning the dollar char to a separate cache var, and expand it, so that + # the final value in the file will be ${PRODUCT_NAME}, to be evaluated at build time by Xcode. + set(QT_INTERNAL_DOLLAR_VAR "$" CACHE STRING "") +endfunction() + +# Adds ${PRODUCT_NAME} to the Info.plist file, which is then evaluated by Xcode itself. +function(_qt_internal_set_xcode_bundle_name target) + if(QT_NO_SET_XCODE_BUNDLE_NAME) + return() + endif() + + get_target_property(existing_bundle_name "${target}" MACOSX_BUNDLE_BUNDLE_NAME) + if(NOT MACOSX_BUNDLE_BUNDLE_NAME AND NOT existing_bundle_name) + if(CMAKE_GENERATOR STREQUAL Xcode) + set_target_properties("${target}" + PROPERTIES + MACOSX_BUNDLE_BUNDLE_NAME "$(PRODUCT_NAME)") + else() + set_target_properties("${target}" + PROPERTIES + MACOSX_BUNDLE_BUNDLE_NAME "${target}") + endif() + endif() +endfunction() + +function(_qt_internal_set_xcode_bitcode_enablement target) + if(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE + OR QT_NO_SET_XCODE_ENABLE_BITCODE) + return() + endif() + + get_target_property(existing_bitcode_enablement + "${target}" XCODE_ATTRIBUTE_ENABLE_BITCODE) + if(NOT existing_bitcode_enablement MATCHES "-NOTFOUND") + return() + endif() + + # Disable bitcode to match Xcode 14's new default + set_target_properties("${target}" + PROPERTIES + XCODE_ATTRIBUTE_ENABLE_BITCODE + "NO") +endfunction() + +function(_qt_internal_copy_info_plist target) + # If the project already specifies a custom file, we don't override it. + get_target_property(info_plist_in "${target}" MACOSX_BUNDLE_INFO_PLIST) + if(NOT info_plist_in) + set(info_plist_in "${__qt_internal_cmake_apple_support_files_path}/Info.plist.app.in") + endif() + + string(MAKE_C_IDENTIFIER "${target}" target_identifier) + set(info_plist_out_dir + "${CMAKE_CURRENT_BINARY_DIR}/.qt/info_plist/${target_identifier}") + set(info_plist_out "${info_plist_out_dir}/Info.plist") + + # Check if we need to specify a custom launch screen storyboard entry. + get_target_property(launch_screen_base_name "${target}" _qt_ios_launch_screen_base_name) + if(launch_screen_base_name) + set(qt_ios_launch_screen_plist_entry "${launch_screen_base_name}") + endif() + + # Call configure_file to substitute Qt-specific @FOO@ values, not ${FOO} values. + # + # The output file will be another template file to be fed to CMake via the + # MACOSX_BUNDLE_INFO_PLIST property. CMake will then call configure_file on it to provide + # content for regular entries like CFBundleName, etc. + # + # We require this extra configure_file call so we can create unique Info.plist files for each + # target in a project, while also providing a way to add Qt specific entries that CMake + # does not support out of the box (e.g. a launch screen name). + configure_file( + "${info_plist_in}" + "${info_plist_out}" + @ONLY + ) + + set_target_properties("${target}" PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${info_plist_out}") +endfunction() + +function(_qt_internal_plist_buddy plist_file) + cmake_parse_arguments(PARSE_ARGV 1 arg + "" "OUTPUT_VARIABLE;ERROR_VARIABLE" "COMMANDS") + foreach(command ${arg_COMMANDS}) + execute_process(COMMAND "/usr/libexec/PlistBuddy" + -c "${command}" "${plist_file}" + OUTPUT_VARIABLE plist_buddy_output + ERROR_VARIABLE plist_buddy_error) + string(STRIP "${plist_buddy_output}" plist_buddy_output) + if(arg_OUTPUT_VARIABLE) + list(APPEND ${arg_OUTPUT_VARIABLE} ${plist_buddy_output}) + set(${arg_OUTPUT_VARIABLE} ${${arg_OUTPUT_VARIABLE}} PARENT_SCOPE) + endif() + if(arg_ERROR_VARIABLE) + list(APPEND ${arg_ERROR_VARIABLE} ${plist_buddy_error}) + set(${arg_ERROR_VARIABLE} ${${arg_ERROR_VARIABLE}} PARENT_SCOPE) + endif() + if(plist_buddy_error) + return() + endif() + endforeach() +endfunction() + +function(_qt_internal_set_apple_localizations target) + if(QT_NO_SET_PLIST_LOCALIZATIONS) + return() + endif() + + set(supported_languages "${QT_I18N_TRANSLATED_LANGUAGES}") + if("${QT_I18N_TRANSLATED_LANGUAGES}" STREQUAL "") + get_target_property(supported_languages "${target}" _qt_apple_supported_languages) + if("${supported_languages}" STREQUAL "supported_languages-NOTFOUND") + return() + endif() + endif() + get_target_property(plist_file "${target}" MACOSX_BUNDLE_INFO_PLIST) + if (NOT plist_file) + return() + endif() + + _qt_internal_plist_buddy("${plist_file}" + COMMANDS "print CFBundleLocalizations" + OUTPUT_VARIABLE existing_localizations + ) + if(NOT existing_localizations) + list(TRANSFORM supported_languages PREPEND + "Add CFBundleLocalizations: string ") + + _qt_internal_plist_buddy("${plist_file}" + COMMANDS + "Add CFBundleLocalizations array" + ${supported_languages} + "Delete CFBundleAllowMixedLocalizations" + ) + endif() + + if(NOT "${QT_I18N_SOURCE_LANGUAGE}" STREQUAL "") + _qt_internal_plist_buddy("${plist_file}" + COMMANDS "print CFBundleDevelopmentRegion" + OUTPUT_VARIABLE existing_dev_region + ) + if(NOT existing_dev_region) + _qt_internal_plist_buddy("${plist_file}" + COMMANDS + "Add CFBundleDevelopmentRegion string" + "Set CFBundleDevelopmentRegion ${QT_I18N_SOURCE_LANGUAGE}" + ) + endif() + endif() +endfunction() + +function(_qt_internal_set_ios_simulator_arch target) + if(CMAKE_XCODE_ATTRIBUTE_ARCHS + OR QT_NO_SET_XCODE_ARCHS) + return() + endif() + + get_target_property(existing_archs + "${target}" XCODE_ATTRIBUTE_ARCHS) + if(NOT existing_archs MATCHES "-NOTFOUND") + return() + endif() + + if(NOT x86_64 IN_LIST QT_OSX_ARCHITECTURES) + return() + endif() + + if(CMAKE_OSX_ARCHITECTURES AND NOT x86_64 IN_LIST CMAKE_OSX_ARCHITECTURES) + return() + endif() + + set_target_properties("${target}" + PROPERTIES + "XCODE_ATTRIBUTE_ARCHS[sdk=iphonesimulator*]" + "x86_64") +endfunction() + +# Export Apple platform sdk and xcode version requirements to Qt6ConfigExtras.cmake. +# Always exported, even on non-Apple platforms, so that we can use them when building +# documentation. +function(_qt_internal_export_apple_sdk_and_xcode_version_requirements out_var) + set(vars_to_assign + QT_SUPPORTED_MIN_IOS_SDK_VERSION + QT_SUPPORTED_MAX_IOS_SDK_VERSION + QT_SUPPORTED_MIN_IOS_XCODE_VERSION + QT_SUPPORTED_MIN_IOS_VERSION + QT_SUPPORTED_MAX_IOS_VERSION_TESTED + + QT_SUPPORTED_MIN_VISIONOS_SDK_VERSION + QT_SUPPORTED_MAX_VISIONOS_SDK_VERSION + QT_SUPPORTED_MIN_VISIONOS_XCODE_VERSION + QT_SUPPORTED_MIN_VISIONOS_VERSION + QT_SUPPORTED_MAX_VISIONOS_VERSION_TESTED + + QT_SUPPORTED_MIN_MACOS_SDK_VERSION + QT_SUPPORTED_MAX_MACOS_SDK_VERSION + QT_SUPPORTED_MIN_MACOS_XCODE_VERSION + QT_SUPPORTED_MIN_MACOS_VERSION + QT_SUPPORTED_MAX_MACOS_VERSION_TESTED + ) + + set(assignments "") + foreach(var IN LISTS vars_to_assign) + set(value "${${var}}") + list(APPEND assignments + " +if(NOT ${var}) + set(${var} \"${value}\") +endif()") + endforeach() + + list(JOIN assignments "\n" assignments) + set(${out_var} "${assignments}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_get_apple_sdk_version out_var) + if(APPLE) + if(CMAKE_SYSTEM_NAME STREQUAL iOS) + set(sdk_name "iphoneos") + elseif(CMAKE_SYSTEM_NAME STREQUAL visionOS) + set(sdk_name "xros") + else() + # Default to macOS + set(sdk_name "macosx") + endif() + set(xcrun_version_arg "--show-sdk-version") + execute_process(COMMAND /usr/bin/xcrun --sdk ${sdk_name} ${xcrun_version_arg} + OUTPUT_VARIABLE sdk_version + ERROR_VARIABLE xcrun_error) + if(NOT sdk_version) + message(FATAL_ERROR + "Can't determine darwin ${sdk_name} SDK version. Error: ${xcrun_error}") + endif() + string(STRIP "${sdk_version}" sdk_version) + set(${out_var} "${sdk_version}" PARENT_SCOPE) + endif() +endfunction() + +function(_qt_internal_get_xcode_version_raw out_var) + if(APPLE) + execute_process(COMMAND /usr/bin/xcrun xcodebuild -version + OUTPUT_VARIABLE xcode_version + ERROR_VARIABLE xcrun_error) + string(REPLACE "\n" " " xcode_version "${xcode_version}") + string(STRIP "${xcode_version}" xcode_version) + set(${out_var} "${xcode_version}" PARENT_SCOPE) + endif() +endfunction() + +function(_qt_internal_get_xcode_version out_var) + if(APPLE) + _qt_internal_get_xcode_version_raw(xcode_version_raw) + + # The raw output is something like after the newlines are replaced with spaces: + # Xcode 14.3 Build version 14E222b + # We want only the '14.3' part. We could be more specific with the regex to match only + # digits separated by dots, but you never know how Apple might change the format. + string(REGEX REPLACE "Xcode (([^ ])+)" "\\2" xcode_version "${xcode_version_raw}") + if(xcode_version_raw MATCHES "Xcode ([^ ]+)") + set(xcode_version "${CMAKE_MATCH_1}") + else() + message(DEBUG "Failed to extract Xcode version from '${xcode_version_raw}'") + set(xcode_version "${xcode_version_raw}") + endif() + + set(${out_var} "${xcode_version}" PARENT_SCOPE) + endif() +endfunction() + +function(_qt_internal_get_cached_apple_sdk_version out_var) + if(QT_INTERNAL_APPLE_SDK_VERSION) + set(sdk_version "${QT_INTERNAL_APPLE_SDK_VERSION}") + else() + _qt_internal_get_apple_sdk_version(sdk_version) + set(QT_INTERNAL_APPLE_SDK_VERSION "${sdk_version}" CACHE STRING "Apple SDK version") + endif() + + set(${out_var} "${sdk_version}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_get_cached_xcode_version out_var) + if(QT_INTERNAL_XCODE_VERSION) + set(xcode_version "${QT_INTERNAL_XCODE_VERSION}") + else() + _qt_internal_get_xcode_version(xcode_version) + set(QT_INTERNAL_XCODE_VERSION "${xcode_version}" CACHE STRING "Xcode version") + endif() + + set(${out_var} "${xcode_version}" PARENT_SCOPE) +endfunction() + +# Warn when the platform SDK or Xcode version are not supported. +# +# The warnings are currently only shown when building Qt, not when building user projects +# with CMake. +# The warnings ARE shown for qmake user projects. +# +# The qmake equivalent for user projects is in mkspecs/features/mac/default_post.prf. +function(_qt_internal_check_apple_sdk_and_xcode_versions) + if(NOT APPLE) + return() + endif() + + if(QT_NO_APPLE_SDK_AND_XCODE_CHECK) + return() + endif() + + # Only run the check once in a top-level build. + get_property(check_done GLOBAL PROPERTY _qt_internal_apple_sdk_and_xcode_check_done) + if(check_done) + return() + endif() + set_property(GLOBAL PROPERTY _qt_internal_apple_sdk_and_xcode_check_done "TRUE") + + if(IOS) + set(min_sdk_version "${QT_SUPPORTED_MIN_IOS_SDK_VERSION}") + set(max_sdk_version "${QT_SUPPORTED_MAX_IOS_SDK_VERSION}") + set(min_xcode_version "${QT_SUPPORTED_MIN_IOS_XCODE_VERSION}") + elseif(VISIONOS) + set(min_sdk_version "${QT_SUPPORTED_MIN_VISIONOS_SDK_VERSION}") + set(max_sdk_version "${QT_SUPPORTED_MAX_VISIONOS_SDK_VERSION}") + set(min_xcode_version "${QT_SUPPORTED_MIN_VISIONOS_XCODE_VERSION}") + else() + set(min_sdk_version "${QT_SUPPORTED_MIN_MACOS_SDK_VERSION}") + set(max_sdk_version "${QT_SUPPORTED_MAX_MACOS_SDK_VERSION}") + set(min_xcode_version "${QT_SUPPORTED_MIN_MACOS_XCODE_VERSION}") + endif() + + _qt_internal_get_cached_apple_sdk_version(sdk_version) + _qt_internal_get_cached_xcode_version(xcode_version) + + if(NOT max_sdk_version MATCHES "^[0-9]+$") + message(FATAL_ERROR + "Invalid max SDK version: ${max_sdk_version} " + "It should be a major version number, without minor or patch version components.") + endif() + + # The default differs in different branches. + set(failed_check_should_error FALSE) + + if(failed_check_should_error) + # Allow downgrading the error into a warning. + if(QT_FORCE_WARN_APPLE_SDK_AND_XCODE_CHECK) + set(message_type WARNING) + set(extra_message " Due to QT_FORCE_WARN_APPLE_SDK_AND_XCODE_CHECK being ON " + "the build will continue, but it will likely fail. Use at your own risk.") + else() + set(message_type FATAL_ERROR) + set(extra_message " You can turn this error into a warning by configuring with " + "-DQT_FORCE_WARN_APPLE_SDK_AND_XCODE_CHECK=ON, but the build will likely fail. " + "Use at your own risk.") + endif() + else() + # Allow upgrading the warning into an error. + if(QT_FORCE_FATAL_APPLE_SDK_AND_XCODE_CHECK) + set(message_type FATAL_ERROR) + set(extra_message " Erroring out due to QT_FORCE_FATAL_APPLE_SDK_AND_XCODE_CHECK " + "being ON.") + else() + set(message_type WARNING) + set(extra_message " You can turn this warning into an error by configuring with " + "-DQT_FORCE_FATAL_APPLE_SDK_AND_XCODE_CHECK=ON. ") + endif() + endif() + + if(sdk_version VERSION_LESS min_sdk_version AND NOT QT_NO_APPLE_SDK_MIN_VERSION_CHECK) + message(${message_type} + "Qt requires at least version ${min_sdk_version} of the platform SDK, " + "you're building against version ${sdk_version}. Please upgrade." + ${extra_message} + ) + endif() + + if(xcode_version VERSION_LESS min_xcode_version AND NOT QT_NO_XCODE_MIN_VERSION_CHECK) + message(${message_type} + "Qt requires at least version ${min_xcode_version} of Xcode, " + "you're building against version ${xcode_version}. Please upgrade." + ${extra_message} + ) + endif() + + if(QT_NO_APPLE_SDK_MAX_VERSION_CHECK) + return() + endif() + + # Make sure we warn only when the current version is greater than the max supported version. + math(EXPR next_after_max_sdk_version "${max_sdk_version} + 1") + if(sdk_version VERSION_GREATER_EQUAL next_after_max_sdk_version) + message(WARNING + "Qt has only been tested with version ${max_sdk_version} " + "of the platform SDK, you're using ${sdk_version}. " + "This is an unsupported configuration. You may experience build issues, " + "and by using " + "the ${sdk_version} SDK you are opting in to new features " + "that Qt has not been prepared for. " + "Please downgrade the SDK you use to build your app to version " + "${max_sdk_version}, or configure " + "with -DQT_NO_APPLE_SDK_MAX_VERSION_CHECK=ON to silence this warning." + ) + endif() +endfunction() + +function(_qt_internal_finalize_apple_app target) + # Shared between macOS and UIKit apps + + _qt_internal_copy_info_plist("${target}") + _qt_internal_set_apple_localizations("${target}") + + # Only set the various properties if targeting the Xcode generator, otherwise the various + # Xcode tokens are embedded as-is instead of being dynamically evaluated. + # This affects things like the version number or application name as reported by Qt API. + if(CMAKE_GENERATOR STREQUAL "Xcode") + _qt_internal_set_xcode_development_team_id("${target}") + _qt_internal_set_xcode_code_sign_style("${target}") + _qt_internal_set_xcode_bundle_display_name("${target}") + _qt_internal_set_xcode_install_path("${target}") + _qt_internal_set_xcode_configuration_build_dir("${target}") + _qt_internal_set_xcode_debug_information_format("${target}") + _qt_internal_set_xcode_generate_debugging_symbols("${target}") + endif() + + _qt_internal_set_xcode_bundle_name("${target}") + _qt_internal_set_apple_bundle_identifier("${target}") + _qt_internal_set_placeholder_apple_bundle_version("${target}") +endfunction() + +function(_qt_internal_finalize_uikit_app target) + if(CMAKE_SYSTEM_NAME STREQUAL iOS) + _qt_internal_finalize_ios_app("${target}") + else() + _qt_internal_finalize_apple_app("${target}") + endif() +endfunction() + +function(_qt_internal_finalize_ios_app target) + # Must be called before we generate the Info.plist + _qt_internal_handle_ios_launch_screen("${target}") + + _qt_internal_finalize_apple_app("${target}") + _qt_internal_set_xcode_targeted_device_family("${target}") + _qt_internal_set_xcode_bitcode_enablement("${target}") + _qt_internal_set_ios_simulator_arch("${target}") +endfunction() + +function(_qt_internal_finalize_macos_app target) + get_target_property(is_bundle ${target} MACOSX_BUNDLE) + if(NOT is_bundle) + return() + endif() + + _qt_internal_finalize_apple_app("${target}") + + # Make sure the install rpath has at least the minimum needed if the app + # has any non-static frameworks. We can't rigorously know if the app will + # have any, even with a static Qt, so always add this. If there are no + # frameworks, it won't do any harm. + get_property(install_rpath TARGET ${target} PROPERTY INSTALL_RPATH) + list(APPEND install_rpath "@executable_path/../Frameworks") + list(REMOVE_DUPLICATES install_rpath) + set_property(TARGET ${target} PROPERTY INSTALL_RPATH "${install_rpath}") +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicCMakeHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicCMakeHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f13c25f3553f1e51aa7135612fb92284655c4d96 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicCMakeHelpers.cmake @@ -0,0 +1,677 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# copy_if_different works incorrect in Windows if file size if bigger than 2GB. +# See https://gitlab.kitware.com/cmake/cmake/-/issues/23052 and QTBUG-99491 for details. +function(_qt_internal_copy_file_if_different_command out_var src_file dst_file) + # The CMake version higher than 3.23 doesn't contain the issue + if(CMAKE_HOST_WIN32 AND CMAKE_VERSION VERSION_LESS 3.23) + set(${out_var} "${CMAKE_COMMAND}" + "-DSRC_FILE_PATH=${src_file}" + "-DDST_FILE_PATH=${dst_file}" + -P "${_qt_6_config_cmake_dir}/QtCopyFileIfDifferent.cmake" + PARENT_SCOPE + ) + else() + set(${out_var} "${CMAKE_COMMAND}" + -E copy_if_different + "${src_file}" + "${dst_file}" + PARENT_SCOPE + ) + endif() +endfunction() + +# The function checks if add_custom_command has the support of the DEPFILE argument. +function(_qt_internal_check_depfile_support out_var) + if(CMAKE_GENERATOR MATCHES "Ninja" OR + (CMAKE_VERSION VERSION_GREATER_EQUAL 3.20 AND CMAKE_GENERATOR MATCHES "Makefiles") + OR (CMAKE_VERSION VERSION_GREATER_EQUAL 3.21 + AND (CMAKE_GENERATOR MATCHES "Xcode" + OR (CMAKE_GENERATOR MATCHES "Visual Studio ([0-9]+)" AND CMAKE_MATCH_1 GREATER_EQUAL 12) + ) + ) + ) + set(${out_var} TRUE) + else() + set(${out_var} FALSE) + endif() + set(${out_var} "${${out_var}}" PARENT_SCOPE) +endfunction() + +# Checks if the path points to the cmake directory, like lib/cmake. +function(__qt_internal_check_path_points_to_cmake_dir result path) + string(TOUPPER "${QT_CMAKE_EXPORT_NAMESPACE}" export_namespace_upper) + if((INSTALL_LIBDIR AND path MATCHES "/${INSTALL_LIBDIR}/cmake$") OR + (${export_namespace_upper}_INSTALL_LIBS AND + path MATCHES "/${${export_namespace_upper}_INSTALL_LIBS}/cmake$") OR + path MATCHES "/lib/cmake$" + ) + set(${result} TRUE PARENT_SCOPE) + else() + set(${result} FALSE PARENT_SCOPE) + endif() +endfunction() + +# Creates a reverse path to prefix from possible cmake directories. Returns the unchanged path +# if it doesn't point to cmake directory. +function(__qt_internal_reverse_prefix_path_from_cmake_dir result cmake_path) + string(TOUPPER "${QT_CMAKE_EXPORT_NAMESPACE}" export_namespace_upper) + if(INSTALL_LIBDIR AND cmake_path MATCHES "(.+)/${INSTALL_LIBDIR}/cmake$") + if(CMAKE_MATCH_1) + set(${result} "${CMAKE_MATCH_1}" PARENT_SCOPE) + endif() + elseif(${export_namespace_upper}_INSTALL_LIBS AND + cmake_path MATCHES "(.+)/${${export_namespace_upper}_INSTALL_LIBS}/cmake$") + if(CMAKE_MATCH_1) + set(${result} "${CMAKE_MATCH_1}" PARENT_SCOPE) + endif() + elseif(result MATCHES "(.+)/lib/cmake$") + if(CMAKE_MATCH_1) + set(${result} "${CMAKE_MATCH_1}" PARENT_SCOPE) + endif() + else() + set(${result} "${cmake_path}" PARENT_SCOPE) + endif() +endfunction() + +# Returns the possible cmake directories based on prefix_path. +function(__qt_internal_get_possible_cmake_dirs out_paths prefix_path) + set(${out_paths} "") + + if(EXISTS "${prefix_path}/lib/cmake") + list(APPEND ${out_paths} "${prefix_path}/lib/cmake") + endif() + + string(TOUPPER "${QT_CMAKE_EXPORT_NAMESPACE}" export_namespace_upper) + set(next_path "${prefix_path}/${${export_namespace_upper}_INSTALL_LIBS}/cmake") + if(${export_namespace_upper}_INSTALL_LIBS AND EXISTS "${next_path}") + list(APPEND ${out_paths} "${next_path}") + endif() + + set(next_path "${prefix_path}/${INSTALL_LIBDIR}/cmake") + if(INSTALL_LIBDIR AND EXISTS "${next_path}") + list(APPEND ${out_paths} "${next_path}") + endif() + + list(REMOVE_DUPLICATES ${out_paths}) + set(${out_paths} "${${out_paths}}" PARENT_SCOPE) +endfunction() + +# Collect additional package prefix paths to look for Qt packages, both from command line and the +# env variable ${prefixes_var}. The result is stored in ${out_var} and is a list of paths ending +# with "/lib/cmake". +function(__qt_internal_collect_additional_prefix_paths out_var prefixes_var) + if(DEFINED "${out_var}") + return() + endif() + + set(additional_packages_prefix_paths "") + + set(additional_packages_prefixes "") + if(${prefixes_var}) + list(APPEND additional_packages_prefixes ${${prefixes_var}}) + endif() + if(DEFINED ENV{${prefixes_var}} + AND NOT "$ENV{${prefixes_var}}" STREQUAL "") + set(prefixes_from_env "$ENV{${prefixes_var}}") + if(NOT CMAKE_HOST_WIN32) + string(REPLACE ":" ";" prefixes_from_env "${prefixes_from_env}") + endif() + list(APPEND additional_packages_prefixes ${prefixes_from_env}) + endif() + + foreach(additional_path IN LISTS additional_packages_prefixes) + file(TO_CMAKE_PATH "${additional_path}" additional_path) + + # The prefix paths need to end with lib/cmake to ensure the packages are found when + # cross compiling. Search for REROOT_PATH_ISSUE_MARKER in the qt.toolchain.cmake file for + # details. + # We must pass the values via the PATHS options because the main find_package call uses + # NO_DEFAULT_PATH, and thus CMAKE_PREFIX_PATH values are discarded. + # CMAKE_FIND_ROOT_PATH values are not discarded and togegher with the PATHS option, it + # ensures packages from additional prefixes are found. + __qt_internal_check_path_points_to_cmake_dir(is_path_to_cmake "${additional_path}") + if(is_path_to_cmake) + list(APPEND additional_packages_prefix_paths "${additional_path}") + else() + __qt_internal_get_possible_cmake_dirs(additional_cmake_dirs "${additional_path}") + list(APPEND additional_packages_prefix_paths ${additional_cmake_dirs}) + endif() + endforeach() + + set("${out_var}" "${additional_packages_prefix_paths}" PARENT_SCOPE) +endfunction() + +# Collects CMAKE_MODULE_PATH from QT_ADDITIONAL_PACKAGES_PREFIX_PATH +function(__qt_internal_collect_additional_module_paths) + if(__qt_additional_module_paths_set) + return() + endif() + foreach(prefix_path IN LISTS QT_ADDITIONAL_PACKAGES_PREFIX_PATH) + __qt_internal_check_path_points_to_cmake_dir(is_path_to_cmake "${prefix_path}") + if(is_path_to_cmake) + list(APPEND CMAKE_MODULE_PATH "${prefix_path}/${QT_CMAKE_EXPORT_NAMESPACE}") + else() + __qt_internal_get_possible_cmake_dirs(additional_cmake_dirs "${additional_path}") + list(TRANSFORM additional_cmake_dirs APPEND "/${QT_CMAKE_EXPORT_NAMESPACE}") + list(APPEND CMAKE_MODULE_PATH ${additional_cmake_dirs}) + endif() + endforeach() + list(REMOVE_DUPLICATES CMAKE_MODULE_PATH) + set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" PARENT_SCOPE) + set(__qt_additional_module_paths_set TRUE PARENT_SCOPE) +endfunction() + +# Take a list of prefix paths ending with "/lib/cmake", and return a list of absolute paths with +# "/lib/cmake" removed. +function(__qt_internal_prefix_paths_to_roots out_var prefix_paths) + set(result "") + foreach(path IN LISTS prefix_paths) + __qt_internal_reverse_prefix_path_from_cmake_dir(path "${path}") + list(APPEND result "${path}") + endforeach() + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + +# This function gets all targets below this directory +# +# Multi-value Arguments: +# EXCLUDE list of target types that should be filtered from resulting list. +# +# INCLUDE list of target types that should be filtered from resulting list. +# EXCLUDE has higher priority than INCLUDE. +function(_qt_internal_collect_buildsystem_targets result dir) + cmake_parse_arguments(arg "" "" "EXCLUDE;INCLUDE" ${ARGN}) + + if(NOT _qt_internal_collect_buildsystem_targets_inner) + set(${result} "") + set(_qt_internal_collect_buildsystem_targets_inner TRUE) + endif() + + set(forward_args "") + if(arg_EXCLUDE) + set(forward_args APPEND EXCLUDE ${arg_EXCLUDE}) + endif() + + if(arg_INCLUDE) + set(forward_args APPEND INCLUDE ${arg_INCLUDE}) + endif() + + get_property(subdirs DIRECTORY "${dir}" PROPERTY SUBDIRECTORIES) + + # Make sure that we don't hit endless recursion when running qt-cmake-standalone-test on a + # in-source test dir, where the currently processed directory lists itself in its SUBDIRECTORIES + # property. + # See https://bugreports.qt.io/browse/QTBUG-119998 + # and https://gitlab.kitware.com/cmake/cmake/-/issues/25489 + # Do it only when QT_INTERNAL_IS_STANDALONE_TEST is set, to avoid the possible slowdown when + # processing many subdirectores when configuring all standalone tests rather than just one. + if(QT_INTERNAL_IS_STANDALONE_TEST) + list(REMOVE_ITEM subdirs "${dir}") + endif() + + foreach(subdir IN LISTS subdirs) + _qt_internal_collect_buildsystem_targets(${result} "${subdir}" ${forward_args}) + endforeach() + get_property(sub_targets DIRECTORY "${dir}" PROPERTY BUILDSYSTEM_TARGETS) + set(real_targets "") + if(sub_targets) + foreach(target IN LISTS sub_targets) + get_target_property(target_type ${target} TYPE) + if((NOT arg_INCLUDE OR target_type IN_LIST arg_INCLUDE) AND + (NOT arg_EXCLUDE OR (NOT target_type IN_LIST arg_EXCLUDE))) + list(APPEND real_targets ${target}) + endif() + endforeach() + endif() + set(${result} ${${result}} ${real_targets} PARENT_SCOPE) +endfunction() + +# Add a custom target ${target} that is *not* added to the default build target in a safe way. +# Dependencies must then be added with _qt_internal_add_phony_target_dependencies. +# +# What's "safe" in this context? For the Visual Studio generators, we cannot use add_dependencies, +# because this would enable the dependencies in the default build of the solution. See QTBUG-115166 +# and upstream CMake issue #16668 for details. Instead, we record the dependencies (added with +# _qt_internal_add_phony_target_dependencies) and create the target at the end of the top-level +# directory scope. +# +# This only works if at least CMake 3.19 is used. Older CMake versions will trigger a warning that +# can be turned off with the variable ${WARNING_VARIABLE}. +# +# For other generators, this is just a call to add_custom_target, unless the target already exists, +# followed by add_dependencies. +# +# Use this function for targets that are not part of the default build, i.e. that should be +# triggered by the user. +# +# TARGET_CREATED_HOOK is the name of a function that is called after the target has been created. +# It takes the target's name as first and only argument. +# +# Example: +# _qt_internal_add_phony_target(update_translations +# WARNING_VARIABLE QT_NO_GLOBAL_LUPDATE_TARGET_CREATED_WARNING +# ) +# _qt_internal_add_phony_target_dependencies(update_translations +# narf_lupdate_zort_lupdate +# ) +# +function(_qt_internal_add_phony_target target) + set(no_value_options "") + set(single_value_options + TARGET_CREATED_HOOK + WARNING_VARIABLE + ) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + if("${arg_WARNING_VARIABLE}" STREQUAL "") + message(FATAL_ERROR "WARNING_VARIABLE must be provided.") + endif() + if(CMAKE_GENERATOR MATCHES "^Visual Studio ") + if(${CMAKE_VERSION} VERSION_LESS "3.19.0") + if(NOT ${${arg_WARNING_VARIABLE}}) + message(WARNING + "Cannot create target ${target} with this CMake version. " + "Please upgrade to CMake 3.19.0 or newer. " + "Set ${WARNING_VARIABLE} to ON to disable this warning." + ) + endif() + return() + endif() + + get_property(already_deferred GLOBAL PROPERTY _qt_target_${target}_creation_deferred) + if(NOT already_deferred) + cmake_language(EVAL CODE + "cmake_language(DEFER DIRECTORY \"${CMAKE_SOURCE_DIR}\" CALL _qt_internal_add_phony_target_deferred \"${target}\")" + ) + if(DEFINED arg_TARGET_CREATED_HOOK) + set_property(GLOBAL + PROPERTY _qt_target_${target}_creation_hook ${arg_TARGET_CREATED_HOOK} + ) + endif() + endif() + set_property(GLOBAL APPEND PROPERTY _qt_target_${target}_creation_deferred ON) + else() + if(NOT TARGET ${target}) + add_custom_target(${target}) + if(DEFINED arg_TARGET_CREATED_HOOK) + if(CMAKE_VERSION VERSION_LESS "3.19") + set(incfile + "${CMAKE_CURRENT_BINARY_DIR}/.qt_internal_add_phony_target.cmake" + ) + file(WRITE "${incfile}" "${arg_TARGET_CREATED_HOOK}(${target})") + include("${incfile}") + file(REMOVE "${incfile}") + else() + cmake_language(CALL "${arg_TARGET_CREATED_HOOK}" "${target}") + endif() + endif() + endif() + endif() +endfunction() + +# Adds dependencies to a custom target that has been created with +# _qt_internal_add_phony_target. See the docstring at _qt_internal_add_phony_target for +# more details. +function(_qt_internal_add_phony_target_dependencies target) + set(dependencies ${ARGN}) + if(CMAKE_GENERATOR MATCHES "^Visual Studio ") + set_property(GLOBAL APPEND PROPERTY _qt_target_${target}_dependencies ${dependencies}) + + # Exclude the dependencies from the solution's default build to avoid them being enabled + # accidentally should the user add another dependency to them. + set_target_properties(${dependencies} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON) + else() + add_dependencies(${target} ${dependencies}) + endif() +endfunction() + +# Hack for the Visual Studio generator. Create the custom target named ${target} and work +# around the lack of a working add_dependencies by calling 'cmake --build' for every dependency. +function(_qt_internal_add_phony_target_deferred target) + get_property(target_dependencies GLOBAL PROPERTY _qt_target_${target}_dependencies) + set(target_commands "") + foreach(dependency IN LISTS target_dependencies) + list(APPEND target_commands + COMMAND "${CMAKE_COMMAND}" --build "${CMAKE_BINARY_DIR}" -t ${dependency} + ) + endforeach() + add_custom_target(${target} ${target_commands}) + get_property(creation_hook GLOBAL PROPERTY _qt_target_${target}_creation_hook) + if(creation_hook) + cmake_language(CALL ${creation_hook} ${target}) + endif() +endfunction() + +# The helper function that checks if module was included multiple times, and has the inconsistent +# set of targets that belong to the module. It's expected that either all 'targets' or none of them +# will be written to the 'targets_not_defined' variable, if the module was not or was +# searched before accordingly. +function(_qt_internal_check_multiple_inclusion targets_not_defined targets) + set(targets_defined "") + set(${targets_not_defined} "") + set(expected_targets "") + foreach(expected_target ${targets}) + list(APPEND expected_targets ${expected_target}) + if(NOT TARGET Qt::${expected_target}) + list(APPEND ${targets_not_defined} ${expected_target}) + endif() + if(TARGET Qt::${expected_target}) + list(APPEND targets_defined ${expected_target}) + endif() + endforeach() + if("${targets_defined}" STREQUAL "${expected_targets}") + set(${targets_not_defined} "" PARENT_SCOPE) + return() + endif() + if(NOT "${targets_defined}" STREQUAL "") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined." + "\nTargets Defined: ${targets_defined}\nTargets not yet defined: " + "${${targets_not_defined}}\n" + ) + endif() + set(${targets_not_defined} "${${targets_not_defined}}" PARENT_SCOPE) +endfunction() + +# The function is used when creating version less targets using ALIASes. +function(_qt_internal_create_versionless_alias_targets targets install_namespace) + foreach(target IN LISTS targets) + add_library(Qt::${target} ALIAS ${install_namespace}::${target}) + endforeach() +endfunction() + +# The function is used when creating version less targets from scratch but not using ALIASes. +# It assigns the known properties from the versioned targets to the versionless created in this +# function. This allows versionless targets mimic the versioned. +function(_qt_internal_create_versionless_targets targets install_namespace) + set(known_imported_properties + IMPORTED_LINK_DEPENDENT_LIBRARIES + ) + + set(known_interface_properties + QT_MAJOR_VERSION + AUTOMOC_MACRO_NAMES + AUTOUIC_OPTIONS + COMPILE_DEFINITIONS + COMPILE_FEATURES + COMPILE_OPTIONS + CXX_MODULE_SETS + HEADER_SETS + HEADER_SETS_TO_VERIFY + INCLUDE_DIRECTORIES + LINK_DEPENDS + LINK_DIRECTORIES + LINK_LIBRARIES + LINK_LIBRARIES_DIRECT + LINK_LIBRARIES_DIRECT_EXCLUDE + LINK_OPTIONS + POSITION_INDEPENDENT_CODE + PRECOMPILE_HEADERS + SOURCES + SYSTEM_INCLUDE_DIRECTORIES + ) + + set(known_qt_exported_properties + MODULE_PLUGIN_TYPES + QT_DISABLED_PRIVATE_FEATURES + QT_DISABLED_PUBLIC_FEATURES + QT_ENABLED_PRIVATE_FEATURES + QT_ENABLED_PUBLIC_FEATURES + QT_QMAKE_PRIVATE_CONFIG + QT_QMAKE_PUBLIC_CONFIG + QT_QMAKE_PUBLIC_QT_CONFIG + ) + + set(known_qt_exported_properties_interface_allowed + _qt_config_module_name + _qt_is_public_module + _qt_module_has_headers + _qt_module_has_private_headers + _qt_module_has_public_headers + _qt_module_has_qpa_headers + _qt_module_has_rhi_headers + _qt_module_include_name + _qt_module_interface_name + _qt_package_name + _qt_package_version + _qt_private_module_target_name + _qt_sbom_spdx_id + _qt_sbom_spdx_repo_document_namespace + _qt_sbom_spdx_relative_installed_repo_document_path + _qt_sbom_spdx_repo_project_name_lowercase + ) + + set(supported_target_types STATIC_LIBRARY MODULE_LIBRARY SHARED_LIBRARY OBJECT_LIBRARY + INTERFACE_LIBRARY) + + foreach(target IN LISTS targets) + if(NOT TARGET ${install_namespace}::${target}) + message(FATAL_ERROR "${install_namespace}::${target} is not a target, can not extend" + " an alias target") + endif() + + get_target_property(type ${install_namespace}::${target} TYPE) + if(NOT type) + message(FATAL_ERROR "Cannot get the ${install_namespace}::${target} target type.") + endif() + + if(NOT "${type}" IN_LIST supported_target_types) + message(AUTHOR_WARNING "${install_namespace}::${target} requires the versionless" + " target creation, but it has incompatible type ${type}.") + continue() + endif() + + string(REPLACE "_LIBRARY" "" creation_type "${type}") + add_library(Qt::${target} ${creation_type} IMPORTED) + + if(NOT "${type}" STREQUAL "INTERFACE_LIBRARY") + foreach(config "" _RELEASE _DEBUG _RELWITHDEBINFO _MINSIZEREL) + get_target_property(target_imported_location + ${install_namespace}::${target} IMPORTED_LOCATION${config}) + if(NOT target_imported_location) + if("${config}" STREQUAL "") + message(FATAL_ERROR "Cannot create versionless target for" + " ${install_namespace}::${target}. IMPORTED_LOCATION property is " + "missing." + ) + else() + continue() + endif() + endif() + set_property(TARGET Qt::${target} PROPERTY + IMPORTED_LOCATION${config} "${target_imported_location}") + + foreach(property IN LISTS known_imported_properties) + get_target_property(exported_property_value + ${install_namespace}::${target} ${property}${config}) + if(exported_property_value) + set_property(TARGET Qt::${target} APPEND PROPERTY + ${property} "${exported_property_value}") + endif() + endforeach() + endforeach() + + foreach(property IN LISTS known_qt_exported_properties) + get_target_property(exported_property_value + ${install_namespace}::${target} ${property}) + if(exported_property_value) + set_property(TARGET Qt::${target} APPEND PROPERTY + ${property} "${exported_property_value}") + endif() + endforeach() + endif() + + foreach(property IN LISTS known_interface_properties) + get_target_property(interface_property_value + ${install_namespace}::${target} INTERFACE_${property}) + if(interface_property_value) + set_property(TARGET Qt::${target} APPEND PROPERTY + INTERFACE_${property} "${interface_property_value}") + endif() + endforeach() + + foreach(property IN LISTS known_qt_exported_properties_interface_allowed) + get_target_property(exported_property_value + ${install_namespace}::${target} ${property}) + if(exported_property_value) + set_property(TARGET Qt::${target} APPEND PROPERTY + ${property} "${exported_property_value}") + endif() + endforeach() + + set_property(TARGET Qt::${target} PROPERTY _qt_is_versionless_target TRUE) + endforeach() +endfunction() + +# Checks whether any unparsed arguments have been passed to the function at the call site. +# Use this right after `cmake_parse_arguments`. +function(_qt_internal_validate_all_args_are_parsed prefix) + if(DEFINED ${prefix}_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown arguments: (${${prefix}_UNPARSED_ARGUMENTS})") + endif() +endfunction() + +# Takes a list of path components and joins them into one path separated by forward slashes "/", +# and saves the path in out_var. +function(_qt_internal_path_join out_var) + string(JOIN "/" path ${ARGN}) + set(${out_var} ${path} PARENT_SCOPE) +endfunction() + +# _qt_internal_qt_remove_args can remove arguments from an existing list of function +# arguments in order to pass a filtered list of arguments to a different function. +# Parameters: +# out_var: result of remove all arguments specified by ARGS_TO_REMOVE from ALL_ARGS +# ARGS_TO_REMOVE: Arguments to remove. +# ALL_ARGS: All arguments supplied to cmake_parse_arguments +# from which ARGS_TO_REMOVE should be removed from. We require all the +# arguments or we can't properly identify the range of the arguments detailed +# in ARGS_TO_REMOVE. +# ARGS: Arguments passed into the function, usually ${ARGV} +# +# E.g.: +# We want to forward all arguments from foo to bar, execpt ZZZ since it will +# trigger an error in bar. +# +# foo(target BAR .... ZZZ .... WWW ...) +# bar(target BAR.... WWW...) +# +# function(foo target) +# cmake_parse_arguments(PARSE_ARGV 1 arg "" "" "BAR;ZZZ;WWW") +# qt_remove_args(forward_args +# ARGS_TO_REMOVE ${target} ZZZ +# ALL_ARGS ${target} BAR ZZZ WWW +# ARGS ${ARGV} +# ) +# bar(${target} ${forward_args}) +# endfunction() +# +function(_qt_internal_remove_args out_var) + cmake_parse_arguments(arg "" "" "ARGS_TO_REMOVE;ALL_ARGS;ARGS" ${ARGN}) + set(result ${arg_ARGS}) + foreach(arg IN LISTS arg_ARGS_TO_REMOVE) + # find arg + list(FIND result ${arg} find_result) + if (NOT find_result EQUAL -1) + # remove arg + list(REMOVE_AT result ${find_result}) + list(LENGTH result result_len) + if(find_result EQUAL result_len) + # We removed the last argument, could have been an option keyword + continue() + endif() + list(GET result ${find_result} arg_current) + # remove values until we hit another arg or the end of the list + while(NOT "${arg_current}" IN_LIST arg_ALL_ARGS AND find_result LESS result_len) + list(REMOVE_AT result ${find_result}) + list(LENGTH result result_len) + if (NOT find_result EQUAL result_len) + list(GET result ${find_result} arg_current) + endif() + endwhile() + endif() + endforeach() + set(${out_var} "${result}" PARENT_SCOPE) +endfunction() + +# Append ${ARGN} to ${target}'s ${property_name} property, removing duplicates. +function(_qt_internal_append_to_target_property_without_duplicates target property_name) + get_target_property(property "${target}" "${property_name}") + if(NOT property) + set(property "") + endif() + list(APPEND property ${ARGN}) + list(REMOVE_DUPLICATES property) + set_property(TARGET "${target}" PROPERTY "${property_name}" "${property}") +endfunction() + +# Append ${ARGN} to global CMake ${property_name} property, removing duplicates. +function(_qt_internal_append_to_cmake_property_without_duplicates property_name) + get_cmake_property(property "${property_name}") + if(NOT property) + set(property "") + endif() + list(APPEND property ${ARGN}) + list(REMOVE_DUPLICATES property) + set_property(GLOBAL PROPERTY "${property_name}" "${property}") +endfunction() + +# Helper function to forward options from one function to another. +# +# This is somewhat the opposite of _qt_internal_remove_args. +# +# Parameters: +# FORWARD_PREFIX is usually arg because we pass cmake_parse_arguments(PARSE_ARGV 0 arg) in most code +# FORWARD_OPTIONS, FORWARD_SINGLE, FORWARD_MULTI are the options that should be forwarded. +# +# The forwarded args will be either set in arg_FORWARD_OUT_VAR or appended if FORWARD_APPEND is set. +# +# The function reads the options like ${arg_FORWARD_PREFIX}_${option} in the parent scope. +function(_qt_internal_forward_function_args) + set(opt_args + FORWARD_APPEND + ) + set(single_args + FORWARD_PREFIX + ) + set(multi_args + FORWARD_OPTIONS + FORWARD_SINGLE + FORWARD_MULTI + FORWARD_OUT_VAR + ) + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_FORWARD_OUT_VAR) + message(FATAL_ERROR "FORWARD_OUT_VAR must be provided.") + endif() + + set(forward_args "") + foreach(option_name IN LISTS arg_FORWARD_OPTIONS) + if(${arg_FORWARD_PREFIX}_${option_name}) + list(APPEND forward_args "${option_name}") + endif() + endforeach() + + foreach(option_name IN LISTS arg_FORWARD_SINGLE) + if(NOT "${${arg_FORWARD_PREFIX}_${option_name}}" STREQUAL "") + list(APPEND forward_args "${option_name}" "${${arg_FORWARD_PREFIX}_${option_name}}") + endif() + endforeach() + + foreach(option_name IN LISTS arg_FORWARD_MULTI) + if(NOT "${${arg_FORWARD_PREFIX}_${option_name}}" STREQUAL "") + list(APPEND forward_args "${option_name}" ${${arg_FORWARD_PREFIX}_${option_name}}) + endif() + endforeach() + + if(arg_FORWARD_APPEND) + set(forward_args ${${arg_FORWARD_OUT_VAR}} "${forward_args}") + endif() + + set(${arg_FORWARD_OUT_VAR} "${forward_args}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicCMakeVersionHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicCMakeVersionHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f063fb0bf10849e60a1c981277f43e3f3f17b837 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicCMakeVersionHelpers.cmake @@ -0,0 +1,91 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(__qt_internal_get_supported_min_cmake_version_for_using_qt out_var) + # This is recorded in Qt6ConfigExtras.cmake + set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT}") + set(${out_var} "${supported_version}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_get_computed_min_cmake_version_for_using_qt out_var) + # Allow override when configuring user project. + if(QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT) + set(computed_min_version "${QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT}") + + # Set in QtConfigExtras.cmake. + elseif(QT_COMPUTED_MIN_CMAKE_VERSION_FOR_USING_QT) + set(computed_min_version "${QT_COMPUTED_MIN_CMAKE_VERSION_FOR_USING_QT}") + else() + message(FATAL_ERROR + "Qt Developer error: Can't compute the minimum CMake version required to use this Qt.") + endif() + + set(${out_var} "${computed_min_version}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_warn_if_min_cmake_version_not_met) + __qt_internal_get_supported_min_cmake_version_for_using_qt(min_supported_version) + __qt_internal_get_computed_min_cmake_version_for_using_qt(computed_min_version) + + if(NOT min_supported_version STREQUAL computed_min_version + AND computed_min_version VERSION_LESS min_supported_version) + message(WARNING + "The minimum required CMake version to use Qt is: '${min_supported_version}'. " + "You have explicitly chosen to require a lower minimum CMake version: '${computed_min_version}'. " + "Using Qt with this CMake version is not officially supported. Use at your own risk." + ) + endif() +endfunction() + +function(__qt_internal_require_suitable_cmake_version_for_using_qt) + # Skip the public project check if we're building a Qt repo because it's too early to do + # it at find_package(Qt6) time. + # Instead, a separate check is done in qt_build_repo_begin. + # We detect a Qt repo by the presence of the QT_REPO_MODULE_VERSION variable set in .cmake.conf + # of each repo. + if(QT_REPO_MODULE_VERSION) + return() + endif() + + # Only do the setup once per directory scope, because Qt6 is a dependency for many packages, + # and a recursive call will show the warning multiple times. + if(__qt_internal_set_up_cmake_minimum_required_version_already_done) + return() + endif() + set(__qt_internal_set_up_cmake_minimum_required_version_already_done TRUE PARENT_SCOPE) + + # Check the overall minimum required CMake version when consuming any Qt CMake package. + __qt_internal_warn_if_min_cmake_version_not_met() + __qt_internal_get_computed_min_cmake_version_for_using_qt(computed_min_version) + + if(CMAKE_VERSION VERSION_LESS computed_min_version) + set(major_minor "${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}") + message(FATAL_ERROR + "CMake ${computed_min_version} or higher is required to use Qt. " + "You are running version ${CMAKE_VERSION} " + "Qt requires newer CMake features to work correctly. You can lower the minimum " + "required version by passing " + "-DQT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT=${major_minor} when configuring the " + "project. Using Qt with this CMake version is not officially supported. " + "Use at your own risk.") + endif() +endfunction() + +function(__qt_internal_set_cmp0156) + if(POLICY CMP0156) + if(QT_FORCE_CMP0156_TO_NEW) + cmake_policy(SET CMP0156 "NEW") + else() + cmake_policy(GET CMP0156 policy_value) + if(NOT "${policy_value}" STREQUAL "OLD") + if("${policy_value}" STREQUAL "NEW" AND NOT QT_BUILDING_QT) + message(WARNING "CMP0156 is set to '${policy_value}'. Qt forces the 'OLD'" + " behavior of this policy by default. Set QT_FORCE_CMP0156_TO_NEW=ON to" + " force the 'NEW' behavior for the Qt commands that create either" + " library or executable targets.") + endif() + cmake_policy(SET CMP0156 "OLD") + endif() + endif() + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicDependencyHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicDependencyHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1a6d7eae3775b5b66e35ef582d7b9df655f07a8c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicDependencyHelpers.cmake @@ -0,0 +1,328 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Note that target_dep_list does not accept a list of values, but a var name that contains the +# list of dependencies. See foreach block for reference. +macro(_qt_internal_find_third_party_dependencies target target_dep_list) + foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list}) + list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg) + list(GET __qt_${target}_target_dep 1 __qt_${target}_is_optional) + list(GET __qt_${target}_target_dep 2 __qt_${target}_version) + list(GET __qt_${target}_target_dep 3 __qt_${target}_components) + list(GET __qt_${target}_target_dep 4 __qt_${target}_optional_components) + set(__qt_${target}_find_package_args "${__qt_${target}_pkg}") + if(__qt_${target}_version) + list(APPEND __qt_${target}_find_package_args "${__qt_${target}_version}") + endif() + if(__qt_${target}_components) + string(REPLACE " " ";" __qt_${target}_components "${__qt_${target}_components}") + list(APPEND __qt_${target}_find_package_args COMPONENTS ${__qt_${target}_components}) + endif() + if(__qt_${target}_optional_components) + string(REPLACE " " ";" + __qt_${target}_optional_components "${__qt_${target}_optional_components}") + list(APPEND __qt_${target}_find_package_args + OPTIONAL_COMPONENTS ${__qt_${target}_optional_components}) + endif() + + _qt_internal_save_find_package_context_for_debugging(${target}) + + if(__qt_${target}_is_optional) + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + list(APPEND __qt_${target}_find_package_args QUIET) + endif() + find_package(${__qt_${target}_find_package_args}) + else() + find_dependency(${__qt_${target}_find_package_args}) + endif() + + _qt_internal_get_package_components_id( + PACKAGE_NAME "${__qt_${target}_pkg}" + COMPONENTS ${__qt_${target}_components} + OPTIONAL_COMPONENTS ${__qt_${target}_optional_components} + OUT_VAR_KEY __qt_${target}_package_components_id + ) + if(${__qt_${target}_pkg}_FOUND + AND __qt_${target}_third_party_package_${__qt_${target}_package_components_id}_provided_targets) + set(__qt_${target}_sbom_args "") + + if(${__qt_${target}_pkg}_VERSION) + list(APPEND __qt_${target}_sbom_args + PACKAGE_VERSION "${${__qt_${target}_pkg}_VERSION}" + ) + endif() + + foreach(__qt_${target}_provided_target + IN LISTS + __qt_${target}_third_party_package_${__qt_${target}_package_components_id}_provided_targets) + + _qt_internal_promote_3rd_party_provided_target_and_3rd_party_deps_to_global( + "${__qt_${target}_provided_target}") + + _qt_internal_sbom_record_system_library_usage( + "${__qt_${target}_provided_target}" + TYPE SYSTEM_LIBRARY + FRIENDLY_PACKAGE_NAME "${__qt_${target}_pkg}" + ${__qt_${target}_sbom_args} + ) + endforeach() + endif() + endforeach() +endmacro() + +# Note that target_dep_list does not accept a list of values, but a var name that contains the +# list of dependencies. See foreach block for reference. +macro(_qt_internal_find_tool_dependencies target target_dep_list) + if(NOT "${${target_dep_list}}" STREQUAL "" AND NOT "${QT_HOST_PATH}" STREQUAL "") + # Make sure that the tools find the host tools first + set(BACKUP_${target}_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH}) + set(BACKUP_${target}_CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH}) + list(PREPEND CMAKE_PREFIX_PATH "${QT_HOST_PATH_CMAKE_DIR}" + "${_qt_additional_host_packages_prefix_paths}") + list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_HOST_PATH}" + "${_qt_additional_host_packages_root_paths}") + endif() + + foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list}) + list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg) + list(GET __qt_${target}_target_dep 1 __qt_${target}_version) + + unset(__qt_${target}_find_package_args) + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + list(APPEND __qt_${target}_find_package_args QUIET) + endif() + + _qt_internal_save_find_package_context_for_debugging(${target}) + + find_package(${__qt_${target}_pkg} + ${__qt_${target}_version} + ${__qt_${target}_find_package_args} + PATHS + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ) + if (NOT ${__qt_${target}_pkg}_FOUND AND NOT QT_ALLOW_MISSING_TOOLS_PACKAGES) + set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE +"${CMAKE_FIND_PACKAGE_NAME} could not be found because dependency \ +${__qt_${target}_pkg} could not be found.") + if(NOT "${QT_HOST_PATH}" STREQUAL "") + set(CMAKE_PREFIX_PATH ${BACKUP_${target}_CMAKE_PREFIX_PATH}) + set(CMAKE_FIND_ROOT_PATH ${BACKUP_${target}_CMAKE_FIND_ROOT_PATH}) + endif() + return() + endif() + endforeach() + if(NOT "${${target_dep_list}}" STREQUAL "" AND NOT "${QT_HOST_PATH}" STREQUAL "") + set(CMAKE_PREFIX_PATH ${BACKUP_${target}_CMAKE_PREFIX_PATH}) + set(CMAKE_FIND_ROOT_PATH ${BACKUP_${target}_CMAKE_FIND_ROOT_PATH}) + endif() +endmacro() + +# Please note the target_dep_list accepts not the actual list values but the list names that +# contain preformed dependencies. See foreach block for reference. +# The same applies for find_dependency_path_list. +macro(_qt_internal_find_qt_dependencies target target_dep_list find_dependency_path_list) + foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list}) + list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg) + list(GET __qt_${target}_target_dep 1 __qt_${target}_version) + + if (NOT ${__qt_${target}_pkg}_FOUND) + + # TODO: Remove Private handling once sufficient time has passed, aka all developers + # updated their builds not to contain stale FooDependencies.cmake files without the + # _qt_package_name property. + set(__qt_${target}_pkg_names ${__qt_${target}_pkg}) + if(__qt_${target}_pkg MATCHES "(.*)Private$") + set(__qt_${target}_pkg_names "${CMAKE_MATCH_1};${__qt_${target}_pkg}") + endif() + + _qt_internal_save_find_package_context_for_debugging(${target}) + + find_dependency(${__qt_${target}_pkg} ${__qt_${target}_version} + NAMES + ${__qt_${target}_pkg_names} + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + ${${find_dependency_path_list}} + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) + endif() + endforeach() +endmacro() + + +# TODO: Remove once a dependency update completes and most developers have the Dependencies.cmake +# files updated in their builds. +# The name is too generic, it doesn't look for any kind of dependencies but only Qt package +# dependencies. +macro(_qt_internal_find_dependencies target_dep_list find_dependency_path_list) + _qt_internal_find_qt_dependencies("none" "${target_dep_list}" "${find_dependency_path_list}") +endmacro() + +# If a dependency package was not found, provide some hints in the error message on how to debug +# the issue. +# +# pkg_name_var should be the variable name that contains the package that was not found. +# e.g. __qt_Core_pkg +# +# message_out_var should contain the variable name of the original "not found" message, and it +# will have the hints appended to it as a string. e.g. ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE +# +# infix is used as a unique prefix to retrieve the find_package paths context for the last package +# that was not found, for debugging purposes. +# +# The function should not be called in Dependencies.cmake files directly, because find_dependency +# returns out of the included file. +macro(_qt_internal_suggest_dependency_debugging infix pkg_name_var message_out_var) + if(${pkg_name_var} + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FOUND + AND ${message_out_var}) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.23") + string(APPEND ${message_out_var} + "\nConfiguring with --debug-find-pkg=${${pkg_name_var}} might reveal \ +details why the package was not found.") + elseif(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17") + string(APPEND ${message_out_var} + "\nConfiguring with -DCMAKE_FIND_DEBUG_MODE=TRUE might reveal \ +details why the package was not found.") + endif() + + if(NOT QT_DEBUG_FIND_PACKAGE) + string(APPEND ${message_out_var} + "\nConfiguring with -DQT_DEBUG_FIND_PACKAGE=ON will print the values of some of \ +the path variables that find_package uses to try and find the package.") + else() + string(APPEND ${message_out_var} + "\n find_package search path values and other context for the last package that was not found:" + "\n CMAKE_MODULE_PATH: ${_qt_${infix}_CMAKE_MODULE_PATH}" + "\n CMAKE_PREFIX_PATH: ${_qt_${infix}_CMAKE_PREFIX_PATH}" + "\n \$ENV{CMAKE_PREFIX_PATH}: $ENV{CMAKE_PREFIX_PATH}" + "\n CMAKE_FIND_ROOT_PATH: ${_qt_${infix}_CMAKE_FIND_ROOT_PATH}" + "\n _qt_additional_packages_prefix_paths: ${_qt_${infix}_qt_additional_packages_prefix_paths}" + "\n _qt_additional_host_packages_prefix_paths: ${_qt_${infix}_qt_additional_host_packages_prefix_paths}" + "\n _qt_cmake_dir: ${_qt_${infix}_qt_cmake_dir}" + "\n QT_HOST_PATH: ${QT_HOST_PATH}" + "\n Qt6HostInfo_DIR: ${Qt6HostInfo_DIR}" + "\n Qt6_DIR: ${Qt6_DIR}" + "\n CMAKE_TOOLCHAIN_FILE: ${CMAKE_TOOLCHAIN_FILE}" + "\n CMAKE_FIND_ROOT_PATH_MODE_PACKAGE: ${CMAKE_FIND_ROOT_PATH_MODE_PACKAGE}" + "\n CMAKE_SYSROOT: ${CMAKE_SYSROOT}" + "\n \$ENV{PATH}: $ENV{PATH}" + ) + endif() + endif() +endmacro() + +# Save find_package search paths context just before a find_package call, to be shown with a +# package not found message. +macro(_qt_internal_save_find_package_context_for_debugging infix) + if(QT_DEBUG_FIND_PACKAGE) + set(_qt_${infix}_CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}") + set(_qt_${infix}_CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH}") + set(_qt_${infix}_CMAKE_FIND_ROOT_PATH "${CMAKE_FIND_ROOT_PATH}") + set(_qt_${infix}_qt_additional_packages_prefix_paths + "${_qt_additional_packages_prefix_paths}") + set(_qt_${infix}_qt_additional_host_packages_prefix_paths + "${_qt_additional_host_packages_prefix_paths}") + set(_qt_${infix}_qt_cmake_dir "${_qt_cmake_dir}") + endif() +endmacro() + +function(_qt_internal_determine_if_host_info_package_needed out_var) + set(needed FALSE) + + # If a QT_HOST_PATH is provided when configuring qtbase, we assume it's a cross build + # and thus we require the QT_HOST_PATH to be provided also when using the cross-built Qt. + # This tells the QtConfigDependencies file to do appropriate requirement checks. + if(NOT "${QT_HOST_PATH}" STREQUAL "" AND NOT QT_NO_REQUIRE_HOST_PATH_CHECK) + set(needed TRUE) + endif() + set(${out_var} "${needed}" PARENT_SCOPE) +endfunction() + +macro(_qt_internal_find_host_info_package platform_requires_host_info) + if(${platform_requires_host_info}) + find_package(Qt6HostInfo + CONFIG + REQUIRED + PATHS "${QT_HOST_PATH}" + "${QT_HOST_PATH_CMAKE_DIR}" + NO_CMAKE_FIND_ROOT_PATH + NO_DEFAULT_PATH) + endif() +endmacro() + +macro(_qt_internal_setup_qt_host_path + host_path_required + initial_qt_host_path + initial_qt_host_path_cmake_dir + ) + # Set up QT_HOST_PATH and do sanity checks. + # A host path is required when cross-compiling but optional when doing a native build. + # Requiredness can be overridden via variable. + if(DEFINED QT_REQUIRE_HOST_PATH_CHECK) + set(_qt_platform_host_path_required "${QT_REQUIRE_HOST_PATH_CHECK}") + elseif(DEFINED ENV{QT_REQUIRE_HOST_PATH_CHECK}) + set(_qt_platform_host_path_required "$ENV{QT_REQUIRE_HOST_PATH_CHECK}") + else() + set(_qt_platform_host_path_required "${host_path_required}") + endif() + + if(_qt_platform_host_path_required) + # QT_HOST_PATH precedence: + # - cache variable / command line option + # - environment variable + # - initial QT_HOST_PATH when qtbase was configured (and the directory exists) + if(NOT DEFINED QT_HOST_PATH) + if(DEFINED ENV{QT_HOST_PATH}) + set(QT_HOST_PATH "$ENV{QT_HOST_PATH}" CACHE PATH "") + elseif(NOT "${initial_qt_host_path}" STREQUAL "" AND EXISTS "${initial_qt_host_path}") + set(QT_HOST_PATH "${initial_qt_host_path}" CACHE PATH "") + endif() + endif() + + if(NOT QT_HOST_PATH STREQUAL "") + get_filename_component(_qt_platform_host_path_absolute "${QT_HOST_PATH}" ABSOLUTE) + endif() + + if("${QT_HOST_PATH}" STREQUAL "" OR NOT EXISTS "${_qt_platform_host_path_absolute}") + message(FATAL_ERROR + "To use a cross-compiled Qt, please set the QT_HOST_PATH cache variable to the " + "location of your host Qt installation.") + endif() + + # QT_HOST_PATH_CMAKE_DIR is needed to work around the rerooting issue when looking for host + # tools. See REROOT_PATH_ISSUE_MARKER. + # Prefer initially configured path if none was explicitly set. + if(NOT DEFINED QT_HOST_PATH_CMAKE_DIR) + if(NOT "${initial_qt_host_path_cmake_dir}" STREQUAL "" + AND EXISTS "${initial_qt_host_path_cmake_dir}") + set(QT_HOST_PATH_CMAKE_DIR "${initial_qt_host_path_cmake_dir}" CACHE PATH "") + else() + # First try to auto-compute the location instead of requiring to set + # QT_HOST_PATH_CMAKE_DIR explicitly. + set(__qt_candidate_host_path_cmake_dir "${QT_HOST_PATH}/lib/cmake") + if(__qt_candidate_host_path_cmake_dir + AND EXISTS "${__qt_candidate_host_path_cmake_dir}") + set(QT_HOST_PATH_CMAKE_DIR + "${__qt_candidate_host_path_cmake_dir}" CACHE PATH "") + endif() + endif() + endif() + + if(NOT QT_HOST_PATH_CMAKE_DIR STREQUAL "") + get_filename_component(_qt_platform_host_path_cmake_dir_absolute + "${QT_HOST_PATH_CMAKE_DIR}" ABSOLUTE) + endif() + + if("${QT_HOST_PATH_CMAKE_DIR}" STREQUAL "" + OR NOT EXISTS "${_qt_platform_host_path_cmake_dir_absolute}") + message(FATAL_ERROR + "To use a cross-compiled Qt, please set the QT_HOST_PATH_CMAKE_DIR cache variable " + "to the location of your host Qt installation lib/cmake directory.") + endif() + endif() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicExternalProjectHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicExternalProjectHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2d77cafc51ee853fc8d7a37488088bf1b53c4761 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicExternalProjectHelpers.cmake @@ -0,0 +1,86 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard() + +# Get CMake variables that are needed to build external projects such as examples or CMake test +# projects. +# +# CMAKE_DIR_VAR: Variable name to store the path to the Qt6 CMake config module. +# +# PREFIXES_VAR: Variable name to store the prefixes that can be passed as CMAKE_PREFIX_PATH. +# +# ADDITIONAL_PACKAGES_PREFIXES_VAR: Variable name to store the prefixes that can be appended to +# QT_ADDITIONAL_PACKAGES_PREFIX_PATH. +function(_qt_internal_get_build_vars_for_external_projects) + set(no_value_options "") + set(single_value_options + CMAKE_DIR_VAR + PREFIXES_VAR + ADDITIONAL_PACKAGES_PREFIXES_VAR + ) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + # Standalone tests and examples have QT_BUILD_DIR pointing to the fake standalone prefix. + # Use instead the relocatable prefix, because qt must have been built / installed by this point. + if(QT_INTERNAL_BUILD_STANDALONE_PARTS) + qt_path_join(qt_cmake_dir + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}" + "${INSTALL_LIBDIR}/cmake/${QT_CMAKE_EXPORT_NAMESPACE}" + ) + + set(qt_prefixes "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}") + set(qt_additional_packages_prefixes "${qt_prefixes}") + + if(QT_WILL_INSTALL) + list(APPEND qt_prefixes "${QT6_INSTALL_PREFIX}") + endif() + # TODO: Fix example/test builds when using Conan / install prefixes are different for each repo. + elseif(QT_SUPERBUILD OR QtBase_BINARY_DIR) + # When doing a top-level build or when building qtbase, + # always use the Config file from the current build directory, even for prefix builds. + # We strive to allow building examples without installing Qt first, which means we can't + # use the install or staging Config files. + set(qt_prefixes "${QT_BUILD_DIR}") + set(qt_cmake_dir "${QT_CONFIG_BUILD_DIR}/${QT_CMAKE_EXPORT_NAMESPACE}") + set(qt_additional_packages_prefixes "") + else() + # This is a per-repo build that isn't the qtbase repo, so we know that + # qtbase was found via find_package() and Qt6_DIR must be set + set(qt_cmake_dir "${${QT_CMAKE_EXPORT_NAMESPACE}_DIR}") + + # In a prefix build of a non-qtbase repo, we want to pick up the installed Config files + # for all repos except the one that is currently built. For the repo that is currently + # built, we pick up the Config files from the current repo build dir instead. + # For non-prefix builds, there's only one prefix, the main build dir. + # Both are handled by this assignment. + set(qt_prefixes "${QT_BUILD_DIR}") + + # Appending to QT_ADDITIONAL_PACKAGES_PREFIX_PATH helps find Qt6 components in + # non-qtbase prefix builds because we use NO_DEFAULT_PATH in find_package calls. + # It also handles the cross-compiling scenario where we need to adjust both the root path + # and prefixes, with the prefixes containing lib/cmake. This leverages the infrastructure + # previously added for Conan. + set(qt_additional_packages_prefixes "${qt_prefixes}") + + # In a prefix build, look up all repo Config files in the install prefix, + # except for the current repo, which will look in the build dir (handled above). + if(QT_WILL_INSTALL) + list(APPEND qt_prefixes "${QT6_INSTALL_PREFIX}") + endif() + endif() + + if(arg_CMAKE_DIR_VAR) + set("${arg_CMAKE_DIR_VAR}" "${qt_cmake_dir}" PARENT_SCOPE) + endif() + if(arg_PREFIXES_VAR) + set("${arg_PREFIXES_VAR}" "${qt_prefixes}" PARENT_SCOPE) + endif() + if(arg_ADDITIONAL_PACKAGES_PREFIXES_VAR) + set("${arg_ADDITIONAL_PACKAGES_PREFIXES_VAR}" "${qt_additional_packages_prefixes}" + PARENT_SCOPE) + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicFinalizerHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicFinalizerHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bebc4426708203e894a7eeee48495ede39c71f72 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicFinalizerHelpers.cmake @@ -0,0 +1,35 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Helper to check if the finalizer mode should be used. +# If true, use finalizer mode. +# If false, use regular mode (usage requirement propagation via associated Qt module) +# Arguments: +# DEFAULT_VALUE specifies the default value of the finalizer mode flag if it is not set. +function(__qt_internal_check_finalizer_mode target out_var finalizer) + set(option_args "") + set(single_args DEFAULT_VALUE) + set(multi_args "") + cmake_parse_arguments(arg "${option_args}" "${single_args}" "${multi_args}" ${ARGN}) + + if(NOT DEFINED arg_DEFAULT_VALUE OR arg_DEFAULT_VALUE) + set(arg_DEFAULT_VALUE TRUE) + else() + set(arg_DEFAULT_VALUE FALSE) + endif() + get_target_property(value ${target} _qt_${finalizer}_finalizer_mode) + if("${value}" STREQUAL "value-NOTFOUND") + __qt_internal_enable_finalizer_mode(${target} ${finalizer} "${arg_DEFAULT_VALUE}") + set(value "${arg_DEFAULT_VALUE}") + endif() + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_enable_finalizer_mode target finalizer enabled) + if(enabled) + set(enabled "TRUE") + else() + set(enabled "FALSE") + endif() + set_property(TARGET "${target}" PROPERTY _qt_${finalizer}_finalizer_mode "${enabled}") +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicFindPackageHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicFindPackageHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b1d58f753282f3c3e315846fd17e4265132e44fe --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicFindPackageHelpers.cmake @@ -0,0 +1,55 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_internal_disable_find_package_global_promotion target) + set_target_properties("${target}" PROPERTIES _qt_no_promote_global TRUE) +endfunction() + +# Transforms a list of package components into a string, so it can serve as a valid infix +# in a property name. +function(_qt_internal_get_package_components_as_valid_key_infix value out_var) + string(REPLACE ";" "_" valid_value "${value}") + set(${out_var} "${valid_value}" PARENT_SCOPE) +endfunction() + +# This function computes a unique key / id using the package name and the components that are +# passed. +# The result is later used as property name, to store provided targets for a specific +# package + components combination. +function(_qt_internal_get_package_components_id) + set(opt_args "") + set(single_args + PACKAGE_NAME + OUT_VAR_KEY + ) + set(multi_args + COMPONENTS + OPTIONAL_COMPONENTS + ) + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_PACKAGE_NAME) + message(FATAL_ERROR "PACKAGE_NAME is required") + endif() + + if(NOT arg_OUT_VAR_KEY) + message(FATAL_ERROR "OUT_VAR_KEY is required") + endif() + + set(key "${arg_PACKAGE_NAME}") + + if(arg_COMPONENTS) + _qt_internal_get_package_components_as_valid_key_infix("${arg_COMPONENTS}" + components_as_string) + string(APPEND key "-${components_as_string}") + endif() + + if(arg_OPTIONAL_COMPONENTS) + _qt_internal_get_package_components_as_valid_key_infix("${arg_OPTIONAL_COMPONENTS}" + components_as_string) + string(APPEND key "-${components_as_string}") + endif() + + set(${arg_OUT_VAR_KEY} "${key}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicGitHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicGitHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f8b68584a82587384c196350e33ae11bfa77edc8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicGitHelpers.cmake @@ -0,0 +1,153 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# Copyright (C) 2023-2024 Jochem Rutgers +# SPDX-License-Identifier: BSD-3-Clause AND MIT + +macro(_qt_internal_find_git_package) + find_package(Git) +endmacro() + +# Helper to set the various git version variables in the parent scope across multiple return points. +macro(_qt_internal_set_git_query_variables) + set("${arg_OUT_VAR_PREFIX}git_hash" "${version_git_hash}" PARENT_SCOPE) + set("${arg_OUT_VAR_PREFIX}git_hash_short" "${version_git_head}" PARENT_SCOPE) + set("${arg_OUT_VAR_PREFIX}git_version" "${git_version}" PARENT_SCOPE) + + # git version sanitized for file paths. + string(REGEX REPLACE "[^-a-zA-Z0-9_.]+" "+" git_version_path "${git_version}") + set("${arg_OUT_VAR_PREFIX}git_version_path" "${git_version_path}" PARENT_SCOPE) +endmacro() + +# Caches the results per working-directory in global cmake properties. +# Sets the following variables in the outer scope: +# - git_hash: Full git hash. +# - git_hash_short: Short git hash. +# - git_version: Git version string. +# - git_version_path: Git version string sanitized for file paths. +function(_qt_internal_query_git_version) + set(opt_args + EMPTY_VALUE_WHEN_NOT_GIT_REPO + ) + set(single_args + WORKING_DIRECTORY + OUT_VAR_PREFIX + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(arg_EMPTY_VALUE_WHEN_NOT_GIT_REPO) + set(version_git_head "") + set(version_git_hash "") + set(version_git_branch "") + set(version_git_tag "") + set(git_version "") + else() + set(version_git_head "unknown") + set(version_git_hash "") + set(version_git_branch "dev") + set(version_git_tag "") + set(git_version "${version_git_head}+${version_git_branch}") + endif() + + if(NOT Git_FOUND) + message(STATUS "Git not found, skipping querying git version.") + _qt_internal_set_git_query_variables() + return() + endif() + + if(arg_WORKING_DIRECTORY) + set(working_directory "${arg_WORKING_DIRECTORY}") + else() + set(working_directory "${PROJECT_SOURCE_DIR}") + endif() + + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --is-inside-work-tree + WORKING_DIRECTORY "${working_directory}" + OUTPUT_VARIABLE is_inside_work_tree_output + RESULT_VARIABLE is_inside_work_tree_result + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + if((NOT is_inside_work_tree_result EQUAL 0) OR (NOT is_inside_work_tree_output STREQUAL "true")) + message(STATUS "Git repo not found, skipping querying git version.") + _qt_internal_set_git_query_variables() + return() + endif() + + get_cmake_property(git_hash_cache _qt_git_hash_cache_${working_directory}) + get_cmake_property(git_hash_short_cache _qt_git_hash_short_cache_${working_directory}) + get_cmake_property(git_version_cache _qt_git_version_cache_${working_directory}) + get_cmake_property(git_version_path_cache _qt_git_version_path_cache_${working_directory}) + if(git_hash_cache) + set(git_hash "${git_hash_cache}") + set(git_hash_short "${git_hash_short_cache}") + set(git_version "${git_version_cache}") + set(git_version_path "${git_version_path_cache}") + _qt_internal_set_git_query_variables() + return() + endif() + + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD + WORKING_DIRECTORY "${working_directory}" + OUTPUT_VARIABLE version_git_head + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse HEAD + WORKING_DIRECTORY "${working_directory}" + OUTPUT_VARIABLE version_git_hash + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD + WORKING_DIRECTORY "${working_directory}" + OUTPUT_VARIABLE version_git_branch + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + execute_process( + COMMAND ${GIT_EXECUTABLE} tag --points-at HEAD + WORKING_DIRECTORY "${working_directory}" + OUTPUT_VARIABLE version_git_tag + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + string(REGEX REPLACE "[ \t\r\n].*$" "" version_git_tag "${version_git_tag}") + + execute_process( + COMMAND ${GIT_EXECUTABLE} status -s + WORKING_DIRECTORY "${working_directory}" + OUTPUT_VARIABLE version_git_dirty + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + if(NOT "${version_git_dirty}" STREQUAL "") + set(version_git_dirty "+dirty") + endif() + + if(NOT "${version_git_tag}" STREQUAL "") + set(git_version "${version_git_tag}") + + if("${git_version}" MATCHES "^v[0-9]+\.") + string(REGEX REPLACE "^v" "" git_version "${git_version}") + endif() + + set(git_version "${git_version}${version_git_dirty}") + else() + set(git_version + "${version_git_head}+${version_git_branch}${version_git_dirty}" + ) + endif() + + set_property(GLOBAL PROPERTY _qt_git_hash_cache_${working_directory} "${git_hash}") + set_property(GLOBAL PROPERTY _qt_git_hash_short_cache_${working_directory} "${git_hash_short}") + set_property(GLOBAL PROPERTY _qt_git_version_cache_${working_directory} "${git_version}") + set_property(GLOBAL PROPERTY _qt_git_version_path_cache_${working_directory} + "${git_version_path}") + + _qt_internal_set_git_query_variables() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicPluginHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicPluginHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..543815598a4940f95e867d11687508d65cd1e3a2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicPluginHelpers.cmake @@ -0,0 +1,562 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Gets the qt plugin type of the given plugin into out_var_plugin_type. +# Also sets out_var_has_plugin_type to TRUE or FALSE depending on whether the plugin type was found. +function(__qt_internal_plugin_get_plugin_type + plugin_target + out_var_has_plugin_type + out_var_plugin_type) + set(has_plugin_type TRUE) + + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + + get_target_property(_plugin_type "${plugin_target_versioned}" QT_PLUGIN_TYPE) + if(NOT _plugin_type) + message("Warning: plugin ${plugin_target_versioned} has no plugin type set, skipping.") + set(has_plugin_type FALSE) + else() + set(${out_var_plugin_type} "${_plugin_type}" PARENT_SCOPE) + endif() + + set(${out_var_has_plugin_type} "${has_plugin_type}" PARENT_SCOPE) +endfunction() + +# Gets the qt plugin class name of the given target into out_var. +function(__qt_internal_plugin_has_class_name plugin_target out_var) + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + + get_target_property(classname "${plugin_target_versioned}" QT_PLUGIN_CLASS_NAME) + if(NOT classname) + message("Warning: plugin ${plugin_target_versioned} has no class name, skipping.") + endif() + + # If unset, it will be -NOTFOUND and still evaluate to false. + set(${out_var} "${classname}" PARENT_SCOPE) +endfunction() + +# Constructs a generator expression which decides whether a plugin will be used. +# +# The conditions are based on the various properties set in qt_import_plugins. + +# All the TARGET_PROPERTY genexes are evaluated in the context of the currently linked target, +# unless the TARGET argument is given. +# +# The genex is saved into out_var. +function(__qt_internal_get_static_plugin_condition_genex + plugin_target_unprefixed + out_var) + set(options) + set(oneValueArgs TARGET) + set(multiValueArgs) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(plugin_target "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target_unprefixed}") + set(plugin_target_versionless "Qt::${plugin_target_unprefixed}") + + get_target_property(_plugin_type "${plugin_target}" QT_PLUGIN_TYPE) + + set(target_infix "") + if(arg_TARGET) + set(target_infix "${arg_TARGET},") + endif() + + set(_default_plugins_are_enabled + "$>,0>>") + set(_manual_plugins_genex "$>") + set(_no_plugins_genex "$>") + + # Plugin genex marker for prl processing. + set(_is_plugin_marker_genex "$") + + set(_plugin_is_default "$") + + # The code in here uses the properties defined in qt_import_plugins (Qt6CoreMacros.cmake) + + # INCLUDE + set(_plugin_is_whitelisted "$") + set(_plugin_versionless_is_whitelisted + "$") + + # Note: qt_import_plugins sets the QT_PLUGINS_${_plugin_type} to "-" + # when excluding it with EXCLUDE_BY_TYPE, + # which ensures that no plug-in will be supported unless explicitly re-added afterwards. + string(CONCAT _plugin_is_not_blacklisted + "$" + ">," + "$" + ">," + # Excludes both plugins targeted by EXCLUDE_BY_TYPE and not included in + # INCLUDE_BY_TYPE. + "$>>" + ">" + ) + + # Support INCLUDE_BY_TYPE + string(CONCAT _plugin_is_in_type_whitelist + "$" + ">" + ">" + ) + string(CONCAT _plugin_versionless_is_in_type_whitelist + "$" + ">" + ">" + ) + + # No point in linking the plugin initialization source file into static libraries. The + # initialization symbol will be discarded by the linker when the static lib is linked into an + # executable or shared library, because nothing is referencing the global static symbol. + set(type_genex "$") + set(no_static_genex "$>") + + # Complete condition that defines whether a static plugin is linked + string(CONCAT _plugin_condition + "$" + ">" + ">>" + ) + + set(${out_var} "${_plugin_condition}" PARENT_SCOPE) +endfunction() + +# Wraps the genex condition to evaluate to true only when using the regular plugin importing mode +# (not finalizer mode). +function(__qt_internal_get_plugin_condition_regular_mode plugin_condition out_var) + set(not_finalizer_mode "$>>") + set(full_plugin_condition "$") + set(${out_var} "${full_plugin_condition}" PARENT_SCOPE) +endfunction() + +# Link plugin via usage requirements of associated Qt module. +function(__qt_internal_add_static_plugin_linkage plugin_target qt_module_target) + __qt_internal_get_static_plugin_condition_genex("${plugin_target}" plugin_condition) + __qt_internal_get_plugin_condition_regular_mode("${plugin_condition}" full_plugin_condition) + + set(plugin_target "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + + # If this condition is true, we link against the plug-in + set(plugin_genex "$<${full_plugin_condition}:${plugin_target}>") + target_link_libraries(${qt_module_target} INTERFACE "${plugin_genex}") +endfunction() + +# Generates C++ import macro source code for given plugin +function(__qt_internal_get_plugin_import_macro plugin_target out_var) + set(plugin_target_prefixed "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + + # Query the class name of plugin targets prefixed with a Qt namespace and without, this is + # needed to support plugin object initializers created by user projects. + set(class_name"") + set(class_name_prefixed "") + + if(TARGET ${plugin_target}) + get_target_property(class_name "${plugin_target}" QT_PLUGIN_CLASS_NAME) + endif() + + if(TARGET ${plugin_target_prefixed}) + get_target_property(class_name_prefixed "${plugin_target_prefixed}" QT_PLUGIN_CLASS_NAME) + endif() + + if(NOT class_name AND NOT class_name_prefixed) + message(FATAL_ERROR "No QT_PLUGIN_CLASS_NAME value on target: '${plugin_target}'") + endif() + + # Qt prefixed target takes priority. + if(class_name_prefixed) + set(class_name "${class_name_prefixed}") + endif() + + set(${out_var} "Q_IMPORT_PLUGIN(${class_name})\n" PARENT_SCOPE) +endfunction() + +function(__qt_internal_get_plugin_include_prelude out_var) + set(${out_var} "#include \n" PARENT_SCOPE) +endfunction() + +# Set up plugin initialization via usage requirements of associated Qt module. +# +# Adds the plugin init object library as an INTERFACE source of the plugin target. +# This is similar to how it was done before, except instead of generating a C++ file and compiling +# it as part of the user project, we just specify the pre-compiled object file as an INTERFACE +# source so that user projects don't have to compile it. User project builds will thus be shorter. +function(__qt_internal_add_static_plugin_import_macro + plugin_target + qt_module_target + qt_module_unprefixed) + + __qt_internal_get_static_plugin_init_target_name("${plugin_target}" plugin_init_target) + set(plugin_init_target_namespaced "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_init_target}") + + __qt_internal_propagate_object_library( + "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}" + "${plugin_init_target_namespaced}" + EXTRA_CONDITIONS + "$>>" + ) +endfunction() + +# Get target name of object library which is used to initialize a qt plugin. +function(__qt_internal_get_static_plugin_init_target_name plugin_target out_var) + # Keep the target name short, so we don't hit long path issues on Windows. + set(plugin_init_target "${plugin_target}_init") + + set(${out_var} "${plugin_init_target}" PARENT_SCOPE) +endfunction() + +# Create an object library that initializes a static qt plugin. +# +# The object library contains a single generated C++ file that calls Q_IMPORT_PLUGIN(plugin_class). +# The object library is exported as part of the Qt build and consumed by user applications +# that link to qt plugins. +# +# The created target name is assigned to 'out_var_plugin_init_target'. +function(__qt_internal_add_static_plugin_init_object_library + plugin_target + out_var_plugin_init_target) + + __qt_internal_get_plugin_import_macro(${plugin_target} import_macro) + __qt_internal_get_plugin_include_prelude(include_prelude) + set(import_content "${include_prelude}${import_macro}") + + string(MAKE_C_IDENTIFIER "${plugin_target}" plugin_target_identifier) + set(generated_qt_plugin_file_name + "${CMAKE_CURRENT_BINARY_DIR}/${plugin_target_identifier}_init.cpp") + + file(GENERATE + OUTPUT "${generated_qt_plugin_file_name}" + CONTENT "${import_content}" + ) + + # CMake versions earlier than 3.18.0 can't find the generated file for some reason, + # failing at generation phase. + # Explicitly marking the file as GENERATED fixes the issue. + set_source_files_properties("${generated_qt_plugin_file_name}" PROPERTIES GENERATED TRUE) + + __qt_internal_get_static_plugin_init_target_name("${plugin_target}" plugin_init_target) + + qt6_add_library("${plugin_init_target}" OBJECT "${generated_qt_plugin_file_name}") + target_link_libraries(${plugin_init_target} + PRIVATE + + # Core provides the symbols needed by Q_IMPORT_PLUGIN. + ${QT_CMAKE_EXPORT_NAMESPACE}::Core + ) + + set_property(TARGET ${plugin_init_target} PROPERTY _is_qt_plugin_init_target TRUE) + set_property(TARGET ${plugin_init_target} APPEND PROPERTY + EXPORT_PROPERTIES _is_qt_plugin_init_target + ) + + set(${out_var_plugin_init_target} "${plugin_init_target}" PARENT_SCOPE) +endfunction() + +# Collect a list of genexes to link plugin libraries. +function(__qt_internal_collect_plugin_libraries plugin_targets out_var) + set(plugins_to_link "") + + foreach(plugin_target ${plugin_targets}) + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + get_target_property(type "${plugin_target_versioned}" TYPE) + if(NOT type STREQUAL STATIC_LIBRARY) + continue() + endif() + + __qt_internal_get_static_plugin_condition_genex( + "${plugin_target}" + plugin_condition) + + list(APPEND plugins_to_link "$<${plugin_condition}:${plugin_target_versioned}>") + endforeach() + + set("${out_var}" "${plugins_to_link}" PARENT_SCOPE) +endfunction() + +# Collect a list of genexes to link plugin initializer object libraries. +# +# The object libraries are only linked if the associated plugins are linked. +function(__qt_internal_collect_plugin_init_libraries plugin_targets out_var) + set(plugin_inits_to_link "") + + foreach(plugin_target ${plugin_targets}) + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + get_target_property(type "${plugin_target_versioned}" TYPE) + if(NOT type STREQUAL STATIC_LIBRARY) + continue() + endif() + + __qt_internal_get_static_plugin_condition_genex( + "${plugin_target}" + plugin_condition) + + __qt_internal_get_static_plugin_init_target_name("${plugin_target}" plugin_init_target) + set(plugin_init_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_init_target}") + + list(APPEND plugin_inits_to_link "$<${plugin_condition}:${plugin_init_target_versioned}>") + endforeach() + + set("${out_var}" "${plugin_inits_to_link}" PARENT_SCOPE) +endfunction() + +# Collect a list of genexes to deploy plugin libraries. +function(__qt_internal_collect_plugin_library_files target plugin_targets out_var) + set(library_files "") + + foreach(plugin_target ${plugin_targets}) + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + __qt_internal_get_static_plugin_condition_genex( + "${plugin_target}" + plugin_condition + TARGET ${target} + ) + + set(target_genex "$<${plugin_condition}:${plugin_target_versioned}>") + list(APPEND library_files "$<$:$>") + endforeach() + + set("${out_var}" "${library_files}" PARENT_SCOPE) +endfunction() + +# Collects all plugin targets discovered by walking the dependencies of ${target}. +# +# Walks immediate dependencies and their transitive dependencies. +# Plugins are collected by inspecting the _qt_plugins property found on any dependency Qt target. +function(__qt_internal_collect_plugin_targets_from_dependencies target out_var) + set(dep_targets "") + + __qt_internal_collect_all_target_dependencies("${target}" dep_targets) + + set(plugin_targets "") + foreach(dep_target ${dep_targets}) + get_target_property(plugins ${dep_target} _qt_plugins) + if(plugins) + list(APPEND plugin_targets ${plugins}) + endif() + endforeach() + + # Plugins that are specified via qt_import_plugin's INCLUDE or INCLUDE_BY_TYPE can have + # dependencies on Qt modules. These modules in turn might bring in more default plugins to link + # So it's recursive. Do only one pass for now. Try to extract the included static plugins, walk + # their public and private dependencies, check if any of them are Qt modules that provide more + # plugins and extract the target names of those plugins. + __qt_internal_collect_plugin_targets_from_dependencies_of_plugins( + "${target}" recursive_plugin_targets) + if(recursive_plugin_targets) + list(APPEND plugin_targets ${recursive_plugin_targets}) + endif() + list(REMOVE_DUPLICATES plugin_targets) + + set("${out_var}" "${plugin_targets}" PARENT_SCOPE) +endfunction() + +# Helper to collect plugin targets from encountered module dependencies as a result of walking +# dependencies. These module dependencies might expose additional plugins. +function(__qt_internal_collect_plugin_targets_from_dependencies_of_plugins target out_var) + set(assigned_plugins_overall "") + + get_target_property(assigned_qt_plugins "${target}" QT_PLUGINS) + + if(assigned_qt_plugins) + foreach(assigned_qt_plugin ${assigned_qt_plugins}) + if(TARGET "${assigned_qt_plugin}") + list(APPEND assigned_plugins_overall "${assigned_qt_plugin}") + endif() + endforeach() + endif() + + get_target_property(assigned_qt_plugins_by_type "${target}" _qt_plugins_by_type) + + if(assigned_qt_plugins_by_type) + foreach(assigned_qt_plugin ${assigned_qt_plugins_by_type}) + if(TARGET "${assigned_qt_plugin}") + list(APPEND assigned_plugins_overall "${assigned_qt_plugin}") + endif() + endforeach() + endif() + + set(plugin_targets "") + foreach(target ${assigned_plugins_overall}) + __qt_internal_walk_libs( + "${target}" + dep_targets + _discarded_out_var + "qt_private_link_library_targets" + "collect_targets") + + foreach(dep_target ${dep_targets}) + get_target_property(plugins ${dep_target} _qt_plugins) + if(plugins) + list(APPEND plugin_targets ${plugins}) + endif() + endforeach() + endforeach() + + list(REMOVE_DUPLICATES plugin_targets) + + set("${out_var}" "${plugin_targets}" PARENT_SCOPE) +endfunction() + +# Generate plugin information files for deployment +# +# Arguments: +# OUT_PLUGIN_TARGETS - Variable name to store the plugin targets that were collected with +# __qt_internal_collect_plugin_targets_from_dependencies. +function(__qt_internal_generate_plugin_deployment_info target) + set(no_value_options "") + set(single_value_options "OUT_PLUGIN_TARGETS") + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + __qt_internal_collect_plugin_targets_from_dependencies("${target}" plugin_targets) + if(NOT "${arg_OUT_PLUGIN_TARGETS}" STREQUAL "") + set("${arg_OUT_PLUGIN_TARGETS}" "${plugin_targets}" PARENT_SCOPE) + endif() + + get_target_property(marked_for_deployment ${target} _qt_marked_for_deployment) + if(NOT marked_for_deployment) + return() + endif() + + __qt_internal_collect_plugin_library_files(${target} "${plugin_targets}" plugins_files) + set(plugins_files "$") + + _qt_internal_get_deploy_impl_dir(deploy_impl_dir) + set(file_path "${deploy_impl_dir}/${target}-plugins") + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + string(APPEND file_path "-$") + endif() + string(APPEND file_path ".cmake") + + file(GENERATE + OUTPUT ${file_path} + CONTENT "set(__QT_DEPLOY_PLUGINS ${plugins_files})" + ) +endfunction() + +# Main logic of finalizer mode. +function(__qt_internal_apply_plugin_imports_finalizer_mode target) + # Process a target only once. + get_target_property(processed ${target} _qt_plugin_finalizer_imports_processed) + if(processed) + return() + endif() + + __qt_internal_generate_plugin_deployment_info(${target} + OUT_PLUGIN_TARGETS plugin_targets) + + # By default if the project hasn't explicitly opted in or out, use finalizer mode. + # The precondition for this is that qt_finalize_target was called (either explicitly by the user + # or auto-deferred by CMake 3.19+). + __qt_internal_check_finalizer_mode("${target}" + use_finalizer_mode + static_plugins + DEFAULT_VALUE "TRUE" + ) + + if(NOT use_finalizer_mode) + return() + endif() + + __qt_internal_collect_plugin_init_libraries("${plugin_targets}" init_libraries) + __qt_internal_collect_plugin_libraries("${plugin_targets}" plugin_libraries) + + target_link_libraries(${target} PRIVATE "${plugin_libraries}" "${init_libraries}") + + set_target_properties(${target} PROPERTIES _qt_plugin_finalizer_imports_processed TRUE) +endfunction() + +# Include CMake plugin packages that belong to the Qt module ${target} and initialize automatic +# linkage of the plugins in static builds. +# The variables inside the macro have to be named unique to the module because an included Plugin +# file might look up another module dependency that calls the same macro before the first one +# has finished processing, which can silently override the values if the variables are not unique. +macro(__qt_internal_include_plugin_packages target) + set(__qt_${target}_plugin_module_target "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + set(__qt_${target}_plugins "") + + # Properties can't be set on aliased targets, so make sure to unalias the target. This is needed + # when Qt examples are built as part of the Qt build itself. + get_target_property(_aliased_target ${__qt_${target}_plugin_module_target} ALIASED_TARGET) + if(_aliased_target) + set(__qt_${target}_plugin_module_target ${_aliased_target}) + endif() + + # Include all PluginConfig.cmake files and update the _qt_plugins and QT_PLUGINS property of + # the module. The underscored version is the one we will use going forward to have compatibility + # with INTERFACE libraries. QT_PLUGINS is now deprecated and only kept so that we don't break + # existing projects using it (like CMake itself). + file(GLOB __qt_${target}_plugin_config_files + "${CMAKE_CURRENT_LIST_DIR}/${QT_CMAKE_EXPORT_NAMESPACE}*PluginConfig.cmake") + foreach(__qt_${target}_plugin_config_file ${__qt_${target}_plugin_config_files}) + string(REGEX REPLACE + "^.*/${QT_CMAKE_EXPORT_NAMESPACE}(.*Plugin)Config.cmake$" + "\\1" + __qt_${target}_qt_plugin "${__qt_${target}_plugin_config_file}") + include("${__qt_${target}_plugin_config_file}") + if(TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::${__qt_${target}_qt_plugin}") + list(APPEND __qt_${target}_plugins ${__qt_${target}_qt_plugin}) + endif() + endforeach() + set_property(TARGET ${__qt_${target}_plugin_module_target} + PROPERTY _qt_plugins ${__qt_${target}_plugins}) + + # TODO: Deprecated. Remove in Qt 7. + set_property(TARGET ${__qt_${target}_plugin_module_target} + PROPERTY QT_PLUGINS ${__qt_${target}_plugins}) + + get_target_property(__qt_${target}_have_added_plugins_already + ${__qt_${target}_plugin_module_target} __qt_internal_plugins_added) + if(__qt_${target}_have_added_plugins_already) + return() + endif() + + foreach(plugin_target ${__qt_${target}_plugins}) + __qt_internal_plugin_get_plugin_type("${plugin_target}" __has_plugin_type __plugin_type) + if(NOT __has_plugin_type) + continue() + endif() + + __qt_internal_plugin_has_class_name("${plugin_target}" __has_class_name) + if(NOT __has_class_name) + continue() + endif() + + list(APPEND "QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${__plugin_type}" "${plugin_target}") + + # Auto-linkage should be set up only for static plugins. + set(plugin_target_versioned "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + get_target_property(type "${plugin_target_versioned}" TYPE) + if(type STREQUAL STATIC_LIBRARY) + __qt_internal_add_static_plugin_linkage( + "${plugin_target}" "${__qt_${target}_plugin_module_target}") + __qt_internal_add_static_plugin_import_macro( + "${plugin_target}" ${__qt_${target}_plugin_module_target} "${target}") + endif() + endforeach() + + set_target_properties( + ${__qt_${target}_plugin_module_target} PROPERTIES __qt_internal_plugins_added TRUE) +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicSbomGenerationHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicSbomGenerationHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..618b82dad05710b21fc5a799327e8df8f23b9d81 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicSbomGenerationHelpers.cmake @@ -0,0 +1,1648 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# Copyright (C) 2023-2024 Jochem Rutgers +# SPDX-License-Identifier: MIT AND BSD-3-Clause + +# Helper to set a single arg option to a default value if not set. +function(qt_internal_sbom_set_default_option_value option_name default) + if(NOT arg_${option_name}) + set(arg_${option_name} "${default}" PARENT_SCOPE) + endif() +endfunction() + +# Helper to set a single arg option to a default value if not set. +# Errors out if the end value is empty. Including if the default value was empty. +function(qt_internal_sbom_set_default_option_value_and_error_if_empty option_name default) + qt_internal_sbom_set_default_option_value("${option_name}" "${default}") + if(NOT arg_${option_name}) + message(FATAL_ERROR "Specifying a non-empty ${option_name} is required") + endif() +endfunction() + +# Helper that returns the directory where the intermediate sbom files will be generated. +function(_qt_internal_get_current_project_sbom_dir out_var) + set(sbom_dir "${PROJECT_BINARY_DIR}/qt_sbom") + set(${out_var} "${sbom_dir}" PARENT_SCOPE) +endfunction() + +# Helper to return the path to staging spdx file, where content will be incrementally appended to. +function(_qt_internal_get_staging_area_spdx_file_path out_var) + _qt_internal_get_current_project_sbom_dir(sbom_dir) + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + set(staging_area_spdx_file "${sbom_dir}/staging-${repo_project_name_lowercase}.spdx.in") + set(${out_var} "${staging_area_spdx_file}" PARENT_SCOPE) +endfunction() + +# Starts recording information for the generation of an sbom for a project. +# The intermediate files that generate the sbom are generated at cmake generation time, but are only +# actually run at build time or install time. +# The files are tracked in cmake global properties. +function(_qt_internal_sbom_begin_project_generate) + set(opt_args "") + set(single_args + OUTPUT + OUTPUT_RELATIVE_PATH + LICENSE + COPYRIGHT + DOWNLOAD_LOCATION + PROJECT + PROJECT_COMMENT + PROJECT_FOR_SPDX_ID + SUPPLIER + SUPPLIER_URL + NAMESPACE + CPE + OUT_VAR_PROJECT_SPDX_ID + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + string(TIMESTAMP current_utc UTC) + string(TIMESTAMP current_year "%Y" UTC) + + qt_internal_sbom_set_default_option_value(PROJECT "${PROJECT_NAME}") + + set(default_sbom_file_name + "${arg_PROJECT}/${arg_PROJECT}-sbom-${QT_SBOM_GIT_VERSION_PATH}.spdx") + set(default_install_sbom_path + "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/${default_sbom_file_name}") + + qt_internal_sbom_set_default_option_value(OUTPUT "${default_install_sbom_path}") + qt_internal_sbom_set_default_option_value(OUTPUT_RELATIVE_PATH + "${default_sbom_file_name}") + + qt_internal_sbom_set_default_option_value(LICENSE "NOASSERTION") + qt_internal_sbom_set_default_option_value(PROJECT_FOR_SPDX "${PROJECT_NAME}") + qt_internal_sbom_set_default_option_value_and_error_if_empty(SUPPLIER "") + qt_internal_sbom_set_default_option_value(COPYRIGHT "${current_year} ${arg_SUPPLIER}") + qt_internal_sbom_set_default_option_value_and_error_if_empty(SUPPLIER_URL + "${PROJECT_HOMEPAGE_URL}") + qt_internal_sbom_set_default_option_value(NAMESPACE + "${arg_SUPPLIER}/spdxdocs/${arg_PROJECT}-${QT_SBOM_GIT_VERSION}") + + if(arg_CPE) + set(QT_SBOM_CPE "${arg_CPE}") + else() + set(QT_SBOM_CPE "") + endif() + + string(REGEX REPLACE "[^A-Za-z0-9.]+" "-" arg_PROJECT_FOR_SPDX_ID "${arg_PROJECT_FOR_SPDX_ID}") + string(REGEX REPLACE "-+$" "" arg_PROJECT_FOR_SPDX_ID "${arg_PROJECT_FOR_SPDX_ID}") + # Prevent collision with other generated SPDXID with -[0-9]+ suffix. + string(REGEX REPLACE "-([0-9]+)$" "\\1" arg_PROJECT_FOR_SPDX_ID "${arg_PROJECT_FOR_SPDX_ID}") + + set(project_spdx_id "SPDXRef-${arg_PROJECT_FOR_SPDX_ID}") + if(arg_OUT_VAR_PROJECT_SPDX_ID) + set(${arg_OUT_VAR_PROJECT_SPDX_ID} "${project_spdx_id}" PARENT_SCOPE) + endif() + + get_filename_component(doc_name "${arg_OUTPUT}" NAME_WLE) + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(cmake_configs "${CMAKE_CONFIGURATION_TYPES}") + else() + set(cmake_configs "${CMAKE_BUILD_TYPE}") + endif() + + qt_internal_sbom_set_default_option_value(DOWNLOAD_LOCATION "NOASSERTION") + + set(cmake_version "Built by CMake ${CMAKE_VERSION}") + set(system_name_and_processor "${CMAKE_SYSTEM_NAME} (${CMAKE_SYSTEM_PROCESSOR})") + set(default_project_comment + "${cmake_version} with ${cmake_configs} configuration for ${system_name_and_processor}") + + set(project_comment "${default_project_comment}") + + if(arg_PROJECT_COMMENT) + string(APPEND project_comment "${arg_PROJECT_COMMENT}") + endif() + + set(project_comment "${project_comment}") + + set(content + "SPDXVersion: SPDX-2.3 +DataLicense: CC0-1.0 +SPDXID: SPDXRef-DOCUMENT +DocumentName: ${doc_name} +DocumentNamespace: ${arg_NAMESPACE} +Creator: Organization: ${arg_SUPPLIER} +Creator: Tool: Qt Build System +CreatorComment: This SPDX document was created from CMake ${CMAKE_VERSION}, using the qt +build system from https://code.qt.io/cgit/qt/qtbase.git/tree/cmake/QtPublicSbomHelpers.cmake +Created: ${current_utc}\${QT_SBOM_EXTERNAL_DOC_REFS} + +PackageName: ${CMAKE_CXX_COMPILER_ID} +SPDXID: SPDXRef-compiler +PackageVersion: ${CMAKE_CXX_COMPILER_VERSION} +PackageDownloadLocation: NOASSERTION +PackageLicenseConcluded: NOASSERTION +PackageLicenseDeclared: NOASSERTION +PackageCopyrightText: NOASSERTION +PackageSupplier: Organization: Anonymous +FilesAnalyzed: false +PackageSummary: The compiler as identified by CMake, running on ${CMAKE_HOST_SYSTEM_NAME} (${CMAKE_HOST_SYSTEM_PROCESSOR}) +PrimaryPackagePurpose: APPLICATION +Relationship: SPDXRef-compiler BUILD_DEPENDENCY_OF ${project_spdx_id} +RelationshipComment: ${project_spdx_id} is built by compiler ${CMAKE_CXX_COMPILER_ID} version ${CMAKE_CXX_COMPILER_VERSION} + +PackageName: ${arg_PROJECT} +SPDXID: ${project_spdx_id} +ExternalRef: SECURITY cpe23Type ${QT_SBOM_CPE} +ExternalRef: PACKAGE-MANAGER purl pkg:generic/${arg_SUPPLIER}/${arg_PROJECT}@${QT_SBOM_GIT_VERSION} +PackageVersion: ${QT_SBOM_GIT_VERSION} +PackageSupplier: Organization: ${arg_SUPPLIER} +PackageDownloadLocation: ${arg_DOWNLOAD_LOCATION} +PackageLicenseConcluded: ${arg_LICENSE} +PackageLicenseDeclared: ${arg_LICENSE} +PackageCopyrightText: ${arg_COPYRIGHT} +PackageHomePage: ${arg_SUPPLIER_URL} +PackageComment: ${project_comment} +PackageVerificationCode: \${QT_SBOM_VERIFICATION_CODE} +BuiltDate: ${current_utc} +Relationship: SPDXRef-DOCUMENT DESCRIBES ${project_spdx_id} +") + + # Create the directory that will contain all sbom related files. + _qt_internal_get_current_project_sbom_dir(sbom_dir) + file(MAKE_DIRECTORY "${sbom_dir}") + + # Generate project document intro spdx file. + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + set(document_intro_file_name + "${sbom_dir}/SPDXRef-DOCUMENT-${repo_project_name_lowercase}.spdx.in") + file(GENERATE OUTPUT "${document_intro_file_name}" CONTENT "${content}") + + # This is the file that will be incrementally assembled by having content appended to it. + _qt_internal_get_staging_area_spdx_file_path(staging_area_spdx_file) + + get_filename_component(output_file_name_without_ext "${arg_OUTPUT}" NAME_WLE) + get_filename_component(output_file_ext "${arg_OUTPUT}" LAST_EXT) + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(multi_config_suffix "-$") + else() + set(multi_config_suffix "") + endif() + + set(computed_sbom_file_name_without_ext "${output_file_name_without_ext}${multi_config_suffix}") + set(computed_sbom_file_name "${output_file_name_without_ext}${output_file_ext}") + + # In a super build, put all the build time sboms into the same dir in qtbase. + if(QT_SUPERBUILD) + set(build_sbom_dir "${QtBase_BINARY_DIR}/qt_sbom") + else() + set(build_sbom_dir "${sbom_dir}") + endif() + + get_filename_component(output_relative_dir "${arg_OUTPUT_RELATIVE_PATH}" DIRECTORY) + + set(build_sbom_path + "${build_sbom_dir}/${output_relative_dir}/${computed_sbom_file_name}") + set(build_sbom_path_without_ext + "${build_sbom_dir}/${output_relative_dir}/${computed_sbom_file_name_without_ext}") + + set(install_sbom_path "${arg_OUTPUT}") + + get_filename_component(install_sbom_dir "${install_sbom_path}" DIRECTORY) + set(install_sbom_path_without_ext "${install_sbom_dir}/${output_file_name_without_ext}") + + # Create cmake file to append the document intro spdx to the staging file. + set(create_staging_file "${sbom_dir}/append_document_to_staging${multi_config_suffix}.cmake") + set(content " + cmake_minimum_required(VERSION 3.16) + message(STATUS \"Starting SBOM generation in build dir: ${staging_area_spdx_file}\") + set(QT_SBOM_EXTERNAL_DOC_REFS \"\") + file(READ \"${document_intro_file_name}\" content) + # Override any previous file because we're starting from scratch. + file(WRITE \"${staging_area_spdx_file}\" \"\${content}\") +") + file(GENERATE OUTPUT "${create_staging_file}" CONTENT "${content}") + + set_property(GLOBAL PROPERTY _qt_sbom_project_name "${arg_PROJECT}") + + set_property(GLOBAL PROPERTY _qt_sbom_build_output_path "${build_sbom_path}") + set_property(GLOBAL PROPERTY _qt_sbom_build_output_path_without_ext + "${build_sbom_path_without_ext}") + + set_property(GLOBAL PROPERTY _qt_sbom_install_output_path "${install_sbom_path}") + set_property(GLOBAL PROPERTY _qt_sbom_install_output_path_without_ext + "${install_sbom_path_without_ext}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_include_files "${create_staging_file}") + + set_property(GLOBAL PROPERTY _qt_sbom_spdx_id_count 0) +endfunction() + +# Signals the end of recording sbom information for a project. +# Creates an 'sbom' custom target to generate an incomplete sbom at build time (no checksums). +# Creates install rules to install a complete (with checksums) sbom. +# Also allows running various post-installation steps like NTIA validation, auditing, json +# generation, etc +function(_qt_internal_sbom_end_project_generate) + set(opt_args + GENERATE_JSON + GENERATE_JSON_REQUIRED + GENERATE_SOURCE_SBOM + VERIFY_SBOM + VERIFY_SBOM_REQUIRED + VERIFY_NTIA_COMPLIANT + LINT_SOURCE_SBOM + LINT_SOURCE_SBOM_NO_ERROR + SHOW_TABLE + AUDIT + AUDIT_NO_ERROR + ) + set(single_args "") + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + get_property(sbom_build_output_path GLOBAL PROPERTY _qt_sbom_build_output_path) + get_property(sbom_build_output_path_without_ext GLOBAL PROPERTY + _qt_sbom_build_output_path_without_ext) + + get_property(sbom_install_output_path GLOBAL PROPERTY _qt_sbom_install_output_path) + get_property(sbom_install_output_path_without_ext GLOBAL PROPERTY + _qt_sbom_install_output_path_without_ext) + + if(NOT sbom_build_output_path) + message(FATAL_ERROR "Call _qt_internal_sbom_begin_project() first") + endif() + + _qt_internal_get_staging_area_spdx_file_path(staging_area_spdx_file) + + if(arg_GENERATE_JSON AND NOT QT_INTERNAL_NO_SBOM_PYTHON_OPS) + set(op_args + OP_KEY "GENERATE_JSON" + OUT_VAR_DEPS_FOUND deps_found + ) + if(arg_GENERATE_JSON_REQUIRED) + list(APPEND op_args REQUIRED) + endif() + + _qt_internal_sbom_find_and_handle_sbom_op_dependencies(${op_args}) + if(deps_found) + _qt_internal_sbom_generate_json() + endif() + endif() + + if(arg_VERIFY_SBOM AND NOT QT_INTERNAL_NO_SBOM_PYTHON_OPS) + set(op_args + OP_KEY "VERIFY_SBOM" + OUT_VAR_DEPS_FOUND deps_found + ) + if(arg_VERIFY_SBOM_REQUIRED) + list(APPEND op_args REQUIRED) + endif() + + _qt_internal_sbom_find_and_handle_sbom_op_dependencies(${op_args}) + if(deps_found) + _qt_internal_sbom_verify_valid() + endif() + endif() + + if(arg_VERIFY_NTIA_COMPLIANT AND NOT QT_INTERNAL_NO_SBOM_PYTHON_OPS) + _qt_internal_sbom_find_and_handle_sbom_op_dependencies(REQUIRED OP_KEY "RUN_NTIA") + _qt_internal_sbom_verify_ntia_compliant() + endif() + + if(arg_SHOW_TABLE AND NOT QT_INTERNAL_NO_SBOM_PYTHON_OPS) + _qt_internal_sbom_find_python_dependency_program(NAME sbom2doc REQUIRED) + _qt_internal_sbom_show_table() + endif() + + if(arg_AUDIT AND NOT QT_INTERNAL_NO_SBOM_PYTHON_OPS) + set(audit_no_error_option "") + if(arg_AUDIT_NO_ERROR) + set(audit_no_error_option NO_ERROR) + endif() + _qt_internal_sbom_find_python_dependency_program(NAME sbomaudit REQUIRED) + _qt_internal_sbom_audit(${audit_no_error_option}) + endif() + + if(arg_GENERATE_SOURCE_SBOM AND NOT QT_INTERNAL_NO_SBOM_PYTHON_OPS) + _qt_internal_sbom_find_python_dependency_program(NAME reuse REQUIRED) + _qt_internal_sbom_generate_reuse_source_sbom() + endif() + + if(arg_LINT_SOURCE_SBOM AND NOT QT_INTERNAL_NO_SBOM_PYTHON_OPS) + set(lint_no_error_option "") + if(arg_LINT_SOURCE_SBOM_NO_ERROR) + set(lint_no_error_option NO_ERROR) + endif() + _qt_internal_sbom_find_python_dependency_program(NAME reuse REQUIRED) + _qt_internal_sbom_run_reuse_lint( + ${lint_no_error_option} + BUILD_TIME_SCRIPT_PATH_OUT_VAR reuse_lint_script + ) + endif() + + get_cmake_property(cmake_include_files _qt_sbom_cmake_include_files) + get_cmake_property(cmake_end_include_files _qt_sbom_cmake_end_include_files) + get_cmake_property(cmake_post_generation_include_files + _qt_sbom_cmake_post_generation_include_files) + get_cmake_property(cmake_verify_include_files _qt_sbom_cmake_verify_include_files) + + set(includes "") + if(cmake_include_files) + foreach(cmake_include_file IN LISTS cmake_include_files) + list(APPEND includes "include(\"${cmake_include_file}\")") + endforeach() + endif() + + if(cmake_end_include_files) + foreach(cmake_include_file IN LISTS cmake_end_include_files) + list(APPEND includes "include(\"${cmake_include_file}\")") + endforeach() + endif() + + list(JOIN includes "\n" includes) + + # Post generation includes are included for both build and install time sboms, after + # sbom generation has finished. + set(post_generation_includes "") + if(cmake_post_generation_include_files) + foreach(cmake_include_file IN LISTS cmake_post_generation_include_files) + list(APPEND post_generation_includes "include(\"${cmake_include_file}\")") + endforeach() + endif() + + list(JOIN post_generation_includes "\n" post_generation_includes) + + # Verification only makes sense on installation, where the checksums are present. + set(verify_includes "") + if(cmake_verify_include_files) + foreach(cmake_include_file IN LISTS cmake_verify_include_files) + list(APPEND verify_includes "include(\"${cmake_include_file}\")") + endforeach() + endif() + list(JOIN verify_includes "\n" verify_includes) + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(multi_config_suffix "-$") + else() + set(multi_config_suffix "") + endif() + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(content " + # QT_SBOM_BUILD_TIME be set to FALSE at install time, so don't override if it's set. + # This allows reusing the same cmake file for both build and install. + if(NOT DEFINED QT_SBOM_BUILD_TIME) + set(QT_SBOM_BUILD_TIME TRUE) + endif() + if(NOT QT_SBOM_OUTPUT_PATH) + set(QT_SBOM_OUTPUT_PATH \"${sbom_build_output_path}\") + set(QT_SBOM_OUTPUT_PATH_WITHOUT_EXT \"${sbom_build_output_path_without_ext}\") + endif() + set(QT_SBOM_VERIFICATION_CODES \"\") + ${includes} + if(QT_SBOM_BUILD_TIME) + message(STATUS \"Finalizing SBOM generation in build dir: \${QT_SBOM_OUTPUT_PATH}\") + configure_file(\"${staging_area_spdx_file}\" \"\${QT_SBOM_OUTPUT_PATH}\") + ${post_generation_includes} + endif() +") + set(assemble_sbom "${sbom_dir}/assemble_sbom${multi_config_suffix}.cmake") + file(GENERATE OUTPUT "${assemble_sbom}" CONTENT "${content}") + + if(NOT TARGET sbom) + add_custom_target(sbom) + endif() + + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + + # Create a build target to create a build-time sbom (no verification codes or sha1s). + set(repo_sbom_target "sbom_${repo_project_name_lowercase}") + set(comment "") + string(APPEND comment "Assembling build time SPDX document without checksums for " + "${repo_project_name_lowercase}. Just for testing.") + add_custom_target(${repo_sbom_target} + COMMAND "${CMAKE_COMMAND}" -P "${assemble_sbom}" + COMMENT "${comment}" + VERBATIM + USES_TERMINAL # To avoid running two configs of the command in parallel + ) + + get_cmake_property(qt_repo_deps _qt_repo_deps_${repo_project_name_lowercase}) + if(qt_repo_deps) + foreach(repo_dep IN LISTS qt_repo_deps) + set(repo_dep_sbom "sbom_${repo_dep}") + if(TARGET "${repo_dep_sbom}") + add_dependencies(${repo_sbom_target} ${repo_dep_sbom}) + endif() + endforeach() + endif() + + add_dependencies(sbom ${repo_sbom_target}) + + # Add 'reuse lint' per-repo custom targets. + if(arg_LINT_SOURCE_SBOM AND NOT QT_INTERNAL_NO_SBOM_PYTHON_OPS) + if(NOT TARGET reuse_lint) + add_custom_target(reuse_lint) + endif() + + set(comment "Running 'reuse lint' for '${repo_project_name_lowercase}'.") + add_custom_target(${repo_sbom_target}_reuse_lint + COMMAND "${CMAKE_COMMAND}" -P "${reuse_lint_script}" + COMMENT "${comment}" + VERBATIM + USES_TERMINAL # To avoid running multiple lints in parallel + ) + add_dependencies(reuse_lint ${repo_sbom_target}_reuse_lint) + endif() + + set(extra_code_begin "") + set(extra_code_inner_end "") + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + + set(install_markers_dir "${sbom_dir}") + set(install_marker_path "${install_markers_dir}/finished_install-$.cmake") + + set(install_marker_code " + message(STATUS \"Writing install marker for config $: ${install_marker_path} \") + file(WRITE \"${install_marker_path}\" \"\") +") + + install(CODE "${install_marker_code}" COMPONENT sbom) + if(QT_SUPERBUILD) + install(CODE "${install_marker_code}" COMPONENT "sbom_${repo_project_name_lowercase}" + EXCLUDE_FROM_ALL) + endif() + + set(install_markers "") + foreach(config IN LISTS configs) + set(marker_path "${install_markers_dir}/finished_install-${config}.cmake") + list(APPEND install_markers "${marker_path}") + # Remove the markers on reconfiguration, just in case there are stale ones. + if(EXISTS "${marker_path}") + file(REMOVE "${marker_path}") + endif() + endforeach() + + set(extra_code_begin " + set(QT_SBOM_INSTALL_MARKERS \"${install_markers}\") + foreach(QT_SBOM_INSTALL_MARKER IN LISTS QT_SBOM_INSTALL_MARKERS) + if(NOT EXISTS \"\${QT_SBOM_INSTALL_MARKER}\") + set(QT_SBOM_INSTALLED_ALL_CONFIGS FALSE) + endif() + endforeach() +") + set(extra_code_inner_end " + foreach(QT_SBOM_INSTALL_MARKER IN LISTS QT_SBOM_INSTALL_MARKERS) + message(STATUS + \"Removing install marker: \${QT_SBOM_INSTALL_MARKER} \") + file(REMOVE \"\${QT_SBOM_INSTALL_MARKER}\") + endforeach() +") + endif() + + # Allow skipping checksum computation for testing purposes, while installing just the sbom + # documents, without requiring to build and install all the actual files. + if(QT_INTERNAL_SBOM_FAKE_CHECKSUM) + string(APPEND extra_code_begin " + set(QT_SBOM_FAKE_CHECKSUM TRUE)") + endif() + + set(assemble_sbom_install " + set(QT_SBOM_INSTALLED_ALL_CONFIGS TRUE) + ${extra_code_begin} + if(QT_SBOM_INSTALLED_ALL_CONFIGS) + set(QT_SBOM_BUILD_TIME FALSE) + set(QT_SBOM_OUTPUT_PATH \"${sbom_install_output_path}\") + set(QT_SBOM_OUTPUT_PATH_WITHOUT_EXT \"${sbom_install_output_path_without_ext}\") + include(\"${assemble_sbom}\") + list(SORT QT_SBOM_VERIFICATION_CODES) + string(REPLACE \";\" \"\" QT_SBOM_VERIFICATION_CODES \"\${QT_SBOM_VERIFICATION_CODES}\") + file(WRITE \"${sbom_dir}/verification.txt\" \"\${QT_SBOM_VERIFICATION_CODES}\") + file(SHA1 \"${sbom_dir}/verification.txt\" QT_SBOM_VERIFICATION_CODE) + message(STATUS \"Finalizing SBOM generation in install dir: \${QT_SBOM_OUTPUT_PATH}\") + configure_file(\"${staging_area_spdx_file}\" \"\${QT_SBOM_OUTPUT_PATH}\") + ${post_generation_includes} + ${verify_includes} + ${extra_code_inner_end} + else() + message(STATUS \"Skipping SBOM finalization because not all configs were installed.\") + endif() +") + + install(CODE "${assemble_sbom_install}" COMPONENT sbom) + if(QT_SUPERBUILD) + install(CODE "${assemble_sbom_install}" COMPONENT "sbom_${repo_project_name_lowercase}" + EXCLUDE_FROM_ALL) + endif() + + # Clean up properties, so that they are empty for possible next repo in a top-level build. + set_property(GLOBAL PROPERTY _qt_sbom_cmake_include_files "") + set_property(GLOBAL PROPERTY _qt_sbom_cmake_end_include_files "") + set_property(GLOBAL PROPERTY _qt_sbom_cmake_post_generation_include_files "") + set_property(GLOBAL PROPERTY _qt_sbom_cmake_verify_include_files "") +endfunction() + +# Helper to add info about a file to the sbom. +# Targets are backed by multiple files in multi-config builds. To support multi-config, +# we generate a -$ file for each config, but we only include / install the one that is +# specified via the CONFIG option. +# For build time sboms, we skip checking file existence and sha1 computation, because the files +# are not installed yet. +function(_qt_internal_sbom_generate_add_file) + set(opt_args + OPTIONAL + ) + set(single_args + FILENAME + FILETYPE + RELATIONSHIP + SPDXID + CONFIG + LICENSE + COPYRIGHT + INSTALL_PREFIX + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + qt_internal_sbom_set_default_option_value_and_error_if_empty(FILENAME "") + qt_internal_sbom_set_default_option_value_and_error_if_empty(FILETYPE "") + + _qt_internal_sbom_get_and_check_spdx_id( + VARIABLE arg_SPDXID + CHECK "${arg_SPDXID}" + HINTS "SPDXRef-${arg_FILENAME}" + ) + + qt_internal_sbom_set_default_option_value(LICENSE "NOASSERTION") + qt_internal_sbom_set_default_option_value(COPYRIGHT "NOASSERTION") + + get_property(sbom_project_name GLOBAL PROPERTY _qt_sbom_project_name) + if(NOT sbom_project_name) + message(FATAL_ERROR "Call _qt_internal_sbom_begin_project() first") + endif() + if(NOT arg_RELATIONSHIP) + set(arg_RELATIONSHIP "SPDXRef-${sbom_project_name} CONTAINS ${arg_SPDXID}") + else() + string(REPLACE + "@QT_SBOM_LAST_SPDXID@" "${arg_SPDXID}" arg_RELATIONSHIP "${arg_RELATIONSHIP}") + endif() + + set(fields "") + + if(arg_LICENSE) + set(fields "${fields} +LicenseConcluded: ${arg_LICENSE}" + ) + else() + set(fields "${fields} +LicenseConcluded: NOASSERTION" + ) + endif() + + if(arg_COPYRIGHT) + set(fields "${fields} +FileCopyrightText: ${arg_COPYRIGHT}" + ) + else() + set(fields "${fields} +FileCopyrightText: NOASSERTION" + ) + endif() + + set(file_suffix_to_generate "") + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(file_suffix_to_generate "-$") + endif() + + if(arg_CONFIG) + set(file_suffix_to_install "-${arg_CONFIG}") + else() + set(file_suffix_to_install "") + endif() + + _qt_internal_get_staging_area_spdx_file_path(staging_area_spdx_file) + + if(arg_INSTALL_PREFIX) + set(install_prefix "${arg_INSTALL_PREFIX}") + else() + set(install_prefix "${CMAKE_INSTALL_PREFIX}") + endif() + + set(content " + if(NOT EXISTS \$ENV{DESTDIR}${install_prefix}/${arg_FILENAME} + AND NOT QT_SBOM_BUILD_TIME AND NOT QT_SBOM_FAKE_CHECKSUM) + if(NOT ${arg_OPTIONAL}) + message(FATAL_ERROR \"Cannot find '${arg_FILENAME}' to compute its checksum. \" + \"Expected to find it at '\$ENV{DESTDIR}${install_prefix}/${arg_FILENAME}' \") + endif() + else() + if(NOT QT_SBOM_BUILD_TIME) + if(QT_SBOM_FAKE_CHECKSUM) + set(sha1 \"158942a783ee1095eafacaffd93de73edeadbeef\") + else() + file(SHA1 \$ENV{DESTDIR}${install_prefix}/${arg_FILENAME} sha1) + endif() + list(APPEND QT_SBOM_VERIFICATION_CODES \${sha1}) + endif() + file(APPEND \"${staging_area_spdx_file}\" +\" +FileName: ./${arg_FILENAME} +SPDXID: ${arg_SPDXID} +FileType: ${arg_FILETYPE} +FileChecksum: SHA1: \${sha1}${fields} +LicenseInfoInFile: NOASSERTION +Relationship: ${arg_RELATIONSHIP} +\" + ) + endif() +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(file_sbom "${sbom_dir}/${arg_SPDXID}${file_suffix_to_generate}.cmake") + file(GENERATE OUTPUT "${file_sbom}" CONTENT "${content}") + + set(file_sbom_to_install "${sbom_dir}/${arg_SPDXID}${file_suffix_to_install}.cmake") + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_include_files "${file_sbom_to_install}") +endfunction() + +# Helper to add info about an external reference to a different project spdx sbom file. +function(_qt_internal_sbom_generate_add_external_reference) + set(opt_args + NO_AUTO_RELATIONSHIP + ) + set(single_args + EXTERNAL + FILENAME + RENAME + SPDXID + RELATIONSHIP + + ) + set(multi_args + INSTALL_PREFIXES + ) + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + qt_internal_sbom_set_default_option_value_and_error_if_empty(EXTERNAL "") + qt_internal_sbom_set_default_option_value_and_error_if_empty(FILENAME "") + + if(NOT arg_SPDXID) + get_property(spdx_id_count GLOBAL PROPERTY _qt_sbom_spdx_id_count) + set(arg_SPDXID "DocumentRef-${spdx_id_count}") + math(EXPR spdx_id_count "${spdx_id_count} + 1") + set_property(GLOBAL PROPERTY _qt_sbom_spdx_id_count "${spdx_id_count}") + endif() + + if(NOT "${arg_SPDXID}" MATCHES "^DocumentRef-[-a-zA-Z0-9]+$") + message(FATAL_ERROR "Invalid DocumentRef \"${arg_SPDXID}\"") + endif() + + get_property(sbom_project_name GLOBAL PROPERTY _qt_sbom_project_name) + if(NOT sbom_project_name) + message(FATAL_ERROR "Call _qt_internal_sbom_begin_project() first") + endif() + if(NOT arg_RELATIONSHIP) + if(NOT arg_NO_AUTO_RELATIONSHIP) + set(arg_RELATIONSHIP + "SPDXRef-${sbom_project_name} DEPENDS_ON ${arg_SPDXID}:${arg_EXTERNAL}") + else() + set(arg_RELATIONSHIP "") + endif() + else() + string(REPLACE + "@QT_SBOM_LAST_SPDXID@" "${arg_SPDXID}" arg_RELATIONSHIP "${arg_RELATIONSHIP}") + endif() + + _qt_internal_get_staging_area_spdx_file_path(staging_area_spdx_file) + + set(install_prefixes "") + if(arg_INSTALL_PREFIXES) + list(APPEND install_prefixes ${arg_INSTALL_PREFIXES}) + endif() + if(QT6_INSTALL_PREFIX) + list(APPEND install_prefixes ${QT6_INSTALL_PREFIX}) + endif() + if(QT_ADDITIONAL_PACKAGES_PREFIX_PATH) + list(APPEND install_prefixes ${QT_ADDITIONAL_PACKAGES_PREFIX_PATH}) + endif() + if(QT_ADDITIONAL_SBOM_DOCUMENT_PATHS) + list(APPEND install_prefixes ${QT_ADDITIONAL_SBOM_DOCUMENT_PATHS}) + endif() + list(REMOVE_DUPLICATES install_prefixes) + + set(relationship_content "") + if(arg_RELATIONSHIP) + set(relationship_content " + file(APPEND \"${staging_area_spdx_file}\" + \" + Relationship: ${arg_RELATIONSHIP}\") +") + endif() + + # Filename may not exist yet, and it could be a generator expression. + set(content " + set(relative_file_name \"${arg_FILENAME}\") + set(document_dir_paths ${install_prefixes}) + foreach(document_dir_path IN LISTS document_dir_paths) + set(document_file_path \"\${document_dir_path}/\${relative_file_name}\") + if(EXISTS \"\${document_file_path}\") + break() + endif() + endforeach() + if(NOT EXISTS \"\${document_file_path}\") + message(FATAL_ERROR \"Could not find external SBOM document \${relative_file_name}\" + \" in any of the document dir paths: \${document_dir_paths} \" + ) + endif() + file(SHA1 \"\${document_file_path}\" ext_sha1) + file(READ \"\${document_file_path}\" ext_content) + + if(NOT \"\${ext_content}\" MATCHES \"[\\r\\n]DocumentNamespace:\") + message(FATAL_ERROR \"Missing DocumentNamespace in \${document_file_path}\") + endif() + + string(REGEX REPLACE \"^.*[\\r\\n]DocumentNamespace:[ \\t]*([^#\\r\\n]*).*$\" + \"\\\\1\" ext_ns \"\${ext_content}\") + + list(APPEND QT_SBOM_EXTERNAL_DOC_REFS \" +ExternalDocumentRef: ${arg_SPDXID} \${ext_ns} SHA1: \${ext_sha1}\") + + ${relationship_content} +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(ext_ref_sbom "${sbom_dir}/${arg_SPDXID}.cmake") + file(GENERATE OUTPUT "${ext_ref_sbom}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_end_include_files "${ext_ref_sbom}") +endfunction() + +# Helper to add info about a package to the sbom. Usually a package is a mapping to a cmake target. +function(_qt_internal_sbom_generate_add_package) + set(opt_args + CONTAINS_FILES + ) + set(single_args + PACKAGE + VERSION + LICENSE_DECLARED + LICENSE_CONCLUDED + COPYRIGHT + DOWNLOAD_LOCATION + RELATIONSHIP + SPDXID + SUPPLIER + PURPOSE + COMMENT + ) + set(multi_args + EXTREF + CPE + ) + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + qt_internal_sbom_set_default_option_value_and_error_if_empty(PACKAGE "") + + _qt_internal_sbom_get_and_check_spdx_id( + VARIABLE arg_SPDXID + CHECK "${arg_SPDXID}" + HINTS "SPDXRef-${arg_PACKAGE}" + ) + + qt_internal_sbom_set_default_option_value(DOWNLOAD_LOCATION "NOASSERTION") + qt_internal_sbom_set_default_option_value(VERSION "unknown") + qt_internal_sbom_set_default_option_value(SUPPLIER "Person: Anonymous") + qt_internal_sbom_set_default_option_value(LICENSE_DECLARED "NOASSERTION") + qt_internal_sbom_set_default_option_value(LICENSE_CONCLUDED "NOASSERTION") + qt_internal_sbom_set_default_option_value(COPYRIGHT "NOASSERTION") + qt_internal_sbom_set_default_option_value(PURPOSE "OTHER") + + set(fields "") + + if(arg_LICENSE_CONCLUDED) + set(fields "${fields} +PackageLicenseConcluded: ${arg_LICENSE_CONCLUDED}" + ) + else() + set(fields "${fields} +PackageLicenseConcluded: NOASSERTION" + ) + endif() + + if(arg_LICENSE_DECLARED) + set(fields "${fields} +PackageLicenseDeclared: ${arg_LICENSE_DECLARED}" + ) + else() + set(fields "${fields} +PackageLicenseDeclared: NOASSERTION" + ) + endif() + + foreach(ext_ref IN LISTS arg_EXTREF) + set(fields "${fields} +ExternalRef: ${ext_ref}" + ) + endforeach() + + if(arg_CONTAINS_FILES) + set(fields "${fields} +FilesAnalyzed: true" + ) + else() + set(fields "${fields} +FilesAnalyzed: false" + ) + endif() + + if(arg_COPYRIGHT) + set(fields "${fields} +PackageCopyrightText: ${arg_COPYRIGHT}" + ) + else() + set(fields "${fields} +PackageCopyrightText: NOASSERTION" + ) + endif() + + if(arg_PURPOSE) + set(fields "${fields} +PrimaryPackagePurpose: ${arg_PURPOSE}" + ) + else() + set(fields "${fields} +PrimaryPackagePurpose: OTHER" + ) + endif() + + if(arg_COMMENT) + set(fields "${fields} +PackageComment: ${arg_COMMENT}" + ) + endif() + + foreach(cpe IN LISTS arg_CPE) + set(fields "${fields} +ExternalRef: SECURITY cpe23Type ${cpe}" + ) + endforeach() + + get_property(sbom_project_name GLOBAL PROPERTY _qt_sbom_project_name) + if(NOT sbom_project_name) + message(FATAL_ERROR "Call _qt_internal_sbom_begin_project() first") + endif() + if(NOT arg_RELATIONSHIP) + set(arg_RELATIONSHIP "SPDXRef-${sbom_project_name} CONTAINS ${arg_SPDXID}") + else() + string(REPLACE "@QT_SBOM_LAST_SPDXID@" "${arg_SPDXID}" arg_RELATIONSHIP "${arg_RELATIONSHIP}") + endif() + + _qt_internal_get_staging_area_spdx_file_path(staging_area_spdx_file) + + set(content " + file(APPEND \"${staging_area_spdx_file}\" +\" +PackageName: ${arg_PACKAGE} +SPDXID: ${arg_SPDXID} +PackageDownloadLocation: ${arg_DOWNLOAD_LOCATION} +PackageVersion: ${arg_VERSION} +PackageSupplier: ${arg_SUPPLIER}${fields} +Relationship: ${arg_RELATIONSHIP} +\" + ) +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(package_sbom "${sbom_dir}/${arg_SPDXID}.cmake") + file(GENERATE OUTPUT "${package_sbom}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_include_files "${package_sbom}") +endfunction() + +# Helper to add a license text from a file or text into the sbom document. +function(_qt_internal_sbom_generate_add_license) + set(opt_args "") + set(single_args + LICENSE_ID + EXTRACTED_TEXT + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + qt_internal_sbom_set_default_option_value_and_error_if_empty(LICENSE_ID "") + + _qt_internal_sbom_get_and_check_spdx_id( + VARIABLE arg_SPDXID + CHECK "${arg_SPDXID}" + HINTS "SPDXRef-${arg_LICENSE_ID}" + ) + + if(NOT arg_EXTRACTED_TEXT) + set(licenses_dir "${PROJECT_SOURCE_DIR}/LICENSES") + file(READ "${licenses_dir}/${arg_LICENSE_ID}.txt" arg_EXTRACTED_TEXT) + string(PREPEND arg_EXTRACTED_TEXT "") + string(APPEND arg_EXTRACTED_TEXT "") + endif() + + _qt_internal_get_staging_area_spdx_file_path(staging_area_spdx_file) + + set(content " + file(APPEND \"${staging_area_spdx_file}\" +\" +LicenseID: ${arg_LICENSE_ID} +ExtractedText: ${arg_EXTRACTED_TEXT} +\" + ) +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(license_sbom "${sbom_dir}/${arg_SPDXID}.cmake") + file(GENERATE OUTPUT "${license_sbom}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_end_include_files "${license_sbom}") +endfunction() + +# Helper to retrieve a valid spdx id, given some hints. +# HINTS can be a list of values, one of which will be sanitized and used as the spdx id. +# CHECK is expected to be a valid spdx id. +function(_qt_internal_sbom_get_and_check_spdx_id) + set(opt_args "") + set(single_args + VARIABLE + CHECK + ) + set(multi_args + HINTS + ) + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + qt_internal_sbom_set_default_option_value_and_error_if_empty(VARIABLE "") + + if(NOT arg_CHECK) + get_property(spdx_id_count GLOBAL PROPERTY _qt_sbom_spdx_id_count) + set(suffix "-${spdx_id_count}") + math(EXPR spdx_id_count "${spdx_id_count} + 1") + set_property(GLOBAL PROPERTY _qt_sbom_spdx_id_count "${spdx_id_count}") + + foreach(hint IN LISTS arg_HINTS) + _qt_internal_sbom_get_sanitized_spdx_id(id "${hint}") + if(id) + set(id "${id}${suffix}") + break() + endif() + endforeach() + + if(NOT id) + set(id "SPDXRef${suffix}") + endif() + else() + set(id "${arg_CHECK}") + endif() + + if("${id}" MATCHES "^SPDXRef-[-]+$" + OR (NOT "${id}" MATCHES "^SPDXRef-[-a-zA-Z0-9]+$")) + message(FATAL_ERROR "Invalid SPDXID \"${id}\"") + endif() + + set(${arg_VARIABLE} "${id}" PARENT_SCOPE) +endfunction() + +# Helper to find a python interpreter and a specific python dependency, e.g. to be able to generate +# a SPDX JSON SBOM, or run post-installation steps like NTIA verification. +# The exact dependency should be specified as the OP_KEY. +# +# Caches the found python executable in a separate cache var QT_INTERNAL_SBOM_PYTHON_EXECUTABLE, to +# avoid conflicts with any other found python interpreter. +function(_qt_internal_sbom_find_and_handle_sbom_op_dependencies) + set(opt_args + REQUIRED + ) + set(single_args + OP_KEY + OUT_VAR_DEPS_FOUND + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_OP_KEY) + message(FATAL_ERROR "OP_KEY is required") + endif() + + set(supported_ops "GENERATE_JSON" "VERIFY_SBOM" "RUN_NTIA") + + if(arg_OP_KEY STREQUAL "GENERATE_JSON" OR arg_OP_KEY STREQUAL "VERIFY_SBOM") + set(import_statement "import spdx_tools.spdx.clitools.pyspdxtools") + elseif(arg_OP_KEY STREQUAL "RUN_NTIA") + set(import_statement "import ntia_conformance_checker.main") + else() + message(FATAL_ERROR "OP_KEY must be one of ${supported_ops}") + endif() + + # Return early if we found the dependencies. + if(QT_INTERNAL_SBOM_DEPS_FOUND_FOR_${arg_OP_KEY}) + if(arg_OUT_VAR_DEPS_FOUND) + set(${arg_OUT_VAR_DEPS_FOUND} TRUE PARENT_SCOPE) + endif() + return() + endif() + + # NTIA-compliance checker requires Python 3.9 or later, so we use it as the minimum for all + # SBOM OPs. + set(required_version "3.9") + + set(python_common_args + VERSION "${required_version}" + ) + + set(everything_found FALSE) + + # On macOS FindPython prefers looking in the system framework location, but that usually would + # not have the required dependencies. So we first look in it, and then fallback to any other + # non-framework python found. + if(CMAKE_HOST_APPLE) + set(extra_python_args SEARCH_IN_FRAMEWORKS QUIET) + _qt_internal_sbom_find_python_and_dependency_helper_lambda() + endif() + + if(NOT everything_found) + set(extra_python_args QUIET) + _qt_internal_sbom_find_python_and_dependency_helper_lambda() + endif() + + if(NOT everything_found) + if(arg_REQUIRED) + set(message_type "FATAL_ERROR") + else() + set(message_type "DEBUG") + endif() + + if(NOT python_found) + # Look for python one more time, this time without QUIET, to show an error why it + # wasn't found. + if(arg_REQUIRED) + _qt_internal_sbom_find_python_helper(${python_common_args} + OUT_VAR_PYTHON_PATH unused_python + OUT_VAR_PYTHON_FOUND unused_found + ) + endif() + message(${message_type} "Python ${required_version} for running SBOM ops not found.") + elseif(NOT dep_found) + message(${message_type} "Python dependency for running SBOM op ${arg_OP_KEY} " + "not found:\n Python: ${python_path} \n Output: \n${dep_find_output}") + endif() + else() + message(DEBUG "Using Python ${python_path} for running SBOM ops.") + + if(NOT QT_INTERNAL_SBOM_PYTHON_EXECUTABLE) + set(QT_INTERNAL_SBOM_PYTHON_EXECUTABLE "${python_path}" CACHE INTERNAL + "Python interpeter used for SBOM generation.") + endif() + + set(QT_INTERNAL_SBOM_DEPS_FOUND_FOR_${arg_OP_KEY} "TRUE" CACHE INTERNAL + "All dependencies found to run SBOM OP ${arg_OP_KEY}") + endif() + + if(arg_OUT_VAR_DEPS_FOUND) + set(${arg_OUT_VAR_DEPS_FOUND} "${QT_INTERNAL_SBOM_DEPS_FOUND_FOR_${arg_OP_KEY}}" + PARENT_SCOPE) + endif() +endfunction() + +# Helper macro to find python and a given dependency. Expects the caller to set all of the vars. +# Meant to reduce the line noise due to the repeated calls. +macro(_qt_internal_sbom_find_python_and_dependency_helper_lambda) + _qt_internal_sbom_find_python_and_dependency_helper( + PYTHON_ARGS + ${extra_python_args} + ${python_common_args} + DEPENDENCY_ARGS + DEPENDENCY_IMPORT_STATEMENT "${import_statement}" + OUT_VAR_PYTHON_PATH python_path + OUT_VAR_PYTHON_FOUND python_found + OUT_VAR_DEP_FOUND dep_found + OUT_VAR_PYTHON_AND_DEP_FOUND everything_found + OUT_VAR_DEP_FIND_OUTPUT dep_find_output + ) +endmacro() + +# Tries to find python and a given dependency based on the args passed to PYTHON_ARGS and +# DEPENDENCY_ARGS which are forwarded to the respective finding functions. +# Returns the path to the python interpreter, whether it was found, whether the dependency was +# found, whether both were found, and the reason why the dependency might not be found. +function(_qt_internal_sbom_find_python_and_dependency_helper) + set(opt_args) + set(single_args + OUT_VAR_PYTHON_PATH + OUT_VAR_PYTHON_FOUND + OUT_VAR_DEP_FOUND + OUT_VAR_PYTHON_AND_DEP_FOUND + OUT_VAR_DEP_FIND_OUTPUT + ) + set(multi_args + PYTHON_ARGS + DEPENDENCY_ARGS + ) + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(everything_found_inner FALSE) + set(deps_find_output_inner "") + + if(NOT arg_OUT_VAR_PYTHON_PATH) + message(FATAL_ERROR "OUT_VAR_PYTHON_PATH var is required") + endif() + + if(NOT arg_OUT_VAR_PYTHON_FOUND) + message(FATAL_ERROR "OUT_VAR_PYTHON_FOUND var is required") + endif() + + if(NOT arg_OUT_VAR_DEP_FOUND) + message(FATAL_ERROR "OUT_VAR_DEP_FOUND var is required") + endif() + + if(NOT arg_OUT_VAR_PYTHON_AND_DEP_FOUND) + message(FATAL_ERROR "OUT_VAR_PYTHON_AND_DEP_FOUND var is required") + endif() + + if(NOT arg_OUT_VAR_DEP_FIND_OUTPUT) + message(FATAL_ERROR "OUT_VAR_DEP_FIND_OUTPUT var is required") + endif() + + _qt_internal_sbom_find_python_helper( + ${arg_PYTHON_ARGS} + OUT_VAR_PYTHON_PATH python_path_inner + OUT_VAR_PYTHON_FOUND python_found_inner + ) + + if(python_found_inner AND python_path_inner) + _qt_internal_sbom_find_python_dependency_helper( + ${arg_DEPENDENCY_ARGS} + PYTHON_PATH "${python_path_inner}" + OUT_VAR_FOUND dep_found_inner + OUT_VAR_OUTPUT dep_find_output_inner + ) + + if(dep_found_inner) + set(everything_found_inner TRUE) + endif() + endif() + + set(${arg_OUT_VAR_PYTHON_PATH} "${python_path_inner}" PARENT_SCOPE) + set(${arg_OUT_VAR_PYTHON_FOUND} "${python_found_inner}" PARENT_SCOPE) + set(${arg_OUT_VAR_DEP_FOUND} "${dep_found_inner}" PARENT_SCOPE) + set(${arg_OUT_VAR_PYTHON_AND_DEP_FOUND} "${everything_found_inner}" PARENT_SCOPE) + set(${arg_OUT_VAR_DEP_FIND_OUTPUT} "${dep_find_output_inner}" PARENT_SCOPE) +endfunction() + +# Tries to find the python intrepreter, given the QT_SBOM_PYTHON_INTERP path hint, as well as +# other options. +# Ignores any previously found python. +# Returns the python interpreter path and whether it was successfully found. +# +# This is intentionally a function, and not a macro, to prevent overriding the Python3_EXECUTABLE +# non-cache variable in a global scope in case if a different python is found and used for a +# different purpose (e.g. qtwebengine or qtinterfaceframework). +# The reason to use a different python is that an already found python might not be the version we +# need, or might lack the dependencies we need. +# https://gitlab.kitware.com/cmake/cmake/-/issues/21797#note_901621 claims that finding multiple +# python versions in separate directory scopes is possible, and I claim a function scope is as +# good as a directory scope. +function(_qt_internal_sbom_find_python_helper) + set(opt_args + SEARCH_IN_FRAMEWORKS + QUIET + ) + set(single_args + VERSION + OUT_VAR_PYTHON_PATH + OUT_VAR_PYTHON_FOUND + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_OUT_VAR_PYTHON_PATH) + message(FATAL_ERROR "OUT_VAR_PYTHON_PATH var is required") + endif() + + if(NOT arg_OUT_VAR_PYTHON_FOUND) + message(FATAL_ERROR "OUT_VAR_PYTHON_FOUND var is required") + endif() + + # Allow disabling looking for a python interpreter shipped as part of a macOS system framework. + if(NOT arg_SEARCH_IN_FRAMEWORKS) + set(Python3_FIND_FRAMEWORK NEVER) + endif() + + set(required_version "") + if(arg_VERSION) + set(required_version "${arg_VERSION}") + endif() + + set(find_quiet "") + if(arg_QUIET) + set(find_quiet "QUIET") + endif() + + # Locally reset any executable that was possibly already found. + # We do this to ensure we always re-do the lookup/ + # This needs to be set to an empty string, to override any cache variable + set(Python3_EXECUTABLE "") + + # This needs to be unset, because the Python module checks whether the variable is defined, not + # whether it is empty. + unset(_Python3_EXECUTABLE) + + if(QT_SBOM_PYTHON_INTERP) + set(Python3_ROOT_DIR ${QT_SBOM_PYTHON_INTERP}) + endif() + + find_package(Python3 ${required_version} ${find_quiet} COMPONENTS Interpreter) + + set(${arg_OUT_VAR_PYTHON_PATH} "${Python3_EXECUTABLE}" PARENT_SCOPE) + set(${arg_OUT_VAR_PYTHON_FOUND} "${Python3_Interpreter_FOUND}" PARENT_SCOPE) +endfunction() + +# Helper that takes an python import statement to run using the given python interpreter path, +# to confirm that the given python dependency can be found. +# Returns whether the dependency was found and the output of running the import, for error handling. +function(_qt_internal_sbom_find_python_dependency_helper) + set(opt_args "") + set(single_args + DEPENDENCY_IMPORT_STATEMENT + PYTHON_PATH + OUT_VAR_FOUND + OUT_VAR_OUTPUT + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_PYTHON_PATH) + message(FATAL_ERROR "Python interpreter path not given.") + endif() + + if(NOT arg_DEPENDENCY_IMPORT_STATEMENT) + message(FATAL_ERROR "Python depdendency import statement not given.") + endif() + + if(NOT arg_OUT_VAR_FOUND) + message(FATAL_ERROR "Out var found variable not given.") + endif() + + set(python_path "${arg_PYTHON_PATH}") + execute_process( + COMMAND + ${python_path} -c "${arg_DEPENDENCY_IMPORT_STATEMENT}" + RESULT_VARIABLE res + OUTPUT_VARIABLE output + ERROR_VARIABLE output + ) + + if("${res}" STREQUAL "0") + set(found TRUE) + set(output "${output}") + else() + set(found FALSE) + string(CONCAT output "SBOM Python dependency ${arg_DEPENDENCY_IMPORT_STATEMENT} not found. " + "Error:\n${output}") + endif() + + set(${arg_OUT_VAR_FOUND} "${found}" PARENT_SCOPE) + if(arg_OUT_VAR_OUTPUT) + set(${arg_OUT_VAR_OUTPUT} "${output}" PARENT_SCOPE) + endif() +endfunction() + +# Helper to find a python installed CLI utility. +# Expected to be in PATH. +function(_qt_internal_sbom_find_python_dependency_program) + set(opt_args + REQUIRED + ) + set(single_args + NAME + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(program_name "${arg_NAME}") + string(TOUPPER "${program_name}" upper_name) + set(cache_var "QT_SBOM_PROGRAM_${upper_name}") + + set(hints "") + + # The path to python installed apps is different on Windows compared to UNIX, so we use + # a different path than where the python interpreter might be located. + if(QT_SBOM_PYTHON_APPS_PATH) + list(APPEND hints ${QT_SBOM_PYTHON_APPS_PATH}) + endif() + + find_program(${cache_var} + NAMES ${program_name} + HINTS ${hints} + ) + + if(NOT ${cache_var}) + if(arg_REQUIRED) + set(message_type "FATAL_ERROR") + set(prefix "Required ") + else() + set(message_type "STATUS") + set(prefix "Optional ") + endif() + message(${message_type} "${prefix}SBOM python program '${program_name}' not found.") + endif() +endfunction() + +# Helper to generate a json file. This also implies some additional validity checks, useful +# to ensure a proper sbom file. +function(_qt_internal_sbom_generate_json) + if(NOT QT_INTERNAL_SBOM_PYTHON_EXECUTABLE) + message(FATAL_ERROR "Python interpreter not found for generating SBOM json file.") + endif() + if(NOT QT_INTERNAL_SBOM_DEPS_FOUND_FOR_GENERATE_JSON) + message(FATAL_ERROR "Python dependencies not found for generating SBOM json file.") + endif() + + set(content " + message(STATUS \"Generating JSON: \${QT_SBOM_OUTPUT_PATH}.json\") + execute_process( + COMMAND ${QT_INTERNAL_SBOM_PYTHON_EXECUTABLE} -m spdx_tools.spdx.clitools.pyspdxtools + -i \"\${QT_SBOM_OUTPUT_PATH}\" -o \"\${QT_SBOM_OUTPUT_PATH}.json\" + RESULT_VARIABLE res + ) + if(NOT res EQUAL 0) + message(FATAL_ERROR \"SBOM conversion to JSON failed: \${res}\") + endif() +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(verify_sbom "${sbom_dir}/convert_to_json.cmake") + file(GENERATE OUTPUT "${verify_sbom}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_verify_include_files "${verify_sbom}") +endfunction() + +# Helper to verify the generated sbom is valid. +function(_qt_internal_sbom_verify_valid) + if(NOT QT_INTERNAL_SBOM_PYTHON_EXECUTABLE) + message(FATAL_ERROR "Python interpreter not found for verifying SBOM file.") + endif() + + if(NOT QT_INTERNAL_SBOM_DEPS_FOUND_FOR_VERIFY_SBOM) + message(FATAL_ERROR "Python dependencies not found for verifying SBOM file") + endif() + + set(content " + message(STATUS \"Verifying: \${QT_SBOM_OUTPUT_PATH}\") + execute_process( + COMMAND ${QT_INTERNAL_SBOM_PYTHON_EXECUTABLE} -m spdx_tools.spdx.clitools.pyspdxtools + -i \"\${QT_SBOM_OUTPUT_PATH}\" + RESULT_VARIABLE res + ) + if(NOT res EQUAL 0) + message(FATAL_ERROR \"SBOM verification failed: \${res}\") + endif() +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(verify_sbom "${sbom_dir}/verify_valid.cmake") + file(GENERATE OUTPUT "${verify_sbom}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_verify_include_files "${verify_sbom}") +endfunction() + +# Helper to verify the generated sbom is NTIA compliant. +function(_qt_internal_sbom_verify_ntia_compliant) + if(NOT QT_INTERNAL_SBOM_PYTHON_EXECUTABLE) + message(FATAL_ERROR "Python interpreter not found for verifying SBOM file.") + endif() + + if(NOT QT_INTERNAL_SBOM_DEPS_FOUND_FOR_RUN_NTIA) + message(FATAL_ERROR "Python dependencies not found for running the SBOM NTIA checker.") + endif() + + set(content " + message(STATUS \"Checking for NTIA compliance: \${QT_SBOM_OUTPUT_PATH}\") + execute_process( + COMMAND ${QT_INTERNAL_SBOM_PYTHON_EXECUTABLE} -m ntia_conformance_checker.main + --file \"\${QT_SBOM_OUTPUT_PATH}\" + RESULT_VARIABLE res + ) + if(NOT res EQUAL 0) + message(FATAL_ERROR \"SBOM NTIA verification failed: \{res}\") + endif() +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(verify_sbom "${sbom_dir}/verify_ntia.cmake") + file(GENERATE OUTPUT "${verify_sbom}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_verify_include_files "${verify_sbom}") +endfunction() + +# Helper to show the main sbom document info in the form of a CLI table. +function(_qt_internal_sbom_show_table) + set(extra_code_begin "") + if(DEFINED ENV{COIN_UNIQUE_JOB_ID}) + # The output of the process dynamically adjusts the width of the shown table based on the + # console width. In the CI, the width is very short for some reason, and thus the output + # is truncated in the CI log. Explicitly set a bigger width to avoid this. + set(extra_code_begin " +set(backup_env_columns \$ENV{COLUMNS}) +set(ENV{COLUMNS} 150) +") +set(extra_code_end " +set(ENV{COLUMNS} \${backup_env_columns}) +") + endif() + + set(content " + message(STATUS \"Showing main SBOM document info: \${QT_SBOM_OUTPUT_PATH}\") + + ${extra_code_begin} + execute_process( + COMMAND ${QT_SBOM_PROGRAM_SBOM2DOC} -i \"\${QT_SBOM_OUTPUT_PATH}\" + RESULT_VARIABLE res + ) + ${extra_code_end} + if(NOT res EQUAL 0) + message(FATAL_ERROR \"Showing SBOM document failed: \${res}\") + endif() +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(verify_sbom "${sbom_dir}/show_table.cmake") + file(GENERATE OUTPUT "${verify_sbom}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_verify_include_files "${verify_sbom}") +endfunction() + +# Helper to audit the generated sbom. +function(_qt_internal_sbom_audit) + set(opt_args NO_ERROR) + set(single_args "") + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(handle_error "") + if(NOT arg_NO_ERROR) + set(handle_error " + if(NOT res EQUAL 0) + message(FATAL_ERROR \"SBOM Audit failed: \${res}\") + endif() +") + endif() + + set(content " + message(STATUS \"Auditing SBOM: \${QT_SBOM_OUTPUT_PATH}\") + execute_process( + COMMAND ${QT_SBOM_PROGRAM_SBOMAUDIT} -i \"\${QT_SBOM_OUTPUT_PATH}\" + --disable-license-check --cpecheck --offline + RESULT_VARIABLE res + ) + ${handle_error} +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(verify_sbom "${sbom_dir}/audit.cmake") + file(GENERATE OUTPUT "${verify_sbom}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_verify_include_files "${verify_sbom}") +endfunction() + +# Returns path to project's potential root source reuse.toml file. +function(_qt_internal_sbom_get_project_reuse_toml_path out_var) + set(reuse_toml_path "${PROJECT_SOURCE_DIR}/REUSE.toml") + set(${out_var} "${reuse_toml_path}" PARENT_SCOPE) +endfunction() + +# Helper to generate and install a source SBOM using reuse. +function(_qt_internal_sbom_generate_reuse_source_sbom) + set(opt_args NO_ERROR) + set(single_args "") + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(file_op "${sbom_dir}/generate_reuse_source_sbom.cmake") + + _qt_internal_sbom_get_project_reuse_toml_path(reuse_toml_path) + if(NOT EXISTS "${reuse_toml_path}" AND NOT QT_FORCE_SOURCE_SBOM_GENERATION) + set(skip_message + "Skipping source SBOM generation: No reuse.toml file found at '${reuse_toml_path}'.") + message(STATUS "${skip_message}") + + set(content " + message(STATUS \"${skip_message}\") +") + + file(GENERATE OUTPUT "${file_op}" CONTENT "${content}") + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_post_generation_include_files + "${file_op}") + return() + endif() + + set(handle_error "") + if(NOT arg_NO_ERROR) + set(handle_error " + if(NOT res EQUAL 0) + message(FATAL_ERROR \"Source SBOM generation using reuse tool failed: \${res}\") + endif() +") + endif() + + set(source_sbom_path "\${QT_SBOM_OUTPUT_PATH_WITHOUT_EXT}.source.spdx") + + set(content " + message(STATUS \"Generating source SBOM using reuse tool: ${source_sbom_path}\") + execute_process( + COMMAND ${QT_SBOM_PROGRAM_REUSE} --root \"${PROJECT_SOURCE_DIR}\" spdx + -o ${source_sbom_path} + RESULT_VARIABLE res + ) + ${handle_error} +") + + file(GENERATE OUTPUT "${file_op}" CONTENT "${content}") + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_post_generation_include_files "${file_op}") +endfunction() + +# Helper to run 'reuse lint' on the project source dir. +function(_qt_internal_sbom_run_reuse_lint) + set(opt_args + NO_ERROR + ) + set(single_args + BUILD_TIME_SCRIPT_PATH_OUT_VAR + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + # If no reuse.toml file exists, it means the repo is likely not reuse compliant yet, + # so we shouldn't error out during installation when running the lint. + _qt_internal_sbom_get_project_reuse_toml_path(reuse_toml_path) + if(NOT EXISTS "${reuse_toml_path}" AND NOT QT_FORCE_REUSE_LINT_ERROR) + set(arg_NO_ERROR TRUE) + endif() + + set(handle_error "") + if(NOT arg_NO_ERROR) + set(handle_error " + if(NOT res EQUAL 0) + message(FATAL_ERROR \"Running 'reuse lint' failed: \${res}\") + endif() +") + endif() + + set(content " + message(STATUS \"Running 'reuse lint' in '${PROJECT_SOURCE_DIR}'.\") + execute_process( + COMMAND ${QT_SBOM_PROGRAM_REUSE} --root \"${PROJECT_SOURCE_DIR}\" lint + RESULT_VARIABLE res + ) + ${handle_error} +") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set(file_op_build "${sbom_dir}/run_reuse_lint_build.cmake") + file(GENERATE OUTPUT "${file_op_build}" CONTENT "${content}") + + # Allow skipping running 'reuse lint' during installation. But still allow running it during + # build time. This is a fail safe opt-out in case some repo needs it. + if(QT_FORCE_SKIP_REUSE_LINT_ON_INSTALL) + set(skip_message "Skipping running 'reuse lint' in '${PROJECT_SOURCE_DIR}'.") + + set(content " + message(STATUS \"${skip_message}\") +") + set(file_op_install "${sbom_dir}/run_reuse_lint_install.cmake") + file(GENERATE OUTPUT "${file_op_install}" CONTENT "${content}") + else() + # Just reuse the already generated script for installation as well. + set(file_op_install "${file_op_build}") + endif() + + set_property(GLOBAL APPEND PROPERTY _qt_sbom_cmake_verify_include_files "${file_op_install}") + + if(arg_BUILD_TIME_SCRIPT_PATH_OUT_VAR) + set(${arg_BUILD_TIME_SCRIPT_PATH_OUT_VAR} "${file_op_build}" PARENT_SCOPE) + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicSbomHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicSbomHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4b35d6ea62b58af62c57a6ca6a4faf48a599c5ce --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicSbomHelpers.cmake @@ -0,0 +1,3659 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Starts repo sbom generation. +# Should be called before any targets are added to the sbom. +# +# INSTALL_PREFIX should be passed a value like CMAKE_INSTALL_PREFIX or QT_STAGING_PREFIX +# INSTALL_SBOM_DIR should be passed a value like CMAKE_INSTALL_DATAROOTDIR or +# Qt's INSTALL_SBOMDIR +# SUPPLIER, SUPPLIER_URL, DOCUMENT_NAMESPACE, COPYRIGHTS are self-explanatory. +function(_qt_internal_sbom_begin_project) + # Allow opt out via an internal variable. Will be used in CI for repos like qtqa. + if(QT_INTERNAL_FORCE_NO_GENERATE_SBOM) + set(QT_GENERATE_SBOM OFF CACHE BOOL "Generate SBOM" FORCE) + endif() + + if(NOT QT_GENERATE_SBOM) + return() + endif() + + set(opt_args + QT_CPE + ) + set(single_args + INSTALL_PREFIX + INSTALL_SBOM_DIR + LICENSE_EXPRESSION + SUPPLIER + SUPPLIER_URL + DOWNLOAD_LOCATION + DOCUMENT_NAMESPACE + VERSION + SBOM_PROJECT_NAME + CPE + ) + set(multi_args + COPYRIGHTS + ) + + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(CMAKE_VERSION LESS_EQUAL "3.19") + if(QT_IGNORE_MIN_CMAKE_VERSION_FOR_SBOM) + message(STATUS + "Using CMake version older than 3.19, and QT_IGNORE_MIN_CMAKE_VERSION_FOR_SBOM was " + "set to ON. qt_attribution.json files will not be processed.") + else() + message(FATAL_ERROR + "Generating an SBOM requires CMake version 3.19 or newer. You can pass " + "-DQT_IGNORE_MIN_CMAKE_VERSION_FOR_SBOM=ON to try to generate the SBOM anyway, " + "but it is not officially supported, and the SBOM might be incomplete.") + endif() + endif() + + # The ntia-conformance-checker insists that a SPDX document contain at least one + # relationship that DESCRIBES a package, and that the package contains the string + # "Package-" in the spdx id. boot2qt spdx seems to contain the same. + + if(arg_SBOM_PROJECT_NAME) + _qt_internal_sbom_set_root_project_name("${arg_SBOM_PROJECT_NAME}") + else() + _qt_internal_sbom_set_root_project_name("${PROJECT_NAME}") + endif() + _qt_internal_sbom_get_root_project_name_for_spdx_id(repo_project_name_for_spdx_id) + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + + if(arg_SUPPLIER_URL) + set(repo_supplier_url "${arg_SUPPLIER_URL}") + else() + _qt_internal_sbom_get_default_supplier_url(repo_supplier_url) + endif() + + # Manual override. + if(arg_VERSION) + set(QT_SBOM_GIT_VERSION "${arg_VERSION}") + set(QT_SBOM_GIT_VERSION_PATH "${arg_VERSION}") + set(QT_SBOM_GIT_HASH "") # empty on purpose, no source of info + set(QT_SBOM_GIT_HASH_SHORT "") # empty on purpose, no source of info + set(non_git_version "${arg_VERSION}") + else() + # Query git version info. + _qt_internal_find_git_package() + _qt_internal_query_git_version( + EMPTY_VALUE_WHEN_NOT_GIT_REPO + OUT_VAR_PREFIX __sbom_ + ) + set(QT_SBOM_GIT_VERSION "${__sbom_git_version}") + set(QT_SBOM_GIT_VERSION_PATH "${__sbom_git_version_path}") + set(QT_SBOM_GIT_HASH "${__sbom_git_hash}") + set(QT_SBOM_GIT_HASH_SHORT "${__sbom_git_hash_short}") + + # Git version might not be available. + set(non_git_version "${QT_REPO_MODULE_VERSION}") + if(NOT QT_SBOM_GIT_VERSION) + set(QT_SBOM_GIT_VERSION "${non_git_version}") + endif() + if(NOT QT_SBOM_GIT_VERSION_PATH) + set(QT_SBOM_GIT_VERSION_PATH "${non_git_version}") + endif() + endif() + + # Set the variables in the outer scope, so they can be accessed by the generation functions + # in QtPublicSbomGenerationHelpers.cmake + set(QT_SBOM_GIT_VERSION "${QT_SBOM_GIT_VERSION}" PARENT_SCOPE) + set(QT_SBOM_GIT_VERSION_PATH "${QT_SBOM_GIT_VERSION_PATH}" PARENT_SCOPE) + set(QT_SBOM_GIT_HASH "${QT_SBOM_GIT_HASH}" PARENT_SCOPE) + set(QT_SBOM_GIT_HASH_SHORT "${QT_SBOM_GIT_HASH_SHORT}" PARENT_SCOPE) + + if(arg_DOCUMENT_NAMESPACE) + set(repo_spdx_namespace "${arg_DOCUMENT_NAMESPACE}") + else() + # Used in external refs, either URI + UUID or URI + checksum. We use git version for now + # which is probably not conformat to spec. + set(repo_name_and_version "${repo_project_name_lowercase}-${QT_SBOM_GIT_VERSION}") + set(repo_spdx_namespace + "${repo_supplier_url}/spdxdocs/${repo_name_and_version}") + endif() + + if(non_git_version) + set(version_suffix "-${non_git_version}") + else() + set(version_suffix "") + endif() + + set(repo_spdx_relative_install_path + "${arg_INSTALL_SBOM_DIR}/${repo_project_name_lowercase}${version_suffix}.spdx") + + # Prepend DESTDIR, to allow relocating installed sbom. Needed for CI. + set(repo_spdx_install_path + "\$ENV{DESTDIR}${arg_INSTALL_PREFIX}/${repo_spdx_relative_install_path}") + + if(arg_LICENSE_EXPRESSION) + set(repo_license "${arg_LICENSE_EXPRESSION}") + else() + # Default to NOASSERTION for root repo SPDX packages, because we have some repos + # with multiple licenses and AND-ing them together will create a giant unreadable list. + # It's better to rely on the more granular package licenses. + set(repo_license "") + endif() + + if(arg_COPYRIGHTS) + list(JOIN arg_COPYRIGHTS "\n" arg_COPYRIGHTS) + set(repo_copyright "${arg_COPYRIGHTS}") + else() + _qt_internal_sbom_get_default_qt_copyright_header(repo_copyright) + endif() + + if(arg_SUPPLIER) + set(repo_supplier "${arg_SUPPLIER}") + else() + _qt_internal_sbom_get_default_supplier(repo_supplier) + endif() + + if(arg_CPE) + set(qt_cpe "${arg_CPE}") + elseif(arg_QT_CPE) + _qt_internal_sbom_get_cpe_qt_repo(qt_cpe) + else() + set(qt_cpe "") + endif() + + if(arg_DOWNLOAD_LOCATION) + set(download_location "${arg_DOWNLOAD_LOCATION}") + else() + _qt_internal_sbom_get_qt_repo_source_download_location(download_location) + endif() + + set(project_comment "") + + _qt_internal_get_configure_line(configure_line) + if(configure_line) + set(configure_line_comment + "\n${repo_project_name_lowercase} was configured with:\n ${configure_line}\n") + string(APPEND project_comment "${configure_line_comment}") + endif() + + _qt_internal_sbom_begin_project_generate( + OUTPUT "${repo_spdx_install_path}" + OUTPUT_RELATIVE_PATH "${repo_spdx_relative_install_path}" + LICENSE "${repo_license}" + COPYRIGHT "${repo_copyright}" + SUPPLIER "${repo_supplier}" # This must not contain spaces! + SUPPLIER_URL "${repo_supplier_url}" + DOWNLOAD_LOCATION "${download_location}" + PROJECT "${repo_project_name_lowercase}" + PROJECT_COMMENT "${project_comment}" + PROJECT_FOR_SPDX_ID "${repo_project_name_for_spdx_id}" + NAMESPACE "${repo_spdx_namespace}" + CPE "${qt_cpe}" + OUT_VAR_PROJECT_SPDX_ID repo_project_spdx_id + ) + + set_property(GLOBAL PROPERTY _qt_internal_project_attribution_files "") + + set_property(GLOBAL PROPERTY _qt_internal_sbom_repo_document_namespace + "${repo_spdx_namespace}") + + set_property(GLOBAL PROPERTY _qt_internal_sbom_relative_installed_repo_document_path + "${repo_spdx_relative_install_path}") + + set_property(GLOBAL PROPERTY _qt_internal_sbom_repo_project_name_lowercase + "${repo_project_name_lowercase}") + + set_property(GLOBAL PROPERTY _qt_internal_sbom_install_prefix + "${arg_INSTALL_PREFIX}") + + set_property(GLOBAL PROPERTY _qt_internal_sbom_project_spdx_id + "${repo_project_spdx_id}") + + _qt_internal_get_current_project_sbom_dir(sbom_dir) + set_property(GLOBAL APPEND PROPERTY _qt_internal_sbom_dirs "${sbom_dir}") + + file(GLOB license_files "${PROJECT_SOURCE_DIR}/LICENSES/LicenseRef-*.txt") + foreach(license_file IN LISTS license_files) + get_filename_component(license_id "${license_file}" NAME_WLE) + _qt_internal_sbom_add_license( + LICENSE_ID "${license_id}" + LICENSE_PATH "${license_file}" + NO_LICENSE_REF_PREFIX + ) + endforeach() + + # Make sure that any system library dependencies that have been found via qt_find_package or + # _qt_internal_find_third_party_dependencies have their spdx id registered now. + _qt_internal_sbom_record_system_library_spdx_ids() + + set_property(GLOBAL PROPERTY _qt_internal_sbom_repo_begin_called TRUE) +endfunction() + +# Ends repo sbom project generation. +# Should be called after all relevant targets are added to the sbom. +# Handles registering sbom info for recorded system libraries and then creates the sbom build +# and install rules. +function(_qt_internal_sbom_end_project) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + # Now that we know which system libraries are linked against because we added all + # subdirectories, we can add the recorded system libs to the sbom. + _qt_internal_sbom_add_recorded_system_libraries() + + # Run sbom finalization for targets that had it scheduled, but haven't run yet. + # This can happen when _qt_internal_sbom_end_project is called within the same + # subdirectory scope as where the targets are meant to be finalized, but that would be too late + # and the targets wouldn't be added to the sbom. + # This would mostly happen in user projects, and not Qt repos, because in Qt repos we afaik + # never create targets in the root cmakelists (aside from the qtbase Platform targets). + get_cmake_property(targets _qt_internal_sbom_targets_waiting_for_finalization) + if(targets) + foreach(target IN LISTS targets) + _qt_internal_finalize_sbom("${target}") + endforeach() + endif() + + set(end_project_options "") + + if(QT_SBOM_GENERATE_JSON OR QT_INTERNAL_SBOM_GENERATE_JSON OR QT_INTERNAL_SBOM_DEFAULT_CHECKS) + list(APPEND end_project_options GENERATE_JSON) + endif() + + # Tring to generate the JSON might fail if the python dependencies are not available. + # The user can explicitly request to fail the build if dependencies are not found. + # error out. For internal options that the CI uses, we always want to fail the build if the + # deps are not found. + if(QT_SBOM_REQUIRE_GENERATE_JSON OR QT_INTERNAL_SBOM_GENERATE_JSON + OR QT_INTERNAL_SBOM_DEFAULT_CHECKS) + list(APPEND end_project_options GENERATE_JSON_REQUIRED) + endif() + + if(QT_SBOM_VERIFY OR QT_INTERNAL_SBOM_VERIFY OR QT_INTERNAL_SBOM_DEFAULT_CHECKS) + list(APPEND end_project_options VERIFY_SBOM) + endif() + + # Do the same requirement check for SBOM verification. + if(QT_SBOM_REQUIRE_VERIFY OR QT_INTERNAL_SBOM_VERIFY OR QT_INTERNAL_SBOM_DEFAULT_CHECKS) + list(APPEND end_project_options VERIFY_SBOM_REQUIRED) + endif() + + if(QT_INTERNAL_SBOM_VERIFY_NTIA_COMPLIANT OR QT_INTERNAL_SBOM_DEFAULT_CHECKS) + list(APPEND end_project_options VERIFY_NTIA_COMPLIANT) + endif() + + if(QT_INTERNAL_SBOM_SHOW_TABLE OR QT_INTERNAL_SBOM_DEFAULT_CHECKS) + list(APPEND end_project_options SHOW_TABLE) + endif() + + if(QT_INTERNAL_SBOM_AUDIT OR QT_INTERNAL_SBOM_AUDIT_NO_ERROR) + list(APPEND end_project_options AUDIT) + endif() + + if(QT_INTERNAL_SBOM_AUDIT_NO_ERROR) + list(APPEND end_project_options AUDIT_NO_ERROR) + endif() + + if(QT_GENERATE_SOURCE_SBOM) + list(APPEND end_project_options GENERATE_SOURCE_SBOM) + endif() + + if(QT_LINT_SOURCE_SBOM) + list(APPEND end_project_options LINT_SOURCE_SBOM) + endif() + + if(QT_INTERNAL_LINT_SOURCE_SBOM_NO_ERROR) + list(APPEND end_project_options LINT_SOURCE_SBOM_NO_ERROR) + endif() + + _qt_internal_sbom_end_project_generate( + ${end_project_options} + ) + + # Clean up external document ref properties, because each repo needs to start from scratch + # in a top-level build. + get_cmake_property(known_external_documents _qt_known_external_documents) + set_property(GLOBAL PROPERTY _qt_known_external_documents "") + foreach(external_document IN LISTS known_external_documents) + set_property(GLOBAL PROPERTY _qt_known_external_documents_${external_document} "") + endforeach() + + set_property(GLOBAL PROPERTY _qt_internal_sbom_repo_begin_called FALSE) + + # Add configure-time dependency on project attribution files. + get_property(attribution_files GLOBAL PROPERTY _qt_internal_project_attribution_files) + list(REMOVE_DUPLICATES attribution_files) + set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${attribution_files}") +endfunction() + +# Helper to get purl parsing options. +macro(_qt_internal_get_sbom_purl_parsing_options opt_args single_args multi_args) + set(${opt_args} + NO_PURL + NO_DEFAULT_QT_PURL + PURL_USE_PACKAGE_VERSION + ) + set(${single_args} + PURL_TYPE + PURL_NAMESPACE + PURL_NAME + PURL_VERSION + PURL_SUBPATH + PURL_VCS_URL + ) + set(${multi_args} + PURL_QUALIFIERS + ) +endmacro() + +# Helper to get the purl variant option names that should be recongized by sbom functions like +# _qt_internal_sbom_add_target. +macro(_qt_internal_get_sbom_purl_add_target_options opt_args single_args multi_args) + set(${opt_args} "") + set(${single_args} "") + set(${multi_args} + PURL_QT_ARGS + PURL_3RDPARTY_UPSTREAM_ARGS + PURL_MIRROR_ARGS + PURL_QT_VALUES + PURL_3RDPARTY_UPSTREAM_VALUES + PURL_MIRROR_VALUES + ) +endmacro() + +# Helper to get purl options that should be forwarded from _qt_internal_sbom_add_target to +# _qt_internal_sbom_handle_purl_values. +macro(_qt_internal_get_sbom_purl_handling_options opt_args single_args multi_args) + set(${opt_args} + IS_QT_ENTITY_TYPE + ) + set(${single_args} + SUPPLIER + TYPE + VERSION + ) + set(${multi_args} "") + + _qt_internal_get_sbom_purl_add_target_options( + purl_add_target_opt_args purl_add_target_single_args purl_add_target_multi_args) + list(APPEND ${opt_args} ${purl_add_target_opt_args}) + list(APPEND ${single_args} ${purl_add_target_single_args}) + list(APPEND ${multi_args} ${purl_add_target_multi_args}) +endmacro() + +# Helper to get the options that _qt_internal_sbom_add_target understands, but that are also +# a safe subset for qt_internal_add_module, qt_internal_extend_target, etc to understand. +macro(_qt_internal_get_sbom_add_target_common_options opt_args single_args multi_args) + set(${opt_args} + NO_CURRENT_DIR_ATTRIBUTION + NO_ATTRIBUTION_LICENSE_ID + NO_DEFAULT_QT_LICENSE + NO_DEFAULT_QT_LICENSE_ID_LIBRARIES + NO_DEFAULT_QT_LICENSE_ID_EXECUTABLES + NO_DEFAULT_DIRECTORY_QT_LICENSE + NO_DEFAULT_QT_COPYRIGHTS + NO_DEFAULT_QT_PACKAGE_VERSION + NO_DEFAULT_QT_SUPPLIER + SBOM_INCOMPLETE_3RD_PARTY_DEPENDENCIES + IS_QT_3RD_PARTY_HEADER_MODULE + ) + set(${single_args} + PACKAGE_VERSION + FRIENDLY_PACKAGE_NAME + CPE_VENDOR + CPE_PRODUCT + LICENSE_EXPRESSION + QT_LICENSE_ID + DOWNLOAD_LOCATION + ATTRIBUTION_ENTRY_INDEX + SBOM_PACKAGE_COMMENT + ) + set(${multi_args} + COPYRIGHTS + CPE + SBOM_DEPENDENCIES + ATTRIBUTION_FILE_PATHS + ATTRIBUTION_FILE_DIR_PATHS + ) + + _qt_internal_get_sbom_purl_add_target_options( + purl_add_target_opt_args purl_add_target_single_args purl_add_target_multi_args) + list(APPEND ${opt_args} ${purl_add_target_opt_args}) + list(APPEND ${single_args} ${purl_add_target_single_args}) + list(APPEND ${multi_args} ${purl_add_target_multi_args}) +endmacro() + +# Helper to get all known SBOM specific options, without the ones that qt_internal_add_module +# and similar functions understand, like LIBRARIES, INCLUDES, etc. +macro(_qt_internal_get_sbom_specific_options opt_args single_args multi_args) + set(${opt_args} "") + set(${single_args} "") + set(${multi_args} "") + + _qt_internal_get_sbom_add_target_common_options( + common_opt_args common_single_args common_multi_args) + list(APPEND ${opt_args} ${common_opt_args}) + list(APPEND ${single_args} ${common_single_args}) + list(APPEND ${multi_args} ${common_multi_args}) + + _qt_internal_sbom_get_multi_config_single_args(multi_config_single_args) + list(APPEND ${single_args} ${multi_config_single_args}) +endmacro() + +# Helper to get the options that _qt_internal_sbom_add_target understands. +# Also used in qt_find_package_extend_sbom. +macro(_qt_internal_get_sbom_add_target_options opt_args single_args multi_args) + set(${opt_args} + NO_INSTALL + ) + set(${single_args} + TYPE + ) + set(${multi_args} + LIBRARIES + PUBLIC_LIBRARIES + ) + + _qt_internal_get_sbom_specific_options( + specific_opt_args specific_single_args specific_multi_args) + list(APPEND ${opt_args} ${specific_opt_args}) + list(APPEND ${single_args} ${specific_single_args}) + list(APPEND ${multi_args} ${specific_multi_args}) +endmacro() + +# Generate sbom information for a given target. +# Creates: +# - a SPDX package for the target +# - zero or more SPDX file entries for each installed binary file +# - each binary file entry gets a list of 'generated from source files' section +# - dependency relationships to other target packages +# - other relevant information like licenses, copyright, etc. +# For licenses, copyrights, these can either be passed as options, or read from qt_attribution.json +# files. +# For dependencies, these are either specified via options, or read from properties set on the +# target by qt_internal_extend_target. +function(_qt_internal_sbom_add_target target) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + _qt_internal_get_sbom_add_target_options(opt_args single_args multi_args) + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + get_target_property(target_type ${target} TYPE) + + # Mark the target as a Qt module for sbom processing purposes. + # Needed for non-standard targets like Bootstrap and QtLibraryInfo, that don't have a Qt:: + # namespace prefix. + if(arg_TYPE STREQUAL QT_MODULE) + set_target_properties(${target} PROPERTIES _qt_sbom_is_qt_module TRUE) + endif() + + set(project_package_options "") + + _qt_internal_sbom_is_qt_entity_type("${arg_TYPE}" is_qt_entity_type) + _qt_internal_sbom_is_qt_3rd_party_entity_type("${arg_TYPE}" is_qt_3rd_party_entity_type) + + if(arg_FRIENDLY_PACKAGE_NAME) + set(package_name_for_spdx_id "${arg_FRIENDLY_PACKAGE_NAME}") + else() + set(package_name_for_spdx_id "${target}") + endif() + + set(package_comment "") + + if(arg_SBOM_INCOMPLETE_3RD_PARTY_DEPENDENCIES) + string(APPEND package_comment + "Note: This package was marked as not listing all of its consumed 3rd party " + "dependencies.\nThus the licensing and copyright information might be incomplete.\n") + endif() + + if(arg_SBOM_PACKAGE_COMMENT) + string(APPEND package_comment "${arg_SBOM_PACKAGE_COMMENT}\n") + endif() + + # Record the target spdx id right now, so we can refer to it in later attribution targets + # if needed. + _qt_internal_sbom_record_target_spdx_id(${target} + TYPE "${arg_TYPE}" + PACKAGE_NAME "${package_name_for_spdx_id}" + OUT_VAR package_spdx_id + ) + + set(attribution_args + PARENT_TARGET "${target}" + ) + + if(is_qt_entity_type) + list(APPEND attribution_args CREATE_SBOM_FOR_EACH_ATTRIBUTION) + endif() + + # Forward the sbom specific options when handling attribution files because those might + # create other sbom targets that need to inherit the parent ones. + _qt_internal_get_sbom_specific_options(sbom_opt_args sbom_single_args sbom_multi_args) + + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR attribution_args + FORWARD_OPTIONS + ${sbom_opt_args} + FORWARD_SINGLE + ${sbom_single_args} + FORWARD_MULTI + ${sbom_multi_args} + ) + + if(NOT arg_NO_CURRENT_DIR_ATTRIBUTION + AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/qt_attribution.json") + list(APPEND attribution_args + ATTRIBUTION_FILE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/qt_attribution.json" + ) + endif() + + _qt_internal_sbom_handle_qt_attribution_files(qa ${attribution_args}) + + # Collect license expressions, but in most cases, each expression needs to be abided, so we + # AND the accumulated license expressions. + set(license_expression "") + + if(arg_LICENSE_EXPRESSION) + set(license_expression "${arg_LICENSE_EXPRESSION}") + endif() + + # For Qt entities, we have some special handling. + if(is_qt_entity_type AND NOT arg_NO_DEFAULT_QT_LICENSE AND NOT arg_QT_LICENSE_ID) + if(arg_TYPE STREQUAL "QT_TOOL" OR arg_TYPE STREQUAL "QT_APP") + if(QT_SBOM_DEFAULT_QT_LICENSE_ID_EXECUTABLES + AND NOT arg_NO_DEFAULT_QT_LICENSE_ID_EXECUTABLES) + # A repo might contain only the "gpl3" license variant as the default for all + # executables, so allow setting it at the repo level to avoid having to repeat it + # for each target. + _qt_internal_sbom_get_spdx_license_expression( + "${QT_SBOM_DEFAULT_QT_LICENSE_ID_EXECUTABLES}" qt_license_expression) + else() + # For tools and apps, we use the gpl exception variant by default. + _qt_internal_sbom_get_spdx_license_expression("QT_COMMERCIAL_OR_GPL3_WITH_EXCEPTION" + qt_license_expression) + endif() + + elseif(QT_SBOM_DEFAULT_QT_LICENSE_ID_LIBRARIES + AND NOT arg_NO_DEFAULT_QT_LICENSE_ID_LIBRARIES) + # A repo might contain only the "gpl3" license variant as the default for all modules + # and plugins, so allow setting it at the repo level to avoid having to repeat it + # for each target. + _qt_internal_sbom_get_spdx_license_expression( + "${QT_SBOM_DEFAULT_QT_LICENSE_ID_LIBRARIES}" qt_license_expression) + + else() + # Otherwise, for modules and plugins we use the default qt license. + _qt_internal_sbom_get_spdx_license_expression("QT_DEFAULT" qt_license_expression) + endif() + + _qt_internal_sbom_join_two_license_ids_with_op( + "${license_expression}" "AND" "${qt_license_expression}" + license_expression) + endif() + + # Some Qt entities might request a specific license from the subset that we usually use. + if(arg_QT_LICENSE_ID) + _qt_internal_sbom_get_spdx_license_expression("${arg_QT_LICENSE_ID}" + requested_license_expression) + _qt_internal_sbom_join_two_license_ids_with_op( + "${license_expression}" "AND" "${requested_license_expression}" + license_expression) + endif() + + # Allow setting a license expression string per directory scope via a variable. + if(is_qt_entity_type AND QT_SBOM_LICENSE_EXPRESSION AND NOT arg_NO_DEFAULT_DIRECTORY_QT_LICENSE) + set(qt_license_expression "${QT_SBOM_LICENSE_EXPRESSION}") + _qt_internal_sbom_join_two_license_ids_with_op( + "${license_expression}" "AND" "${qt_license_expression}" + license_expression) + endif() + + # Read a license expression from the attribution json file. + if(qa_license_id AND NOT arg_NO_ATTRIBUTION_LICENSE_ID) + if(NOT qa_license_id MATCHES "urn:dje:license") + _qt_internal_sbom_join_two_license_ids_with_op( + "${license_expression}" "AND" "${qa_license_id}" + license_expression) + else() + message(DEBUG + "Attribution license id contains invalid spdx license reference: ${qa_license_id}") + set(invalid_license_comment + " Attribution license ID with invalid spdx license reference: ") + string(APPEND invalid_license_comment "${qa_license_id}\n") + string(APPEND package_comment "${invalid_license_comment}") + endif() + endif() + + if(license_expression) + list(APPEND project_package_options LICENSE_CONCLUDED "${license_expression}") + + # For qt entities we know the license we provide, so we mark it as declared as well. + if(is_qt_entity_type) + list(APPEND project_package_options LICENSE_DECLARED "${license_expression}") + endif() + endif() + + # Copyrights are additive, so we collect them from all sources that were found. + set(copyrights "") + if(arg_COPYRIGHTS) + list(APPEND copyrights "${arg_COPYRIGHTS}") + endif() + if(is_qt_entity_type AND NOT arg_NO_DEFAULT_QT_COPYRIGHTS) + _qt_internal_sbom_get_default_qt_copyright_header(qt_default_copyright) + if(qt_default_copyright) + list(APPEND copyrights "${qt_default_copyright}") + endif() + endif() + if(qa_copyrights) + list(APPEND copyrights "${qa_copyrights}") + endif() + if(copyrights) + list(JOIN copyrights "\n" copyrights) + list(APPEND project_package_options COPYRIGHT "${copyrights}") + endif() + + set(package_version "") + if(arg_PACKAGE_VERSION) + set(package_version "${arg_PACKAGE_VERSION}") + elseif(is_qt_entity_type AND NOT arg_NO_DEFAULT_QT_PACKAGE_VERSION) + _qt_internal_sbom_get_default_qt_package_version(package_version) + elseif(qa_version) + set(package_version "${qa_version}") + endif() + if(package_version) + list(APPEND project_package_options VERSION "${package_version}") + endif() + + set(supplier "") + if((is_qt_entity_type OR is_qt_3rd_party_entity_type) + AND NOT arg_NO_DEFAULT_QT_SUPPLIER) + _qt_internal_sbom_get_default_supplier(supplier) + endif() + if(supplier) + list(APPEND project_package_options SUPPLIER "Organization: ${supplier}") + endif() + + set(download_location "") + if(arg_DOWNLOAD_LOCATION) + set(download_location "${arg_DOWNLOAD_LOCATION}") + elseif(is_qt_entity_type) + _qt_internal_sbom_get_qt_repo_source_download_location(download_location) + elseif(arg_TYPE STREQUAL "QT_THIRD_PARTY_MODULE" OR arg_TYPE STREQUAL "QT_THIRD_PARTY_SOURCES") + if(qa_download_location) + set(download_location "${qa_download_location}") + elseif(qa_homepage) + set(download_location "${qa_homepage}") + endif() + elseif(arg_TYPE STREQUAL "SYSTEM_LIBRARY") + # Try to get package url that was set using CMake's set_package_properties function. + # Relies on querying the internal global property name that CMake sets in its + # implementation. + get_cmake_property(target_url _CMAKE_${package_name_for_spdx_id}_URL) + if(target_url) + set(download_location "${target_url}") + endif() + if(NOT download_location AND qa_download_location) + set(download_location "${qa_download_location}") + endif() + endif() + + if(download_location) + list(APPEND project_package_options DOWNLOAD_LOCATION "${download_location}") + endif() + + _qt_internal_sbom_get_package_purpose("${arg_TYPE}" package_purpose) + list(APPEND project_package_options PURPOSE "${package_purpose}") + + set(cpe_args "") + + if(arg_CPE) + list(APPEND cpe_args CPE "${arg_CPE}") + endif() + + if(arg_CPE_VENDOR AND arg_CPE_PRODUCT) + _qt_internal_sbom_compute_security_cpe(custom_cpe + VENDOR "${arg_CPE_VENDOR}" + PRODUCT "${arg_CPE_PRODUCT}" + VERSION "${package_version}") + list(APPEND cpe_args CPE "${custom_cpe}") + endif() + + if(qa_cpes) + list(APPEND cpe_args CPE "${qa_cpes}") + endif() + + # Add the qt-specific CPE if the target is a Qt entity type, or if it's a 3rd party entity type + # without any CPE specified. + if(is_qt_entity_type OR (is_qt_3rd_party_entity_type AND NOT cpe_args)) + _qt_internal_sbom_compute_security_cpe_for_qt(cpe_list) + list(APPEND cpe_args CPE "${cpe_list}") + endif() + + if(cpe_args) + list(APPEND project_package_options ${cpe_args}) + endif() + + # Assemble arguments to forward to the function that handles purl options. + set(purl_args "") + _qt_internal_get_sbom_purl_add_target_options(purl_opt_args purl_single_args purl_multi_args) + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR purl_args + FORWARD_OPTIONS + ${purl_opt_args} + FORWARD_SINGLE + ${purl_single_args} + TYPE + FORWARD_MULTI + ${purl_multi_args} + ) + + list(APPEND purl_args SUPPLIER "${supplier}") + list(APPEND purl_args VERSION "${package_version}") + if(is_qt_entity_type) + list(APPEND purl_args IS_QT_ENTITY_TYPE) + endif() + if(qa_purls) + list(APPEND purl_args PURL_3RDPARTY_UPSTREAM_VALUES "${qa_purls}") + endif() + list(APPEND purl_args OUT_VAR purl_package_options) + + _qt_internal_sbom_handle_purl_values(${target} ${purl_args}) + + if(purl_package_options) + list(APPEND project_package_options ${purl_package_options}) + endif() + + if(is_qt_3rd_party_entity_type + OR arg_TYPE STREQUAL "SYSTEM_LIBRARY" + OR arg_TYPE STREQUAL "THIRD_PARTY_LIBRARY" + OR arg_TYPE STREQUAL "THIRD_PARTY_LIBRARY_WITH_FILES" + ) + if(qa_attribution_name) + string(APPEND package_comment " Name: ${qa_attribution_name}\n") + endif() + + if(qa_description) + string(APPEND package_comment " Description: ${qa_description}\n") + endif() + + if(qa_qt_usage) + string(APPEND package_comment " Qt usage: ${qa_qt_usage}\n") + endif() + + if(qa_chosen_attribution_file_path) + _qt_internal_sbom_map_path_to_reproducible_relative_path(relative_attribution_path + PATH "${qa_chosen_attribution_file_path}" + ) + string(APPEND package_comment + " Information extracted from:\n ${relative_attribution_path}\n") + endif() + + if(NOT "${qa_chosen_attribution_entry_index}" STREQUAL "") + string(APPEND package_comment + " Entry index: ${qa_chosen_attribution_entry_index}\n") + endif() + endif() + + if(package_comment) + list(APPEND project_package_options COMMENT "\n${package_comment}") + endif() + + _qt_internal_sbom_handle_target_dependencies("${target}" + SPDX_ID "${package_spdx_id}" + LIBRARIES "${arg_LIBRARIES}" + PUBLIC_LIBRARIES "${arg_PUBLIC_LIBRARIES}" + OUT_RELATIONSHIPS relationships + ) + + get_cmake_property(project_spdx_id _qt_internal_sbom_project_spdx_id) + list(APPEND relationships "${project_spdx_id} CONTAINS ${package_spdx_id}") + + list(REMOVE_DUPLICATES relationships) + list(JOIN relationships "\nRelationship: " relationships) + list(APPEND project_package_options RELATIONSHIP "${relationships}") + + _qt_internal_sbom_generate_add_package( + PACKAGE "${package_name_for_spdx_id}" + SPDXID "${package_spdx_id}" + CONTAINS_FILES + ${project_package_options} + ) + + set(no_install_option "") + if(arg_NO_INSTALL) + set(no_install_option NO_INSTALL) + endif() + + set(framework_option "") + if(APPLE AND NOT target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(is_framework ${target} FRAMEWORK) + if(is_framework) + set(framework_option "FRAMEWORK") + endif() + endif() + + set(install_prefix_option "") + get_cmake_property(install_prefix _qt_internal_sbom_install_prefix) + if(install_prefix) + set(install_prefix_option INSTALL_PREFIX "${install_prefix}") + endif() + + _qt_internal_forward_function_args( + FORWARD_PREFIX arg + FORWARD_OUT_VAR target_binary_multi_config_args + FORWARD_SINGLE + ${multi_config_single_args} + ) + + _qt_internal_sbom_handle_target_binary_files("${target}" + ${no_install_option} + ${framework_option} + ${install_prefix_option} + TYPE "${arg_TYPE}" + ${target_binary_multi_config_args} + SPDX_ID "${package_spdx_id}" + COPYRIGHTS "${copyrights}" + LICENSE_EXPRESSION "${license_expression}" + ) +endfunction() + +# Walks a target's direct dependencies and assembles a list of relationships between the packages +# of the target dependencies. +# Currently handles various Qt targets and system libraries. +function(_qt_internal_sbom_handle_target_dependencies target) + set(opt_args "") + set(single_args + SPDX_ID + OUT_RELATIONSHIPS + ) + set(multi_args + LIBRARIES + PUBLIC_LIBRARIES + ) + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_SPDX_ID) + message(FATAL_ERROR "SPDX_ID must be set") + endif() + set(package_spdx_id "${arg_SPDX_ID}") + + + set(libraries "") + if(arg_LIBRARIES) + list(APPEND libraries "${arg_LIBRARIES}") + endif() + + get_target_property(extend_libraries "${target}" _qt_extend_target_libraries) + if(extend_libraries) + list(APPEND libraries ${extend_libraries}) + endif() + + get_target_property(target_type ${target} TYPE) + set(valid_target_types + EXECUTABLE + SHARED_LIBRARY + MODULE_LIBRARY + STATIC_LIBRARY + OBJECT_LIBRARY + ) + if(target_type IN_LIST valid_target_types) + get_target_property(link_libraries "${target}" LINK_LIBRARIES) + if(link_libraries) + list(APPEND libraries ${link_Libraries}) + endif() + endif() + + set(public_libraries "") + if(arg_PUBLIC_LIBRARIES) + list(APPEND public_libraries "${arg_PUBLIC_LIBRARIES}") + endif() + + get_target_property(extend_public_libraries "${target}" _qt_extend_target_public_libraries) + if(extend_public_libraries) + list(APPEND public_libraries ${extend_public_libraries}) + endif() + + set(sbom_dependencies "") + if(arg_SBOM_DEPENDENCIES) + list(APPEND sbom_dependencies "${arg_SBOM_DEPENDENCIES}") + endif() + + get_target_property(extend_sbom_dependencies "${target}" _qt_extend_target_sbom_dependencies) + if(extend_sbom_dependencies) + list(APPEND sbom_dependencies ${extend_sbom_dependencies}) + endif() + + list(REMOVE_DUPLICATES libraries) + list(REMOVE_DUPLICATES public_libraries) + list(REMOVE_DUPLICATES sbom_dependencies) + + set(all_direct_libraries ${libraries} ${public_libraries} ${sbom_dependencies}) + list(REMOVE_DUPLICATES all_direct_libraries) + + set(spdx_dependencies "") + set(relationships "") + + # Go through each direct linked lib. + foreach(direct_lib IN LISTS all_direct_libraries) + if(NOT TARGET "${direct_lib}") + continue() + endif() + + # Some targets are Qt modules, even though they are not prefixed with Qt::, targets + # like Bootstrap and QtLibraryInfo. We use the property to differentiate them. + get_target_property(is_marked_as_qt_module "${direct_lib}" _qt_sbom_is_qt_module) + + # Custom sbom targets created by _qt_internal_create_sbom_target are always imported, so we + # need to differentiate them via this property. + get_target_property(is_custom_sbom_target "${direct_lib}" _qt_sbom_is_custom_sbom_target) + + if("${direct_lib}" MATCHES "^(Qt::.*)|(${QT_CMAKE_EXPORT_NAMESPACE}::.*)") + set(is_qt_prefixed TRUE) + else() + set(is_qt_prefixed FALSE) + endif() + + # is_qt_dependency is not strictly only a qt dependency, it applies to custom sbom + # targets as well. But I'm having a hard time to come up with a better name. + if(is_marked_as_qt_module OR is_custom_sbom_target OR is_qt_prefixed) + set(is_qt_dependency TRUE) + else() + set(is_qt_dependency FALSE) + endif() + + # Regular Qt dependency, depend on the relevant package, either within the current + # document or via an external document. + if(is_qt_dependency) + _qt_internal_sbom_is_external_target_dependency("${direct_lib}" + OUT_VAR is_dependency_in_external_document + ) + + if(is_dependency_in_external_document) + # External document case. + _qt_internal_sbom_add_external_target_dependency( + "${package_spdx_id}" "${direct_lib}" + extra_spdx_dependencies + extra_spdx_relationships + ) + if(extra_spdx_dependencies) + list(APPEND spdx_dependencies "${extra_spdx_dependencies}") + endif() + if(extra_spdx_relationships) + list(APPEND relationships "${extra_spdx_relationships}") + endif() + else() + # Dependency is part of current repo build. + _qt_internal_sbom_get_spdx_id_for_target("${direct_lib}" dep_spdx_id) + if(dep_spdx_id) + list(APPEND spdx_dependencies "${dep_spdx_id}") + else() + message(DEBUG "Could not add target dependency on ${direct_lib} " + "because no spdx id could be found") + endif() + endif() + else() + # If it's not a Qt dependency, then it's most likely a 3rd party dependency. + # If we are looking at a FindWrap dependency, we need to depend on either + # the system or vendored lib, whichever one the FindWrap script points to. + # If we are looking at a non-Wrap dependency, it's 99% a system lib. + __qt_internal_walk_libs( + "${direct_lib}" + lib_walked_targets + _discarded_out_var + "sbom_targets" + "collect_targets") + + # Detect if we are dealing with a vendored / bundled lib. + set(bundled_targets_found FALSE) + if(lib_walked_targets) + foreach(lib_walked_target IN LISTS lib_walked_targets) + get_target_property(is_3rdparty_bundled_lib + "${lib_walked_target}" _qt_module_is_3rdparty_library) + _qt_internal_sbom_get_spdx_id_for_target("${lib_walked_target}" lib_spdx_id) + + # Add a dependency on the vendored lib instead of the Wrap target. + if(is_3rdparty_bundled_lib AND lib_spdx_id) + list(APPEND spdx_dependencies "${lib_spdx_id}") + set(bundled_targets_found TRUE) + endif() + endforeach() + endif() + + # If no bundled libs were found as a result of walking the Wrap lib, we consider this + # a system lib, and add a dependency on it directly. + if(NOT bundled_targets_found) + _qt_internal_sbom_get_spdx_id_for_target("${direct_lib}" lib_spdx_id) + _qt_internal_sbom_is_external_target_dependency("${direct_lib}" + SYSTEM_LIBRARY + OUT_VAR is_dependency_in_external_document + ) + + if(lib_spdx_id) + if(NOT is_dependency_in_external_document) + list(APPEND spdx_dependencies "${lib_spdx_id}") + + # Mark the system library is used, so that we later generate an sbom for it. + _qt_internal_append_to_cmake_property_without_duplicates( + _qt_internal_sbom_consumed_system_library_targets + "${direct_lib}" + ) + else() + # Refer to the package in the external document. This can be the case + # in a top-level build, where a system library is reused across repos. + _qt_internal_sbom_add_external_target_dependency( + "${package_spdx_id}" "${direct_lib}" + extra_spdx_dependencies + extra_spdx_relationships + ) + if(extra_spdx_dependencies) + list(APPEND spdx_dependencies "${extra_spdx_dependencies}") + endif() + if(extra_spdx_relationships) + list(APPEND relationships "${extra_spdx_relationships}") + endif() + endif() + else() + message(DEBUG "Could not add target dependency on system library ${direct_lib} " + "because no spdx id could be found") + endif() + endif() + endif() + endforeach() + + foreach(dep_spdx_id IN LISTS spdx_dependencies) + set(relationship + "${package_spdx_id} DEPENDS_ON ${dep_spdx_id}" + ) + list(APPEND relationships "${relationship}") + endforeach() + + set(${arg_OUT_RELATIONSHIPS} "${relationships}" PARENT_SCOPE) +endfunction() + +# Checks whether the current target will have its sbom generated into the current repo sbom +# document, or whether it is present in an external sbom document. +function(_qt_internal_sbom_is_external_target_dependency target) + set(opt_args + SYSTEM_LIBRARY + ) + set(single_args + OUT_VAR + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + get_target_property(is_imported "${target}" IMPORTED) + get_target_property(is_custom_sbom_target "${target}" _qt_sbom_is_custom_sbom_target) + + _qt_internal_sbom_get_root_project_name_lower_case(current_repo_project_name) + get_property(target_repo_project_name TARGET ${target} + PROPERTY _qt_sbom_spdx_repo_project_name_lowercase) + + if(NOT "${target_repo_project_name}" STREQUAL "" + AND NOT "${target_repo_project_name}" STREQUAL "${current_repo_project_name}") + set(part_of_other_repo TRUE) + else() + set(part_of_other_repo FALSE) + endif() + + # A target is in an external document if + # 1) it is imported, and not a custom sbom target, and not a system library + # 2) it was created as part of another repo in a top-level build + if((is_imported AND NOT is_custom_sbom_target AND NOT arg_SYSTEM_LIBRARY) + OR part_of_other_repo) + set(is_dependency_in_external_document TRUE) + else() + set(is_dependency_in_external_document FALSE) + endif() + + set(${arg_OUT_VAR} "${is_dependency_in_external_document}" PARENT_SCOPE) +endfunction() + +# Handles generating an external document reference SDPX element for each target package that is +# located in a different spdx document. +function(_qt_internal_sbom_add_external_target_dependency + current_package_spdx_id + target_dep + out_spdx_dependencies + out_spdx_relationships + ) + set(target "${target_dep}") + + _qt_internal_sbom_get_spdx_id_for_target("${target}" dep_spdx_id) + + if(NOT dep_spdx_id) + message(DEBUG "Could not add external target dependency on ${target} " + "because no spdx id could be found") + set(${out_spdx_dependencies} "" PARENT_SCOPE) + set(${out_spdx_relationships} "" PARENT_SCOPE) + return() + endif() + + set(spdx_dependencies "") + set(spdx_relationships "") + + # Get the external document path and the repo it belongs to for the given target. + get_property(relative_installed_repo_document_path TARGET ${target} + PROPERTY _qt_sbom_spdx_relative_installed_repo_document_path) + + get_property(project_name_lowercase TARGET ${target} + PROPERTY _qt_sbom_spdx_repo_project_name_lowercase) + + if(relative_installed_repo_document_path AND project_name_lowercase) + _qt_internal_sbom_get_external_document_ref_spdx_id( + "${project_name_lowercase}" external_document_ref) + + get_cmake_property(known_external_document + _qt_known_external_documents_${external_document_ref}) + + set(relationship + "${current_package_spdx_id} DEPENDS_ON ${external_document_ref}:${dep_spdx_id}") + + list(APPEND spdx_relationships "${relationship}") + + # Only add a reference to the external document package, if we haven't done so already. + if(NOT known_external_document) + set(install_prefixes "") + + get_cmake_property(install_prefix _qt_internal_sbom_install_prefix) + list(APPEND install_prefixes "${install_prefix}") + + # Add the current sbom build dirs as install prefixes, so that we can use ninja 'sbom' + # in top-level builds. This is needed because the external references will point + # to sbom docs in different build dirs, not just one. + if(QT_SUPERBUILD) + get_cmake_property(build_sbom_dirs _qt_internal_sbom_dirs) + if(build_sbom_dirs) + foreach(build_sbom_dir IN LISTS build_sbom_dirs) + list(APPEND install_prefixes "${build_sbom_dir}") + endforeach() + endif() + endif() + + set(external_document "${relative_installed_repo_document_path}") + + _qt_internal_sbom_generate_add_external_reference( + NO_AUTO_RELATIONSHIP + EXTERNAL "${dep_spdx_id}" + FILENAME "${external_document}" + SPDXID "${external_document_ref}" + INSTALL_PREFIXES ${install_prefixes} + ) + + set_property(GLOBAL PROPERTY + _qt_known_external_documents_${external_document_ref} TRUE) + set_property(GLOBAL APPEND PROPERTY + _qt_known_external_documents "${external_document_ref}") + endif() + else() + message(WARNING "Missing spdx document path for external ref: " + "package_name_for_spdx_id ${package_name_for_spdx_id} direct_lib ${direct_lib}") + endif() + + set(${out_spdx_dependencies} "${spdx_dependencies}" PARENT_SCOPE) + set(${out_spdx_relationships} "${spdx_relationships}" PARENT_SCOPE) +endfunction() + +# Handles addition of binary files SPDX entries for a given target. +# Is multi-config aware. +function(_qt_internal_sbom_handle_target_binary_files target) + set(opt_args + NO_INSTALL + FRAMEWORK + ) + set(single_args + TYPE + SPDX_ID + LICENSE_EXPRESSION + INSTALL_PREFIX + ) + set(multi_args + COPYRIGHTS + ) + + _qt_internal_sbom_get_multi_config_single_args(multi_config_single_args) + list(APPEND single_args ${multi_config_single_args}) + + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(arg_NO_INSTALL) + message(DEBUG "Skipping sbom target file processing ${target} because NO_INSTALL is set") + return() + endif() + + set(supported_types + QT_MODULE + QT_PLUGIN + QT_APP + QT_TOOL + QT_THIRD_PARTY_MODULE + QT_THIRD_PARTY_SOURCES + SYSTEM_LIBRARY + + # This will be meant for user projects, and are not currently used by Qt's sbom. + THIRD_PARTY_LIBRARY + THIRD_PARTY_LIBRARY_WITH_FILES + EXECUTABLE + LIBRARY + ) + + if(NOT arg_TYPE IN_LIST supported_types) + message(FATAL_ERROR "Unsupported target TYPE for SBOM creation: ${arg_TYPE}") + endif() + + set(types_without_files + SYSTEM_LIBRARY + QT_THIRD_PARTY_SOURCES + THIRD_PARTY_LIBRARY + ) + + get_target_property(target_type ${target} TYPE) + + if(arg_TYPE IN_LIST types_without_files) + message(DEBUG "Target ${target} has no binary files to reference in the SBOM " + "because it has the ${arg_TYPE} type.") + return() + endif() + + if(target_type STREQUAL "INTERFACE_LIBRARY") + message(DEBUG "Target ${target} has no binary files to reference in the SBOM " + "because it is an INTERFACE_LIBRARY.") + return() + endif() + + get_target_property(excluded ${target} _qt_internal_excluded_from_default_target) + if(excluded) + message(DEBUG "Target ${target} has no binary files to reference in the SBOM " + "because it was excluded from the default 'all' target.") + return() + endif() + + if(NOT arg_SPDX_ID) + message(FATAL_ERROR "SPDX_ID must be set") + endif() + set(package_spdx_id "${arg_SPDX_ID}") + + set(file_common_options "") + + list(APPEND file_common_options PACKAGE_SPDX_ID "${package_spdx_id}") + list(APPEND file_common_options PACKAGE_TYPE "${arg_TYPE}") + + if(arg_COPYRIGHTS) + list(APPEND file_common_options COPYRIGHTS "${arg_COPYRIGHTS}") + endif() + + if(arg_LICENSE_EXPRESSION) + list(APPEND file_common_options LICENSE_EXPRESSION "${arg_LICENSE_EXPRESSION}") + endif() + + if(arg_INSTALL_PREFIX) + list(APPEND file_common_options INSTALL_PREFIX "${arg_INSTALL_PREFIX}") + endif() + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + else() + set(configs "${CMAKE_BUILD_TYPE}") + endif() + + set(path_suffix "$") + + if(arg_FRAMEWORK) + set(library_path_kind FRAMEWORK_PATH) + else() + set(library_path_kind LIBRARY_PATH) + endif() + + if(arg_TYPE STREQUAL "QT_TOOL" + OR arg_TYPE STREQUAL "QT_APP" + OR arg_TYPE STREQUAL "EXECUTABLE") + + set(valid_executable_types + "EXECUTABLE" + ) + if(ANDROID) + list(APPEND valid_executable_types "MODULE_LIBRARY") + endif() + if(NOT target_type IN_LIST valid_executable_types) + message(FATAL_ERROR "Unsupported target type: ${target_type}") + endif() + + get_target_property(app_is_bundle ${target} MACOSX_BUNDLE) + if(app_is_bundle) + _qt_internal_get_executable_bundle_info(bundle "${target}") + _qt_internal_path_join(path_suffix "${bundle_contents_binary_dir}" "${path_suffix}") + endif() + + _qt_internal_sbom_handle_multi_config_target_binary_file(${target} + PATH_KIND RUNTIME_PATH + PATH_SUFFIX "${path_suffix}" + OPTIONS ${file_common_options} + ) + elseif(arg_TYPE STREQUAL "QT_PLUGIN") + if(NOT (target_type STREQUAL "SHARED_LIBRARY" + OR target_type STREQUAL "STATIC_LIBRARY" + OR target_type STREQUAL "MODULE_LIBRARY")) + message(FATAL_ERROR "Unsupported target type: ${target_type}") + endif() + + _qt_internal_sbom_handle_multi_config_target_binary_file(${target} + PATH_KIND INSTALL_PATH + PATH_SUFFIX "${path_suffix}" + OPTIONS ${file_common_options} + ) + elseif(arg_TYPE STREQUAL "QT_MODULE" + OR arg_TYPE STREQUAL "QT_THIRD_PARTY_MODULE" + OR arg_TYPE STREQUAL "LIBRARY" + OR arg_TYPE STREQUAL "THIRD_PARTY_LIBRARY_WITH_FILES" + ) + if(WIN32 AND target_type STREQUAL "SHARED_LIBRARY") + _qt_internal_sbom_handle_multi_config_target_binary_file(${target} + PATH_KIND RUNTIME_PATH + PATH_SUFFIX "${path_suffix}" + OPTIONS ${file_common_options} + ) + + _qt_internal_sbom_handle_multi_config_target_binary_file(${target} + PATH_KIND ARCHIVE_PATH + PATH_SUFFIX "$" + OPTIONS + ${file_common_options} + IMPORT_LIBRARY + # OPTIONAL because on Windows the import library might not always be present, + # because no symbols are exported. + OPTIONAL + ) + elseif(target_type STREQUAL "SHARED_LIBRARY" OR target_type STREQUAL "STATIC_LIBRARY") + _qt_internal_sbom_handle_multi_config_target_binary_file(${target} + PATH_KIND "${library_path_kind}" + PATH_SUFFIX "${path_suffix}" + OPTIONS ${file_common_options} + ) + else() + message(FATAL_ERROR "Unsupported target type: ${target_type}") + endif() + endif() +endfunction() + +# Add a binary file of a target to the sbom (e.g a shared library or an executable). +# Adds relationships to the SBOM that the binary file was generated from its source files, +# as well as relationship to the owning package. +function(_qt_internal_sbom_add_binary_file target file_path) + set(opt_args + OPTIONAL + IMPORT_LIBRARY + ) + set(single_args + PACKAGE_SPDX_ID + PACKAGE_TYPE + LICENSE_EXPRESSION + CONFIG + INSTALL_PREFIX + ) + set(multi_args + COPYRIGHTS + ) + cmake_parse_arguments(PARSE_ARGV 2 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_PACKAGE_SPDX_ID) + message(FATAL_ERROR "PACKAGE_SPDX_ID must be set") + endif() + + set(file_common_options "") + + if(arg_COPYRIGHTS) + list(JOIN arg_COPYRIGHTS "\n" copyrights) + list(APPEND file_common_options COPYRIGHT "${copyrights}") + endif() + + if(arg_LICENSE_EXPRESSION) + list(APPEND file_common_options LICENSE "${arg_LICENSE_EXPRESSION}") + endif() + + if(arg_INSTALL_PREFIX) + list(APPEND file_common_options INSTALL_PREFIX "${arg_INSTALL_PREFIX}") + endif() + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + else() + set(configs "${CMAKE_BUILD_TYPE}") + endif() + + if(is_multi_config) + set(spdx_id_suffix "${arg_CONFIG}") + set(config_to_install_option CONFIG ${arg_CONFIG}) + else() + set(spdx_id_suffix "") + set(config_to_install_option "") + endif() + + set(file_infix "") + if(arg_IMPORT_LIBRARY) + set(file_infix "-ImportLibrary") + endif() + + # We kind of have to add the package infix into the file spdx, otherwise we get file system + # collisions for cases like the qml tool and Qml library, and apparently cmake's file(GENERATE) + # is case insensitive for file names. + _qt_internal_sbom_get_package_infix("${arg_PACKAGE_TYPE}" package_infix) + + _qt_internal_sbom_get_file_spdx_id( + "${package_infix}-${target}-${file_infix}-${spdx_id_suffix}" spdx_id) + + set(optional "") + if(arg_OPTIONAL) + set(optional OPTIONAL) + endif() + + # Add relationship from owning package. + set(relationships "${arg_PACKAGE_SPDX_ID} CONTAINS ${spdx_id}") + + # Add source file relationships from which the binary file was generated. + _qt_internal_sbom_add_source_files("${target}" "${spdx_id}" source_relationships) + if(source_relationships) + list(APPEND relationships "${source_relationships}") + endif() + + set(glue "\nRelationship: ") + # Replace semicolon with $ to avoid errors when passing into sbom_add. + string(REPLACE ";" "$" relationships "${relationships}") + + # Glue the relationships at generation time, because there some source file relationships + # will be conditional on genexes, and evaluate to an empty value, and we want to discard + # such relationships. + set(relationships "$") + set(relationship_option RELATIONSHIP "${relationships}") + + # Add the actual binary file to the latest package. + _qt_internal_sbom_generate_add_file( + FILENAME "${file_path}" + FILETYPE BINARY ${optional} + SPDXID "${spdx_id}" + ${file_common_options} + ${config_to_install_option} + ${relationship_option} + ) +endfunction() + +# Takes a relative or absolute path and maps it to a reproducible path that is relative to +# the project source or build dir. +function(_qt_internal_sbom_map_path_to_reproducible_relative_path out_var) + set(opt_args "") + set(single_args + PATH + REPO_PROJECT_NAME_LOWERCASE + OUT_SUCCESS + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(is_in_source_dir FALSE) + set(is_in_build_dir FALSE) + + if(NOT arg_REPO_PROJECT_NAME_LOWERCASE) + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name) + else() + set(repo_project_name "${arg_REPO_PROJECT_NAME_LOWERCASE}") + endif() + + if(NOT DEFINED arg_PATH) + message(FATAL_ERROR "PATH must be set") + endif() + set(path "${arg_PATH}") + + set(handled FALSE) + + if(path MATCHES "$<.+>") + # TODO: Paths wrapped in genexes are usually absolute paths that we also want to handle, + # but can't at configure time. We'll need a separate processing step at build time. + # Keep these as is for now, but signal failure of handling. + set(path_out "${path}") + else() + if(IS_ABSOLUTE "${path}") + set(path_in "${path}") + if(path MATCHES "^${PROJECT_SOURCE_DIR}/") + set(is_in_source_dir TRUE) + elseif(path MATCHES "^${PROJECT_BINARY_DIR}/") + set(is_in_build_dir TRUE) + endif() + else() + # We consider relative paths to be relative to the current source dir. + set(is_in_source_dir TRUE) + set(path_in "${CMAKE_CURRENT_SOURCE_DIR}/${path}") + endif() + + # Resolve any .. and replace the absolute path with a path relative to the source dir + # or build dir, prefixed with a root marker. + get_filename_component(path_in_real "${path_in}" REALPATH) + + # Replace the absolute prefixes with markers. + if(is_in_source_dir) + set(handled TRUE) + set(marker "/src_dir") + string(REPLACE "${PROJECT_SOURCE_DIR}/" "${marker}/${repo_project_name}/" + path_out "${path_in_real}") + elseif(is_in_build_dir) + set(handled TRUE) + set(marker "/build_dir") + string(REPLACE "${PROJECT_BINARY_DIR}/" "${marker}/${repo_project_name}/" + path_out "${path_in_real}") + else() + # If it's not a source dir or a build dir, it might be some kind of weird genex + # or marker that we don't handle yet. + set(path_out "${path_in_real}") + endif() + endif() + + set(${out_var} "${path_out}" PARENT_SCOPE) + if(arg_OUT_SUCCESS) + set(${arg_OUT_SUCCESS} "${handled}" PARENT_SCOPE) + endif() +endfunction() + +# Adds source file "generated from" relationship comments to the sbom for a given target. +function(_qt_internal_sbom_add_source_files target spdx_id out_relationships) + get_target_property(sources ${target} SOURCES) + list(REMOVE_DUPLICATES sources) + + set(relationships "") + + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + + foreach(source IN LISTS sources) + # Filter out $. + if(source MATCHES "^\\$$") + continue() + endif() + + # Filter out prl files. + if(source MATCHES "\.prl$") + continue() + endif() + + # Filter out pkg-config. pc files. + if(source MATCHES "\.pc$") + continue() + endif() + + # Filter out metatypes .json.gen files. + if(source MATCHES "\.json\.gen$") + continue() + endif() + + _qt_internal_sbom_map_path_to_reproducible_relative_path(source_path + PATH "${source}" + REPO_PROJECT_NAME_LOWERCASE "${repo_project_name_lowercase}" + ) + + set(source_entry +"${spdx_id} GENERATED_FROM NOASSERTION\nRelationshipComment: ${source_path}" + ) + set(source_non_empty "$") + # Some sources are conditional on genexes, so we evaluate them. + set(relationship "$<${source_non_empty}:$>") + list(APPEND relationships "${relationship}") + endforeach() + + set(${out_relationships} "${relationships}" PARENT_SCOPE) +endfunction() + +# Adds a license id and its text to the sbom. +function(_qt_internal_sbom_add_license) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + set(opt_args + NO_LICENSE_REF_PREFIX + ) + set(single_args + LICENSE_ID + LICENSE_PATH + EXTRACTED_TEXT + ) + set(multi_args + ) + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_LICENSE_ID) + message(FATAL_ERROR "LICENSE_ID must be set") + endif() + + if(NOT arg_TEXT AND NOT arg_LICENSE_PATH) + message(FATAL_ERROR "Either TEXT or LICENSE_PATH must be set") + endif() + + # Sanitize the content a bit. + if(arg_TEXT) + set(text "${arg_TEXT}") + string(REPLACE ";" "$" text "${text}") + string(REPLACE "\"" "\\\"" text "${text}") + else() + file(READ "${arg_LICENSE_PATH}" text) + string(REPLACE ";" "$" text "${text}") + string(REPLACE "\"" "\\\"" text "${text}") + endif() + + set(license_id "${arg_LICENSE_ID}") + if(NOT arg_NO_LICENSE_REF_PREFIX) + set(license_id "LicenseRef-${license_id}") + endif() + + _qt_internal_sbom_generate_add_license( + LICENSE_ID "${license_id}" + EXTRACTED_TEXT "${text}" + ) +endfunction() + +# Records information about a system library target, usually due to a qt_find_package call. +# This information is later used to generate packages for the system libraries, but only after +# confirming that the library was used (linked) into any of the Qt targets. +function(_qt_internal_sbom_record_system_library_usage target) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + set(opt_args "") + set(single_args + TYPE + PACKAGE_VERSION + FRIENDLY_PACKAGE_NAME + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_TYPE) + message(FATAL_ERROR "TYPE must be set") + endif() + + # A package might be looked up more than once, make sure to record it once. + get_property(already_recorded GLOBAL PROPERTY + _qt_internal_sbom_recorded_system_library_target_${target}) + + if(already_recorded) + return() + endif() + + set_property(GLOBAL PROPERTY + _qt_internal_sbom_recorded_system_library_target_${target} TRUE) + + # Defer spdx id creation until _qt_internal_sbom_begin_project is called, so we know the + # project name. The project name is used in the package infix generation of the system library, + # but _qt_internal_sbom_record_system_library_usage might be called before sbom generation + # has started, e.g. during _qt_internal_find_third_party_dependencies. + set(spdx_options + ${target} + TYPE "${arg_TYPE}" + PACKAGE_NAME "${arg_FRIENDLY_PACKAGE_NAME}" + ) + + get_cmake_property(sbom_repo_begin_called _qt_internal_sbom_repo_begin_called) + if(sbom_repo_begin_called AND TARGET "${target}") + _qt_internal_sbom_record_system_library_spdx_id(${target} ${spdx_options}) + else() + set_property(GLOBAL PROPERTY + _qt_internal_sbom_recorded_system_library_spdx_options_${target} "${spdx_options}") + endif() + + # Defer sbom info creation until we detect usage of the system library (whether the library is + # linked into any other target). + set_property(GLOBAL APPEND PROPERTY + _qt_internal_sbom_recorded_system_library_targets "${target}") + set_property(GLOBAL PROPERTY + _qt_internal_sbom_recorded_system_library_options_${target} "${ARGN}") +endfunction() + +# Helper to record spdx ids of all system library targets that were found so far. +function(_qt_internal_sbom_record_system_library_spdx_ids) + get_property(recorded_targets GLOBAL PROPERTY _qt_internal_sbom_recorded_system_library_targets) + + if(NOT recorded_targets) + return() + endif() + + foreach(target IN LISTS recorded_targets) + get_property(args GLOBAL PROPERTY + _qt_internal_sbom_recorded_system_library_spdx_options_${target}) + + # qt_find_package PROVIDED_TARGETS might refer to non-existent targets in certain cases, + # like zstd::libzstd_shared for qt_find_package(WrapZSTD), because we are not sure what + # kind of zstd build was done. Make sure to check if the target exists before recording it. + if(TARGET "${target}") + set(target_unaliased "${target}") + get_target_property(aliased_target "${target}" ALIASED_TARGET) + if(aliased_target) + set(target_unaliased ${aliased_target}) + endif() + + _qt_internal_sbom_record_system_library_spdx_id(${target_unaliased} ${args}) + else() + message(DEBUG + "Skipping recording system library for SBOM because target does not exist: " + " ${target}") + endif() + endforeach() +endfunction() + +# Helper to record the spdx id of a system library target. +function(_qt_internal_sbom_record_system_library_spdx_id target) + # Save the spdx id before the sbom info is added, so we can refer to it in relationships. + _qt_internal_sbom_record_target_spdx_id(${ARGN} OUT_VAR package_spdx_id) + + if(NOT package_spdx_id) + message(FATAL_ERROR "Could not generate spdx id for system library target: ${target}") + endif() + + set_property(GLOBAL PROPERTY + _qt_internal_sbom_recorded_system_library_package_${target} "${package_spdx_id}") +endfunction() + +# Goes through the list of consumed system libraries (those that were linked in) and creates +# sbom packages for them. +# Uses information from recorded system libraries (calls to qt_find_package). +function(_qt_internal_sbom_add_recorded_system_libraries) + get_property(recorded_targets GLOBAL PROPERTY _qt_internal_sbom_recorded_system_library_targets) + get_property(consumed_targets GLOBAL PROPERTY _qt_internal_sbom_consumed_system_library_targets) + + set(unconsumed_targets "${recorded_targets}") + set(generated_package_names "") + + foreach(target IN LISTS consumed_targets) + # Some system targets like qtspeech SpeechDispatcher::SpeechDispatcher might be aliased, + # and we can't set properties on them, so unalias the target name. + set(target_original "${target}") + get_target_property(aliased_target "${target}" ALIASED_TARGET) + if(aliased_target) + set(target ${aliased_target}) + endif() + + get_property(args GLOBAL PROPERTY + _qt_internal_sbom_recorded_system_library_options_${target}) + get_property(package_name GLOBAL PROPERTY + _qt_internal_sbom_recorded_system_library_package_${target}) + + set_property(GLOBAL PROPERTY _qt_internal_sbom_recorded_system_library_target_${target} "") + set_property(GLOBAL PROPERTY _qt_internal_sbom_recorded_system_library_options_${target} "") + set_property(GLOBAL PROPERTY _qt_internal_sbom_recorded_system_library_package_${target} "") + + # Guard against generating a package multiple times. Can happen when multiple targets belong + # to the same package. + if(sbom_generated_${package_name}) + continue() + endif() + + # Automatic system library sbom recording happens at project root source dir scope, which + # means it might accidentally pick up a qt_attribution.json file from the project root, + # that is not intended to be use for system libraries. + # For now, explicitly disable using the root attribution file. + list(APPEND args NO_CURRENT_DIR_ATTRIBUTION) + + list(APPEND generated_package_names "${package_name}") + set(sbom_generated_${package_name} TRUE) + + _qt_internal_extend_sbom(${target} ${args}) + _qt_internal_finalize_sbom(${target}) + + list(REMOVE_ITEM unconsumed_targets "${target_original}") + endforeach() + + message(DEBUG "System libraries that were recorded, but not consumed: ${unconsumed_targets}") + message(DEBUG "Generated SBOMs for the following system packages: ${generated_package_names}") + + # Clean up, before configuring next repo project. + set_property(GLOBAL PROPERTY _qt_internal_sbom_consumed_system_library_targets "") + set_property(GLOBAL PROPERTY _qt_internal_sbom_recorded_system_library_targets "") +endfunction() + +# Helper to add sbom information for a possibly non-existing target. +# This will defer the actual sbom generation until the end of the directory scope, unless +# immediate finalization was requested. +function(_qt_internal_add_sbom target) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + set(opt_args + IMMEDIATE_FINALIZATION + ) + set(single_args + TYPE + FRIENDLY_PACKAGE_NAME + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + # No validation on purpose, the other options will be validated later. + + set(forward_args ${ARGN}) + + # Remove the IMMEDIATE_FINALIZATION from the forwarded args. + list(REMOVE_ITEM forward_args IMMEDIATE_FINALIZATION) + + # If a target doesn't exist we create it. + if(NOT TARGET "${target}") + _qt_internal_create_sbom_target("${target}" ${forward_args}) + endif() + + # Save the passed options. + _qt_internal_extend_sbom("${target}" ${forward_args}) + + # Defer finalization. In case it was already deferred, it will be a no-op. + # Some targets need immediate finalization, like the PlatformInternal ones, because otherwise + # they would be finalized after the sbom was already generated. + set(immediate_finalization "") + if(arg_IMMEDIATE_FINALIZATION) + set(immediate_finalization IMMEDIATE_FINALIZATION) + endif() + _qt_internal_defer_sbom_finalization("${target}" ${immediate_finalization}) +endfunction() + +# Helper to add custom sbom information for some kind of dependency that is not backed by an +# existing target. +# Useful for cases like 3rd party dependencies not represented by an already existing imported +# target, or for 3rd party sources that get compiled into a regular Qt target (PCRE sources compiled +# into Bootstrap). +function(_qt_internal_create_sbom_target target) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + set(opt_args "") + set(single_args + TYPE + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + # No validation on purpose, the other options will be validated later. + + if(TARGET "${target}") + message(FATAL_ERROR "The target ${target} already exists.") + endif() + + add_library("${target}" INTERFACE IMPORTED) + set_target_properties(${target} PROPERTIES + _qt_sbom_is_custom_sbom_target "TRUE" + IMPORTED_GLOBAL TRUE + ) + + if(NOT arg_TYPE) + message(FATAL_ERROR "No SBOM TYPE option was provided for target: ${target}") + endif() +endfunction() + +# Helper to add additional sbom information for an existing target. +# Just appends the options to the target's sbom args property, which will will be evaluated +# during finalization. +function(_qt_internal_extend_sbom target) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + if(NOT TARGET "${target}") + message(FATAL_ERROR + "The target ${target} does not exist, use qt_internal_add_sbom to create " + "a target first, or call the function on any other exsiting target.") + endif() + + set(opt_args "") + set(single_args + TYPE + FRIENDLY_PACKAGE_NAME + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + # No validation on purpose, the other options will be validated later. + + # Make sure a spdx id is recorded for the target right now, so it is "known" when handling + # relationships for other targets, even if the target was not yet finalized. + if(arg_TYPE) + # Friendly package name is allowed to be empty. + _qt_internal_sbom_record_target_spdx_id(${target} + TYPE "${arg_TYPE}" + PACKAGE_NAME "${arg_FRIENDLY_PACKAGE_NAME}" + ) + endif() + + set_property(TARGET ${target} APPEND PROPERTY _qt_finalize_sbom_args "${ARGN}") +endfunction() + +# Helper to add additional sbom information to targets created by qt_find_package. +# If the package was not found, and the targets were not created, the functions does nothing. +# This is similar to _qt_internal_extend_sbom, but is explicit in the fact that the targets might +# not exist. +function(_qt_find_package_extend_sbom) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + _qt_internal_get_sbom_add_target_options(sbom_opt_args sbom_single_args sbom_multi_args) + + set(opt_args + ${sbom_opt_args} + ) + set(single_args + ${sbom_single_args} + ) + set(multi_args + TARGETS + ${sbom_multi_args} + ) + + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + # Make sure not to forward TARGETS. + set(sbom_args "") + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + ${sbom_opt_args} + FORWARD_SINGLE + ${sbom_single_args} + FORWARD_MULTI + ${sbom_multi_args} + ) + + foreach(target IN LISTS arg_TARGETS) + if(TARGET "${target}") + _qt_internal_extend_sbom("${target}" ${sbom_args}) + else() + message(DEBUG "The target ${target} does not exist, skipping extending the sbom info.") + endif() + endforeach() +endfunction() + +# Helper to defer adding sbom information for a target, at the end of the directory scope. +function(_qt_internal_defer_sbom_finalization target) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + set(opt_args + IMMEDIATE_FINALIZATION + ) + set(single_args "") + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + get_target_property(sbom_finalization_requested ${target} _qt_sbom_finalization_requested) + if(sbom_finalization_requested) + # Already requested, nothing to do. + return() + endif() + set_target_properties(${target} PROPERTIES _qt_sbom_finalization_requested TRUE) + + _qt_internal_append_to_cmake_property_without_duplicates( + _qt_internal_sbom_targets_waiting_for_finalization + "${target}" + ) + + set(func "_qt_internal_finalize_sbom") + + if(arg_IMMEDIATE_FINALIZATION) + _qt_internal_finalize_sbom(${target}) + elseif(QT_BUILDING_QT) + qt_add_list_file_finalizer("${func}" "${target}") + elseif(CMAKE_VERSION VERSION_GREATER_EQUAL "3.19") + cmake_language(EVAL CODE "cmake_language(DEFER CALL \"${func}\" \"${target}\")") + else() + message(FATAL_ERROR "Defer adding a sbom target requires CMake version 3.19") + endif() +endfunction() + +# Finalizer to add sbom information for the target. +# Expects the target to exist. +function(_qt_internal_finalize_sbom target) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + get_target_property(sbom_finalization_done ${target} _qt_sbom_finalization_done) + if(sbom_finalization_done) + # Already done, nothing to do. + return() + endif() + set_target_properties(${target} PROPERTIES _qt_sbom_finalization_done TRUE) + + get_target_property(sbom_args ${target} _qt_finalize_sbom_args) + if(NOT sbom_args) + set(sbom_args "") + endif() + _qt_internal_sbom_add_target(${target} ${sbom_args}) +endfunction() + +# Extends the list of targets that are considered dependencies for target. +function(_qt_internal_extend_sbom_dependencies target) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + set(opt_args "") + set(single_args "") + set(multi_args + SBOM_DEPENDENCIES + ) + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT TARGET "${target}") + message(FATAL_ERROR "The target ${target} does not exist.") + endif() + + _qt_internal_append_to_target_property_without_duplicates(${target} + _qt_extend_target_sbom_dependencies "${arg_SBOM_DEPENDENCIES}" + ) +endfunction() + +# Handles attribution information for a target. +# +# If CREATE_SBOM_FOR_EACH_ATTRIBUTION is set, a separate sbom target is created for each parsed +# attribution entry, and the new targets are added as dependencies to the parent target. +# +# If CREATE_SBOM_FOR_EACH_ATTRIBUTION is not set, the information read from the first attribution +# entry is added directly to the parent target, aka the the values are propagated to the outer +# function scope to be read.. The rest of the attribution entries are created as separate targets +# and added as dependencies, as if the option was passed. +# +# Handles multiple attribution files and entries within a file. +# Attribution files can be specified either via directories and direct file paths. +# If ATTRIBUTION_ENTRY_INDEX is set, only that specific attribution entry will be processed +# from the given attribution file. +function(_qt_internal_sbom_handle_qt_attribution_files out_prefix_outer) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + if(CMAKE_VERSION LESS_EQUAL "3.19") + message(DEBUG "CMake version is too low, can't parse attribution.json file.") + return() + endif() + + set(opt_args + CREATE_SBOM_FOR_EACH_ATTRIBUTION + ) + set(single_args + PARENT_TARGET + ) + set(multi_args "") + + _qt_internal_get_sbom_specific_options(sbom_opt_args sbom_single_args sbom_multi_args) + list(APPEND opt_args ${sbom_opt_args}) + list(APPEND single_args ${sbom_single_args}) + list(APPEND multi_args ${sbom_multi_args}) + + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(attribution_files "") + set(attribution_file_count 0) + + foreach(attribution_file_path IN LISTS arg_ATTRIBUTION_FILE_PATHS) + get_filename_component(real_path "${attribution_file_path}" REALPATH) + list(APPEND attribution_files "${real_path}") + math(EXPR attribution_file_count "${attribution_file_count} + 1") + endforeach() + + foreach(attribution_file_dir_path IN LISTS arg_ATTRIBUTION_FILE_DIR_PATHS) + get_filename_component(real_path + "${attribution_file_dir_path}/qt_attribution.json" REALPATH) + list(APPEND attribution_files "${real_path}") + math(EXPR attribution_file_count "${attribution_file_count} + 1") + endforeach() + + # If CREATE_SBOM_FOR_EACH_ATTRIBUTION is set, that means the parent target was a qt entity, + # and not a 3rd party library. + # In which case we don't want to proagate options like CPE to the child attribution targets, + # because the CPE is meant for the parent target. + set(propagate_sbom_options_to_new_attribution_targets TRUE) + if(arg_CREATE_SBOM_FOR_EACH_ATTRIBUTION) + set(propagate_sbom_options_to_new_attribution_targets FALSE) + if(NOT arg_PARENT_TARGET) + message(FATAL_ERROR "PARENT_TARGET must be set") + endif() + endif() + + if(arg_ATTRIBUTION_ENTRY_INDEX AND attribution_file_count GREATER 1) + message(FATAL_ERROR + "ATTRIBUTION_ENTRY_INDEX should only be set if a single attribution " + "file is specified." + ) + endif() + + set(file_index 0) + set(first_attribution_processed FALSE) + foreach(attribution_file_path IN LISTS attribution_files) + # Collect all processed attribution files to later create a configure-time dependency on + # them so that the SBOM is regenerated (and CMake is re-ran) if they are modified. + set_property(GLOBAL APPEND PROPERTY _qt_internal_project_attribution_files + "${attribution_file_path}") + + # Set a unique out_prefix that will not overlap when multiple entries are processed. + set(out_prefix_file "${out_prefix_outer}_${file_index}") + + # Get the number of entries in the attribution file. + _qt_internal_sbom_read_qt_attribution(${out_prefix_file} + GET_ATTRIBUTION_ENTRY_COUNT + OUT_VAR_VALUE attribution_entry_count + FILE_PATH "${attribution_file_path}" + ) + + # If a specific entry was specified, we will only process it from the file. + if(NOT "${arg_ATTRIBUTION_ENTRY_INDEX}" STREQUAL "") + set(entry_index ${arg_ATTRIBUTION_ENTRY_INDEX}) + else() + set(entry_index 0) + endif() + + # Go through each entry in the attribution file. + while("${entry_index}" LESS "${${out_prefix_file}_attribution_entry_count}") + # If this is the first entry to be processed, or if CREATE_SBOM_FOR_EACH_ATTRIBUTION + # is not set, we read the attribution file entry directly, and propagate the values + # to the parent scope. + if(NOT first_attribution_processed AND NOT arg_CREATE_SBOM_FOR_EACH_ATTRIBUTION) + # Set a prefix without indices, so that the parent scope add_sbom call can + # refer to the values directly with the outer prefix, without any index infix. + set(out_prefix "${out_prefix_outer}") + + _qt_internal_sbom_read_qt_attribution(${out_prefix} + GET_DEFAULT_KEYS + ENTRY_INDEX "${entry_index}" + OUT_VAR_ASSIGNED_VARIABLE_NAMES variable_names + FILE_PATH "${attribution_file_path}" + ) + + # Propagate the values to the outer scope. + foreach(variable_name IN LISTS variable_names) + set(${out_prefix}_${variable_name} "${${out_prefix}_${variable_name}}" + PARENT_SCOPE) + endforeach() + + get_filename_component(relative_attribution_file_path + "${attribution_file_path}" REALPATH) + + set(${out_prefix}_chosen_attribution_file_path "${relative_attribution_file_path}" + PARENT_SCOPE) + set(${out_prefix}_chosen_attribution_entry_index "${entry_index}" + PARENT_SCOPE) + + set(first_attribution_processed TRUE) + if(NOT "${arg_ATTRIBUTION_ENTRY_INDEX}" STREQUAL "") + # We had a specific index to process, so break right after processing it. + break() + endif() + else() + # We are processing the second or later entry, or CREATE_SBOM_FOR_EACH_ATTRIBUTION + # was set. Instead of directly reading all the keys from the attribution file, + # we get the Id, and create a new sbom target for the entry. + # That will recursively call this function with a specific attribution file path + # and index, to process the specific entry. + + set(out_prefix "${out_prefix_outer}_${file_index}_${entry_index}") + + # Get the attribution id. + _qt_internal_sbom_read_qt_attribution(${out_prefix} + GET_KEY + KEY Id + OUT_VAR_VALUE attribution_id + ENTRY_INDEX "${entry_index}" + FILE_PATH "${attribution_file_path}" + ) + + # If no Id was retrieved, just add a numeric one, to make the sbom target + # unique. + set(attribution_target "${arg_PARENT_TARGET}_Attribution_") + if(NOT ${out_prefix}_attribution_id) + string(APPEND attribution_target "${file_index}_${entry_index}") + else() + string(APPEND attribution_target "${${out_prefix}_attribution_id}") + endif() + + set(sbom_args "") + + if(propagate_sbom_options_to_new_attribution_targets) + # Filter out the attributtion options, they will be passed mnaually + # depending on which file and index is currently being processed. + _qt_internal_get_sbom_specific_options( + sbom_opt_args sbom_single_args sbom_multi_args) + list(REMOVE_ITEM sbom_opt_args NO_CURRENT_DIR_ATTRIBUTION) + list(REMOVE_ITEM sbom_single_args ATTRIBUTION_ENTRY_INDEX) + list(REMOVE_ITEM sbom_multi_args + ATTRIBUTION_FILE_PATHS + ATTRIBUTION_FILE_DIR_PATHS + ) + + # Also filter out the FRIENDLY_PACKAGE_NAME option, otherwise we'd try to + # file(GENERATE) multiple times with the same file name, but different content. + list(REMOVE_ITEM sbom_single_args FRIENDLY_PACKAGE_NAME) + + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + ${sbom_opt_args} + FORWARD_SINGLE + ${sbom_single_args} + FORWARD_MULTI + ${sbom_multi_args} + ) + endif() + + # Create another sbom target with the id as a hint for the target name, + # the attribution file passed, and make the new target a dependency of the + # parent one. + _qt_internal_add_sbom("${attribution_target}" + IMMEDIATE_FINALIZATION + TYPE QT_THIRD_PARTY_SOURCES + ATTRIBUTION_FILE_PATHS "${attribution_file_path}" + ATTRIBUTION_ENTRY_INDEX "${entry_index}" + NO_CURRENT_DIR_ATTRIBUTION + ${sbom_args} + ) + + _qt_internal_extend_sbom_dependencies(${arg_PARENT_TARGET} + SBOM_DEPENDENCIES ${attribution_target} + ) + endif() + + math(EXPR entry_index "${entry_index} + 1") + endwhile() + + math(EXPR file_index "${file_index} + 1") + endforeach() +endfunction() + +# Helper to parse a qt_attribution.json file and do various operations: +# - GET_DEFAULT_KEYS extracts the license id, copyrights, version, etc. +# - GET_KEY extracts a single given json key's value, as specified with KEY and saved into +# OUT_VAR_VALUE +# - GET_ATTRIBUTION_ENTRY_COUNT returns the number of entries in the json file, set in +# OUT_VAR_VALUE +# +# ENTRY_INDEX can be used to specify the array index to select a specific entry in the json file. +# +# Any retrieved value is set in the outer scope. +# The variables are prefixed with ${out_prefix}. +# OUT_VAR_ASSIGNED_VARIABLE_NAMES contains the list of variables set in the parent scope, the +# variables names in this list are not prefixed with ${out_prefix}. +# +# Requires cmake 3.19 for json parsing. +function(_qt_internal_sbom_read_qt_attribution out_prefix) + if(NOT QT_GENERATE_SBOM) + return() + endif() + + if(CMAKE_VERSION LESS_EQUAL "3.19") + message(DEBUG "CMake version is too low, can't parse attribution.json file.") + return() + endif() + + set(opt_args + GET_DEFAULT_KEYS + GET_KEY + GET_ATTRIBUTION_ENTRY_COUNT + ) + set(single_args + FILE_PATH + KEY + ENTRY_INDEX + OUT_VAR_VALUE + OUT_VAR_ASSIGNED_VARIABLE_NAMES + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(file_path "${arg_FILE_PATH}") + + if(NOT file_path) + message(FATAL_ERROR "qt attribution file path not given") + endif() + + file(READ "${file_path}" contents) + if(NOT contents) + message(FATAL_ERROR "qt attribution file is empty: ${file_path}") + endif() + + if(NOT arg_GET_DEFAULT_KEYS AND NOT arg_GET_KEY AND NOT arg_GET_ATTRIBUTION_ENTRY_COUNT) + message(FATAL_ERROR + "No valid operation specified to _qt_internal_sbom_read_qt_attribution call.") + endif() + + if(arg_GET_KEY) + if(NOT arg_KEY) + message(FATAL_ERROR "KEY must be set") + endif() + if(NOT arg_OUT_VAR_VALUE) + message(FATAL_ERROR "OUT_VAR_VALUE must be set") + endif() + endif() + + get_filename_component(attribution_file_dir "${file_path}" DIRECTORY) + + # Parse the json file. + # The first element might be an array, or an object. We need to detect which one. + # Do that by trying to query index 0 of the potential root array. + # If the index is found, that means the root is an array, and elem_error is set to NOTFOUND, + # because there was no error. + # Otherwise elem_error will be something like 'member '0' not found', and we can assume the + # root is an object. + string(JSON first_elem_type ERROR_VARIABLE elem_error TYPE "${contents}" 0) + if(elem_error STREQUAL "NOTFOUND") + # Root is an array. The attribution file might contain multiple entries. + # Pick the first one if no specific index was specified, otherwise use the given index. + if(NOT "${arg_ENTRY_INDEX}" STREQUAL "") + set(indices "${arg_ENTRY_INDEX}") + else() + set(indices "0") + endif() + set(is_array TRUE) + else() + # Root is an object, not an array, which means the file has a single entry. + set(indices "") + set(is_array FALSE) + endif() + + set(variable_names "") + + if(arg_GET_KEY) + _qt_internal_sbom_get_attribution_key(${arg_KEY} ${arg_OUT_VAR_VALUE} ${out_prefix}) + endif() + + if(arg_GET_ATTRIBUTION_ENTRY_COUNT) + if(NOT arg_OUT_VAR_VALUE) + message(FATAL_ERROR "OUT_VAR_VALUE must be set") + endif() + + if(is_array) + string(JSON attribution_entry_count ERROR_VARIABLE elem_error LENGTH "${contents}") + # There was an error getting the length of the array, so we assume it's empty. + if(NOT elem_error STREQUAL "NOTFOUND") + set(attribution_entry_count 0) + endif() + else() + set(attribution_entry_count 1) + endif() + + set(${out_prefix}_${arg_OUT_VAR_VALUE} "${attribution_entry_count}" PARENT_SCOPE) + endif() + + if(arg_GET_DEFAULT_KEYS) + # Some calls are currently commented out, to save on json parsing time because we don't have + # a usage for them yet. + # _qt_internal_sbom_get_attribution_key(License license) + _qt_internal_sbom_get_attribution_key(LicenseId license_id "${out_prefix}") + _qt_internal_sbom_get_attribution_key(Version version "${out_prefix}") + _qt_internal_sbom_get_attribution_key(Homepage homepage "${out_prefix}") + _qt_internal_sbom_get_attribution_key(Name attribution_name "${out_prefix}") + _qt_internal_sbom_get_attribution_key(Description description "${out_prefix}") + _qt_internal_sbom_get_attribution_key(QtUsage qt_usage "${out_prefix}") + _qt_internal_sbom_get_attribution_key(DownloadLocation download_location "${out_prefix}") + _qt_internal_sbom_get_attribution_key(Copyright copyrights "${out_prefix}" IS_MULTI_VALUE) + _qt_internal_sbom_get_attribution_key(CopyrightFile copyright_file "${out_prefix}") + _qt_internal_sbom_get_attribution_key(PURL purls "${out_prefix}" IS_MULTI_VALUE) + _qt_internal_sbom_get_attribution_key(CPE cpes "${out_prefix}" IS_MULTI_VALUE) + + # Some attribution files contain a copyright file that contains the actual list of + # copyrights. Read it and use it. + set(copyright_file_path "${attribution_file_dir}/${copyright_file}") + get_filename_component(copyright_file_path "${copyright_file_path}" REALPATH) + if(NOT copyrights AND copyright_file AND EXISTS "${copyright_file_path}") + file(READ "${copyright_file_path}" copyright_contents) + if(copyright_contents) + set(copyright_contents "${copyright_contents}") + set(copyrights "${copyright_contents}") + set(${out_prefix}_copyrights "${copyright_contents}" PARENT_SCOPE) + list(APPEND variable_names "copyrights") + endif() + endif() + endif() + + if(arg_OUT_VAR_ASSIGNED_VARIABLE_NAMES) + set(${arg_OUT_VAR_ASSIGNED_VARIABLE_NAMES} "${variable_names}" PARENT_SCOPE) + endif() +endfunction() + +# Extracts a string or an array of strings from a json index path, depending on the extracted value +# type. +# +# Given the 'contents' of the whole json document and the EXTRACTED_VALUE of a json key specified +# by the INDICES path, it tries to determine whether the value is an array, in which case the array +# is converted to a cmake list and assigned to ${out_var} in the parent scope. +# Otherwise the function assumes the EXTRACTED_VALUE was not an array, and just assigns the value +# of EXTRACTED_VALUE to ${out_var} +function(_qt_internal_sbom_handle_attribution_json_array contents) + set(opt_args "") + set(single_args + EXTRACTED_VALUE + OUT_VAR + ) + set(multi_args + INDICES + ) + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + # Write the original value to the parent scope, in case it was not an array. + set(${arg_OUT_VAR} "${arg_EXTRACTED_VALUE}" PARENT_SCOPE) + + if(NOT arg_EXTRACTED_VALUE) + return() + endif() + + string(JSON element_type TYPE "${contents}" ${arg_INDICES}) + + if(NOT element_type STREQUAL "ARRAY") + return() + endif() + + set(json_array "${arg_EXTRACTED_VALUE}") + string(JSON array_len LENGTH "${json_array}") + + set(value_list "") + + math(EXPR array_len "${array_len} - 1") + foreach(index RANGE 0 "${array_len}") + string(JSON value GET "${json_array}" ${index}) + if(value) + list(APPEND value_list "${value}") + endif() + endforeach() + + if(value_list) + set(${arg_OUT_VAR} "${value_list}" PARENT_SCOPE) + endif() +endfunction() + +# Escapes various characters in json content, so that the generate cmake code to append the content +# to the spdx document is syntactically valid. +function(_qt_internal_sbom_escape_json_content content out_var) + # Escape backslashes + string(REPLACE "\\" "\\\\" escaped_content "${content}") + + # Escape quotes + string(REPLACE "\"" "\\\"" escaped_content "${escaped_content}") + + set(${out_var} "${escaped_content}" PARENT_SCOPE) +endfunction() + +# This macro reads a json key from a qt_attribution.json file, and assigns the escaped value to +# out_var. +# Also appends the name of the out_var to the parent scope 'variable_names' var. +# +# Expects 'contents' and 'indices' to already be set in the calling scope. +# +# If IS_MULTI_VALUE is set, handles the key as if it contained an array of +# values, by converting the array of json values to a cmake list. +macro(_qt_internal_sbom_get_attribution_key json_key out_var out_prefix) + cmake_parse_arguments(arg "IS_MULTI_VALUE" "" "" ${ARGN}) + + string(JSON "${out_var}" ERROR_VARIABLE get_error GET "${contents}" ${indices} "${json_key}") + if(NOT "${${out_var}}" STREQUAL "" AND NOT get_error) + set(extracted_value "${${out_var}}") + + if(arg_IS_MULTI_VALUE) + _qt_internal_sbom_handle_attribution_json_array("${contents}" + EXTRACTED_VALUE "${extracted_value}" + INDICES ${indices} ${json_key} + OUT_VAR value_list + ) + if(value_list) + set(extracted_value "${value_list}") + endif() + endif() + + _qt_internal_sbom_escape_json_content("${extracted_value}" escaped_content) + + set(${out_prefix}_${out_var} "${escaped_content}" PARENT_SCOPE) + list(APPEND variable_names "${out_var}") + + unset(extracted_value) + unset(escaped_content) + unset(value_list) + endif() +endmacro() + +# Set sbom project name for the root project. +function(_qt_internal_sbom_set_root_project_name project_name) + set_property(GLOBAL PROPERTY _qt_internal_sbom_repo_project_name "${project_name}") +endfunction() + +# Get repo project_name spdx id reference, needs to start with Package- to be NTIA compliant. +function(_qt_internal_sbom_get_root_project_name_for_spdx_id out_var) + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + set(sbom_repo_project_name "Package-${repo_project_name_lowercase}") + set(${out_var} "${sbom_repo_project_name}" PARENT_SCOPE) +endfunction() + +# Just a lower case sbom project name. +function(_qt_internal_sbom_get_root_project_name_lower_case out_var) + get_cmake_property(project_name _qt_internal_sbom_repo_project_name) + + if(NOT project_name) + message(FATAL_ERROR "No SBOM project name was set.") + endif() + + string(TOLOWER "${project_name}" repo_project_name_lowercase) + set(${out_var} "${repo_project_name_lowercase}" PARENT_SCOPE) +endfunction() + +# Get a spdx id to reference an external document. +function(_qt_internal_sbom_get_external_document_ref_spdx_id repo_name out_var) + set(${out_var} "DocumentRef-${repo_name}" PARENT_SCOPE) +endfunction() + +# Sanitize a given value to be used as a SPDX id. +function(_qt_internal_sbom_get_sanitized_spdx_id out_var hint) + # Only allow alphanumeric characters and dashes. + string(REGEX REPLACE "[^a-zA-Z0-9]+" "-" spdx_id "${hint}") + + # Remove all trailing dashes. + string(REGEX REPLACE "-+$" "" spdx_id "${spdx_id}") + + set(${out_var} "${spdx_id}" PARENT_SCOPE) +endfunction() + +# Generates a spdx id for a target and saves it its properties. +function(_qt_internal_sbom_record_target_spdx_id target) + set(opt_args "") + set(single_args + PACKAGE_NAME + TYPE + OUT_VAR + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + _qt_internal_sbom_get_spdx_id_for_target("${target}" spdx_id) + + if(spdx_id) + # Return early if the target was already recorded and has a spdx id. + if(arg_OUT_VAR) + set(${arg_OUT_VAR} "${spdx_id}" PARENT_SCOPE) + endif() + return() + endif() + + if(arg_PACKAGE_NAME) + set(package_name_for_spdx_id "${arg_PACKAGE_NAME}") + else() + set(package_name_for_spdx_id "${target}") + endif() + + _qt_internal_sbom_generate_target_package_spdx_id(package_spdx_id + TYPE "${arg_TYPE}" + PACKAGE_NAME "${package_name_for_spdx_id}" + ) + _qt_internal_sbom_save_spdx_id_for_target("${target}" "${package_spdx_id}") + + _qt_internal_sbom_is_qt_entity_type("${arg_TYPE}" is_qt_entity_type) + _qt_internal_sbom_save_spdx_id_for_qt_entity_type( + "${target}" "${is_qt_entity_type}" "${package_spdx_id}") + + if(arg_OUT_VAR) + set(${arg_OUT_VAR} "${package_spdx_id}" PARENT_SCOPE) + endif() +endfunction() + +# Generates a sanitized spdx id for a target (package) of a specific type. +function(_qt_internal_sbom_generate_target_package_spdx_id out_var) + set(opt_args "") + set(single_args + PACKAGE_NAME + TYPE + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_PACKAGE_NAME) + message(FATAL_ERROR "PACKAGE_NAME must be set") + endif() + if(NOT arg_TYPE) + message(FATAL_ERROR "TYPE must be set") + endif() + + _qt_internal_sbom_get_root_project_name_for_spdx_id(repo_project_name_spdx_id) + _qt_internal_sbom_get_package_infix("${arg_TYPE}" package_infix) + + _qt_internal_sbom_get_sanitized_spdx_id(spdx_id + "SPDXRef-${repo_project_name_spdx_id}-${package_infix}-${arg_PACKAGE_NAME}") + + set(${out_var} "${spdx_id}" PARENT_SCOPE) +endfunction() + +# Save a spdx id for a target inside its target properties. +# Also saves the repo document namespace and relative installed repo document path. +# These are used when generating a SPDX external document reference for exported targets, to +# include them in relationships. +function(_qt_internal_sbom_save_spdx_id_for_target target spdx_id) + message(DEBUG "Saving spdx id for target ${target}: ${spdx_id}") + + set(target_unaliased "${target}") + get_target_property(aliased_target "${target}" ALIASED_TARGET) + if(aliased_target) + set(target_unaliased ${aliased_target}) + endif() + + set_target_properties(${target_unaliased} PROPERTIES + _qt_sbom_spdx_id "${spdx_id}") + + # Retrieve repo specific properties. + get_property(repo_document_namespace + GLOBAL PROPERTY _qt_internal_sbom_repo_document_namespace) + + get_property(relative_installed_repo_document_path + GLOBAL PROPERTY _qt_internal_sbom_relative_installed_repo_document_path) + + get_property(project_name_lowercase + GLOBAL PROPERTY _qt_internal_sbom_repo_project_name_lowercase) + + # And save them on the target. + set_property(TARGET ${target_unaliased} PROPERTY + _qt_sbom_spdx_repo_document_namespace + "${repo_document_namespace}") + + set_property(TARGET ${target_unaliased} PROPERTY + _qt_sbom_spdx_relative_installed_repo_document_path + "${relative_installed_repo_document_path}") + + set_property(TARGET ${target_unaliased} PROPERTY + _qt_sbom_spdx_repo_project_name_lowercase + "${project_name_lowercase}") + + # Export the properties, so they can be queried by other repos. + # We also do it for versionless targets. + set(export_properties + _qt_sbom_spdx_id + _qt_sbom_spdx_repo_document_namespace + _qt_sbom_spdx_relative_installed_repo_document_path + _qt_sbom_spdx_repo_project_name_lowercase + ) + set_property(TARGET "${target_unaliased}" APPEND PROPERTY + EXPORT_PROPERTIES "${export_properties}") +endfunction() + +# Returns whether the given sbom type is considered to be a Qt type like a module or a tool. +function(_qt_internal_sbom_is_qt_entity_type sbom_type out_var) + set(qt_entity_types + QT_MODULE + QT_PLUGIN + QT_APP + QT_TOOL + ) + + set(is_qt_entity_type FALSE) + if(sbom_type IN_LIST qt_entity_types) + set(is_qt_entity_type TRUE) + endif() + + set(${out_var} ${is_qt_entity_type} PARENT_SCOPE) +endfunction() + +# Returns whether the given sbom type is considered to a Qt 3rd party entity type. +function(_qt_internal_sbom_is_qt_3rd_party_entity_type sbom_type out_var) + set(entity_types + QT_THIRD_PARTY_MODULE + QT_THIRD_PARTY_SOURCES + ) + + set(is_qt_third_party_entity_type FALSE) + if(sbom_type IN_LIST entity_types) + set(is_qt_third_party_entity_type TRUE) + endif() + + set(${out_var} ${is_qt_third_party_entity_type} PARENT_SCOPE) +endfunction() + +# Save a spdx id for all known related target names of a given Qt target. +# Related being the namespaced and versionless variants of a Qt target. +# All the related targets will contain the same spdx id. +# So Core, CorePrivate, Qt6::Core, Qt6::CorePrivate, Qt::Core, Qt::CorePrivate will all be +# referred to by the same spdx id. +function(_qt_internal_sbom_save_spdx_id_for_qt_entity_type target is_qt_entity_type package_spdx_id) + # Assign the spdx id to all known related target names of given the given Qt target. + set(target_names "") + + if(is_qt_entity_type) + set(namespaced_target "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + set(namespaced_private_target "${QT_CMAKE_EXPORT_NAMESPACE}::${target}Private") + set(versionless_target "Qt::${target}") + set(versionless_private_target "Qt::${target}Private") + + list(APPEND target_names + namespaced_target + namespaced_private_target + versionless_target + versionless_private_target + ) + endif() + + foreach(target_name IN LISTS ${target_names}) + if(TARGET "${target_name}") + _qt_internal_sbom_save_spdx_id_for_target("${target_name}" "${package_spdx_id}") + endif() + endforeach() +endfunction() + +# Retrieves a saved spdx id from the target. Might be empty. +function(_qt_internal_sbom_get_spdx_id_for_target target out_var) + get_target_property(spdx_id ${target} _qt_sbom_spdx_id) + set(${out_var} "${spdx_id}" PARENT_SCOPE) +endfunction() + +# Get a sanitized spdx id for a file. +# For consistency, we prefix the id with SPDXRef-PackagedFile-. This is not a requirement. +function(_qt_internal_sbom_get_file_spdx_id target out_var) + _qt_internal_sbom_get_sanitized_spdx_id(spdx_id "SPDXRef-PackagedFile-${target}") + set(${out_var} "${spdx_id}" PARENT_SCOPE) +endfunction() + +# Returns a package infix for a given target sbom type to be used in spdx package id generation. +function(_qt_internal_sbom_get_package_infix type out_infix) + if(type STREQUAL "QT_MODULE") + set(package_infix "qt-module") + elseif(type STREQUAL "QT_PLUGIN") + set(package_infix "qt-plugin") + elseif(type STREQUAL "QML_PLUGIN") + set(package_infix "qt-qml-plugin") # not used at the moment + elseif(type STREQUAL "QT_TOOL") + set(package_infix "qt-tool") + elseif(type STREQUAL "QT_APP") + set(package_infix "qt-app") + elseif(type STREQUAL "QT_THIRD_PARTY_MODULE") + set(package_infix "qt-bundled-3rdparty-module") + elseif(type STREQUAL "QT_THIRD_PARTY_SOURCES") + set(package_infix "qt-3rdparty-sources") + elseif(type STREQUAL "SYSTEM_LIBRARY") + set(package_infix "system-3rdparty") + elseif(type STREQUAL "EXECUTABLE") + set(package_infix "executable") + elseif(type STREQUAL "LIBRARY") + set(package_infix "library") + elseif(type STREQUAL "THIRD_PARTY_LIBRARY") + set(package_infix "3rdparty-library") + elseif(type STREQUAL "THIRD_PARTY_LIBRARY_WITH_FILES") + set(package_infix "3rdparty-library-with-files") + else() + message(DEBUG "No package infix due to unknown type: ${type}") + set(package_infix "") + endif() + set(${out_infix} "${package_infix}" PARENT_SCOPE) +endfunction() + +# Returns a package purpose for a given target sbom type. +function(_qt_internal_sbom_get_package_purpose type out_purpose) + if(type STREQUAL "QT_MODULE") + set(package_purpose "LIBRARY") + elseif(type STREQUAL "QT_PLUGIN") + set(package_purpose "LIBRARY") + elseif(type STREQUAL "QML_PLUGIN") + set(package_purpose "LIBRARY") + elseif(type STREQUAL "QT_TOOL") + set(package_purpose "APPLICATION") + elseif(type STREQUAL "QT_APP") + set(package_purpose "APPLICATION") + elseif(type STREQUAL "QT_THIRD_PARTY_MODULE") + set(package_purpose "LIBRARY") + elseif(type STREQUAL "QT_THIRD_PARTY_SOURCES") + set(package_purpose "LIBRARY") + elseif(type STREQUAL "SYSTEM_LIBRARY") + set(package_purpose "LIBRARY") + elseif(type STREQUAL "EXECUTABLE") + set(package_purpose "APPLICATION") + elseif(type STREQUAL "LIBRARY") + set(package_purpose "LIBRARY") + elseif(type STREQUAL "THIRD_PARTY_LIBRARY") + set(package_purpose "LIBRARY") + elseif(type STREQUAL "THIRD_PARTY_LIBRARY_WITH_FILES") + set(package_purpose "LIBRARY") + else() + set(package_purpose "OTHER") + endif() + set(${out_purpose} "${package_purpose}" PARENT_SCOPE) +endfunction() + +# Get a qt spdx license expression given the id. +function(_qt_internal_sbom_get_spdx_license_expression id out_var) + set(license "") + + # The default for modules / plugins + if(id STREQUAL "QT_DEFAULT" OR id STREQUAL "QT_COMMERCIAL_OR_LGPL3") + set(license "LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only") + + # For commercial only entities + elseif(id STREQUAL "QT_COMMERCIAL") + set(license "LicenseRef-Qt-Commercial") + + # For GPL3 only modules + elseif(id STREQUAL "QT_COMMERCIAL_OR_GPL3") + set(license "LicenseRef-Qt-Commercial OR GPL-3.0-only") + + # For tools and apps + elseif(id STREQUAL "QT_COMMERCIAL_OR_GPL3_WITH_EXCEPTION") + set(license "LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0") + + # For things like the qtmain library + elseif(id STREQUAL "QT_COMMERCIAL_OR_BSD3") + set(license "LicenseRef-Qt-Commercial OR BSD-3-Clause") + + # For documentation + elseif(id STREQUAL "QT_COMMERCIAL_OR_GFDL1_3") + set(license "LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only") + + # For examples and the like + elseif(id STREQUAL "BSD3") + set(license "BSD-3-Clause") + + endif() + + if(NOT license) + message(FATAL_ERROR "No SPDX license expression found for id: ${id}") + endif() + + set(${out_var} "${license}" PARENT_SCOPE) +endfunction() + +# Get the default qt copyright. +function(_qt_internal_sbom_get_default_qt_copyright_header out_var) + set(${out_var} + "Copyright (C) The Qt Company Ltd. and other contributors." + PARENT_SCOPE) +endfunction() + +# Get the default qt package version. +function(_qt_internal_sbom_get_default_qt_package_version out_var) + set(${out_var} "${QT_REPO_MODULE_VERSION}" PARENT_SCOPE) +endfunction() + +# Get the default qt supplier. +function(_qt_internal_sbom_get_default_supplier out_var) + set(${out_var} "TheQtCompany" PARENT_SCOPE) +endfunction() + +# Get the default qt supplier url. +function(_qt_internal_sbom_get_default_supplier_url out_var) + set(${out_var} "https://qt.io" PARENT_SCOPE) +endfunction() + +# Get the default qt download location. +# If git info is available, includes the hash. +function(_qt_internal_sbom_get_qt_repo_source_download_location out_var) + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + set(download_location "git://code.qt.io/qt/${repo_project_name_lowercase}.git") + if(QT_SBOM_GIT_HASH) + string(APPEND download_location "@${QT_SBOM_GIT_HASH}") + endif() + set(${out_var} "${download_location}" PARENT_SCOPE) +endfunction() + +# Computes a security CPE for a given set of attributes. +# +# When a part is not specified, a wildcard is added. +# +# References: +# https://spdx.github.io/spdx-spec/v2.3/external-repository-identifiers/#f22-cpe23type +# https://nvlpubs.nist.gov/nistpubs/Legacy/IR/nistir7695.pdf +# https://nvd.nist.gov/products/cpe +# +# Each attribute means: +# 1. part +# 2. vendor +# 3. product +# 4. version +# 5. update +# 6. edition +# 7. language +# 8. sw_edition +# 9. target_sw +# 10. target_hw +# 11. other +function(_qt_internal_sbom_compute_security_cpe out_cpe) + set(opt_args "") + set(single_args + PART + VENDOR + PRODUCT + VERSION + UPDATE + EDITION + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(cpe_template "cpe:2.3:PART:VENDOR:PRODUCT:VERSION:UPDATE:EDITION:*:*:*:*:*") + + set(cpe "${cpe_template}") + foreach(attribute_name IN LISTS single_args) + if(arg_${attribute_name}) + set(${attribute_name}_value "${arg_${attribute_name}}") + else() + if(attribute_name STREQUAL "PART") + set(${attribute_name}_value "a") + else() + set(${attribute_name}_value "*") + endif() + endif() + string(REPLACE "${attribute_name}" "${${attribute_name}_value}" cpe "${cpe}") + endforeach() + + set(${out_cpe} "${cpe}" PARENT_SCOPE) +endfunction() + +# Computes the default security CPE for the Qt framework. +function(_qt_internal_sbom_get_cpe_qt out_var) + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + _qt_internal_sbom_compute_security_cpe(repo_cpe + VENDOR "qt" + PRODUCT "${repo_project_name_lowercase}" + VERSION "${QT_REPO_MODULE_VERSION}" + ) + set(${out_var} "${repo_cpe}" PARENT_SCOPE) +endfunction() + +# Computes the default security CPE for a given qt repository. +function(_qt_internal_sbom_get_cpe_qt_repo out_var) + _qt_internal_sbom_compute_security_cpe(qt_cpe + VENDOR "qt" + PRODUCT "qt" + VERSION "${QT_REPO_MODULE_VERSION}" + ) + set(${out_var} "${qt_cpe}" PARENT_SCOPE) +endfunction() + +# Computes the list of security CPEs for Qt, including both the repo-specific one and generic one. +function(_qt_internal_sbom_compute_security_cpe_for_qt out_cpe_list) + set(cpe_list "") + + _qt_internal_sbom_get_cpe_qt(repo_cpe) + list(APPEND cpe_list "${repo_cpe}") + + _qt_internal_sbom_get_cpe_qt_repo(qt_cpe) + list(APPEND cpe_list "${qt_cpe}") + + set(${out_cpe_list} "${cpe_list}" PARENT_SCOPE) +endfunction() + +# Parse purl arguments for a specific purl variant, e.g. for parsing all values of arg_PURL_QT_ARGS. +# arguments_var_name is the variable name that contains the args. +macro(_qt_internal_sbom_parse_purl_variant_options prefix arguments_var_name) + _qt_internal_get_sbom_purl_parsing_options(purl_opt_args purl_single_args purl_multi_args) + + cmake_parse_arguments(arg "${purl_opt_args}" "${purl_single_args}" "${purl_multi_args}" + ${${arguments_var_name}}) + _qt_internal_validate_all_args_are_parsed(arg) +endmacro() + +# Returns a vcs url where for purls where qt entities of the current repo are hosted. +function(_qt_internal_sbom_get_qt_entity_vcs_url target) + set(opt_args "") + set(single_args + REPO_NAME + VERSION + OUT_VAR + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_REPO_NAME) + message(FATAL_ERROR "REPO_NAME must be set") + endif() + + if(NOT arg_OUT_VAR) + message(FATAL_ERROR "OUT_VAR must be set") + endif() + + set(version_part "") + if(arg_VERSION) + set(version_part "@${arg_VERSION}") + endif() + + set(vcs_url "https://code.qt.io/qt/${arg_REPO_NAME}.git${version_part}") + set(${arg_OUT_VAR} "${vcs_url}" PARENT_SCOPE) +endfunction() + +# Returns a relative path to the source where the target was created, to be embedded into a +# mirror purl as a subpath. +function(_qt_internal_sbom_get_qt_entity_repo_source_dir target) + set(opt_args "") + set(single_args + OUT_VAR + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_OUT_VAR) + message(FATAL_ERROR "OUT_VAR must be set") + endif() + + get_target_property(repo_source_dir "${target}" SOURCE_DIR) + + # Get the path relative to the PROJECT_SOURCE_DIR + file(RELATIVE_PATH relative_repo_source_dir "${PROJECT_SOURCE_DIR}" "${repo_source_dir}") + + set(sub_path "${relative_repo_source_dir}") + set(${arg_OUT_VAR} "${sub_path}" PARENT_SCOPE) +endfunction() + +# Handles purl arguments specified to functions like qt_internal_add_sbom. +# Currently accepts arguments for 3 variants of purls, each of which will generate a separate purl. +# If no arguments are specified, for qt entity types, default values will be chosen. +# +# Purl variants: +# - PURL_QT_ARGS +# args to override Qt's generic purl for Qt modules or patched 3rd party libs +# defaults to something like pkg:generic/TheQtCompany/${repo_name}-${target}@SHA1 +# - PURL_MIRROR_ARGS +# args to override Qt's mirror purl, which is hosted on github +# defaults to something like pkg:github/qt/${repo_name}@SHA1 +# - PURL_3RDPARTY_UPSTREAM_ARGS +# args to specify a purl pointing to an upstream repo, usually to github or another forge +# no defaults, but could look like: pkg:github/harfbuzz/harfbuzz@v8.5.0 +# Example values for harfbuzz: +# PURL_3RDPARTY_UPSTREAM_ARGS +# PURL_TYPE "github" +# PURL_NAMESPACE "harfbuzz" +# PURL_NAME "harfbuzz" +# PURL_VERSION "v8.5.0" # tag +function(_qt_internal_sbom_handle_purl_values target) + _qt_internal_get_sbom_purl_handling_options(opt_args single_args multi_args) + list(APPEND single_args OUT_VAR) + + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_OUT_VAR) + message(FATAL_ERROR "OUT_VAR must be set") + endif() + + # List of purl variants to process. + set(purl_variants "") + + set(third_party_types + QT_THIRD_PARTY_MODULE + QT_THIRD_PARTY_SOURCES + ) + + if(arg_IS_QT_ENTITY_TYPE) + # Qt entities have two purls by default, a QT generic one and a MIRROR hosted on github. + list(APPEND purl_variants MIRROR QT) + elseif(arg_TYPE IN_LIST third_party_types) + # Third party libraries vendored in Qt also have at least two purls, like regular Qt + # libraries, but might also have an upstream one. + + # The order in which the purls are generated matters for tools that consume the SBOM. Some + # tools can only handle one PURL per package, so the first one should be the important one. + # For now, I deem that the upstream one if present. Otherwise the github mirror. + if(arg_PURL_3RDPARTY_UPSTREAM_ARGS) + list(APPEND purl_variants 3RDPARTY_UPSTREAM) + endif() + + list(APPEND purl_variants MIRROR QT) + else() + # If handling another entity type, handle based on whether any of the purl arguments are + # set. + set(known_purl_variants QT MIRROR 3RDPARTY_UPSTREAM) + foreach(known_purl_variant IN_LIST known_purl_variants) + if(arg_PURL_${known_purl_variant}_ARGS) + list(APPEND purl_variants ${known_purl_variant}) + endif() + endforeach() + endif() + + if(arg_IS_QT_ENTITY_TYPE + OR arg_TYPE STREQUAL "QT_THIRD_PARTY_MODULE" + OR arg_TYPE STREQUAL "QT_THIRD_PARTY_SOURCES" + ) + set(is_qt_purl_entity_type TRUE) + else() + set(is_qt_purl_entity_type FALSE) + endif() + + _qt_internal_get_sbom_purl_parsing_options(purl_opt_args purl_single_args purl_multi_args) + + set(project_package_options "") + + foreach(purl_variant IN LISTS purl_variants) + # Clear previous values. + foreach(option_name IN LISTS purl_opt_args purl_single_args purl_multi_args) + unset(arg_${option_name}) + endforeach() + + _qt_internal_sbom_parse_purl_variant_options(arg arg_PURL_${purl_variant}_ARGS) + + # Check if custom purl args were specified. + set(purl_args_available FALSE) + if(arg_PURL_${purl_variant}_ARGS) + set(purl_args_available TRUE) + endif() + + # We want to create a purl either if it's one of Qt's entities and one of it's default + # purl types, or if custom args were specified. + set(consider_purl_processing FALSE) + if((purl_args_available OR is_qt_purl_entity_type) AND NOT arg_NO_PURL) + set(consider_purl_processing TRUE) + endif() + + if(consider_purl_processing) + set(purl_args "") + + # Override the purl version with the package version. + if(arg_PURL_USE_PACKAGE_VERSION AND arg_VERSION) + set(arg_PURL_VERSION "${arg_VERSION}") + endif() + + # Append a vcs_url to the qualifiers if specified. + if(arg_PURL_VCS_URL) + list(APPEND arg_PURL_QUALIFIERS "vcs_url=${arg_PURL_VCS_URL}") + endif() + + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR purl_args + FORWARD_OPTIONS + ${purl_opt_args} + FORWARD_SINGLE + ${purl_single_args} + FORWARD_MULTI + ${purl_multi_args} + ) + + # Qt entity types get special treatment purl. + if(is_qt_purl_entity_type AND NOT arg_NO_DEFAULT_QT_PURL AND + (purl_variant STREQUAL "QT" OR purl_variant STREQUAL "MIRROR")) + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + + # Add a vcs_url to the generic QT variant. + if(purl_variant STREQUAL "QT") + _qt_internal_sbom_get_qt_entity_vcs_url(${target} + REPO_NAME "${repo_project_name_lowercase}" + VERSION "${QT_SBOM_GIT_HASH_SHORT}" # can be empty + OUT_VAR vcs_url) + list(APPEND purl_args PURL_QUALIFIERS "vcs_url=${vcs_url}") + endif() + + # Add the subdirectory path where the target was created as a custom qualifier. + _qt_internal_sbom_get_qt_entity_repo_source_dir(${target} OUT_VAR sub_path) + list(APPEND purl_args PURL_SUBPATH "${sub_path}") + + # Add the target name as a custom qualifer. + list(APPEND purl_args PURL_QUALIFIERS "library_name=${target}") + + # Get purl args the Qt entity type, taking into account defaults. + _qt_internal_sbom_get_qt_entity_purl_args(${target} + NAME "${repo_project_name_lowercase}-${target}" + REPO_NAME "${repo_project_name_lowercase}" + SUPPLIER "${arg_SUPPLIER}" + VERSION "${QT_SBOM_GIT_HASH_SHORT}" # can be empty + PURL_VARIANT "${purl_variant}" + ${purl_args} + OUT_VAR purl_args + ) + endif() + + _qt_internal_sbom_assemble_purl(${target} + ${purl_args} + OUT_VAR package_manager_external_ref + ) + list(APPEND project_package_options ${package_manager_external_ref}) + endif() + endforeach() + + set(direct_values + PURL_QT_VALUES + PURL_MIRROR_VALUES + PURL_3RDPARTY_UPSTREAM_VALUES + ) + + foreach(direct_value IN LISTS direct_values) + if(arg_${direct_value}) + set(direct_values_per_type "") + foreach(direct_value IN LISTS arg_${direct_value}) + _qt_internal_sbom_get_purl_value_extref( + VALUE "${direct_value}" OUT_VAR package_manager_external_ref) + + list(APPEND direct_values_per_type ${package_manager_external_ref}) + endforeach() + # The order in which the purls are generated, matters for tools that consume the SBOM. + # Some tools can only handle one PURL per package, so the first one should be the + # important one. + # For now, I deem that the directly specified ones (probably via a qt_attribution.json + # file) are the more important ones. So we prepend them. + list(PREPEND project_package_options ${direct_values_per_type}) + endif() + endforeach() + + set(${arg_OUT_VAR} "${project_package_options}" PARENT_SCOPE) +endfunction() + +# Gets a list of arguments to pass to _qt_internal_sbom_assemble_purl when handling a Qt entity +# type. The purl for Qt entity types have Qt-specific defaults, but can be overridden per purl +# component. +# The arguments are saved in OUT_VAR. +function(_qt_internal_sbom_get_qt_entity_purl_args target) + set(opt_args "") + set(single_args + NAME + REPO_NAME + SUPPLIER + VERSION + PURL_VARIANT + OUT_VAR + ) + set(multi_args "") + + _qt_internal_get_sbom_purl_parsing_options(purl_opt_args purl_single_args purl_multi_args) + list(APPEND opt_args ${purl_opt_args}) + list(APPEND single_args ${purl_single_args}) + list(APPEND multi_args ${purl_multi_args}) + + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(supported_purl_variants QT MIRROR) + if(NOT arg_PURL_VARIANT IN_LIST supported_purl_variants) + message(FATAL_ERROR "PURL_VARIANT unknown: ${arg_PURL_VARIANT}") + endif() + + if(arg_PURL_VARIANT STREQUAL "QT") + set(purl_type "generic") + set(purl_namespace "${arg_SUPPLIER}") + set(purl_name "${arg_NAME}") + set(purl_version "${arg_VERSION}") + elseif(arg_PURL_VARIANT STREQUAL "MIRROR") + set(purl_type "github") + set(purl_namespace "qt") + set(purl_name "${arg_REPO_NAME}") + set(purl_version "${arg_VERSION}") + endif() + + if(arg_PURL_TYPE) + set(purl_type "${arg_PURL_TYPE}") + endif() + + if(arg_PURL_NAMESPACE) + set(purl_namespace "${arg_PURL_NAMESPACE}") + endif() + + if(arg_PURL_NAME) + set(purl_name "${arg_PURL_NAME}") + endif() + + if(arg_PURL_VERSION) + set(purl_version "${arg_PURL_VERSION}") + endif() + + set(purl_args + PURL_TYPE "${purl_type}" + PURL_NAMESPACE "${purl_namespace}" + PURL_NAME "${purl_name}" + PURL_VERSION "${purl_version}" + ) + + if(arg_PURL_QUALIFIERS) + list(APPEND purl_args PURL_QUALIFIERS "${arg_PURL_QUALIFIERS}") + endif() + + if(arg_PURL_SUBPATH) + list(APPEND purl_args PURL_SUBPATH "${arg_PURL_SUBPATH}") + endif() + + set(${arg_OUT_VAR} "${purl_args}" PARENT_SCOPE) +endfunction() + +# Assembles an external reference purl identifier. +# PURL_TYPE and PURL_NAME are required. +# Stores the result in the OUT_VAR. +# Accepted options: +# PURL_TYPE +# PURL_NAME +# PURL_NAMESPACE +# PURL_VERSION +# PURL_SUBPATH +# PURL_QUALIFIERS +function(_qt_internal_sbom_assemble_purl target) + set(opt_args "") + set(single_args + OUT_VAR + ) + set(multi_args "") + + _qt_internal_get_sbom_purl_parsing_options(purl_opt_args purl_single_args purl_multi_args) + list(APPEND opt_args ${purl_opt_args}) + list(APPEND single_args ${purl_single_args}) + list(APPEND multi_args ${purl_multi_args}) + + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + set(purl_scheme "pkg") + + if(NOT arg_PURL_TYPE) + message(FATAL_ERROR "PURL_TYPE must be set") + endif() + + if(NOT arg_PURL_NAME) + message(FATAL_ERROR "PURL_NAME must be set") + endif() + + if(NOT arg_OUT_VAR) + message(FATAL_ERROR "OUT_VAR must be set") + endif() + + # https://github.com/package-url/purl-spec + # Spec is 'scheme:type/namespace/name@version?qualifiers#subpath' + set(purl "${purl_scheme}:${arg_PURL_TYPE}") + + if(arg_PURL_NAMESPACE) + string(APPEND purl "/${arg_PURL_NAMESPACE}") + endif() + + string(APPEND purl "/${arg_PURL_NAME}") + + if(arg_PURL_VERSION) + string(APPEND purl "@${arg_PURL_VERSION}") + endif() + + if(arg_PURL_QUALIFIERS) + # TODO: Note that the qualifiers are expected to be URL encoded, which this implementation + # is not doing at the moment. + list(JOIN arg_PURL_QUALIFIERS "&" qualifiers) + string(APPEND purl "?${qualifiers}") + endif() + + if(arg_PURL_SUBPATH) + string(APPEND purl "#${arg_PURL_SUBPATH}") + endif() + + _qt_internal_sbom_get_purl_value_extref(VALUE "${purl}" OUT_VAR result) + + set(${arg_OUT_VAR} "${result}" PARENT_SCOPE) +endfunction() + +# Takes a PURL VALUE and returns an SBOM purl external reference in OUT_VAR. +function(_qt_internal_sbom_get_purl_value_extref) + set(opt_args "") + set(single_args + OUT_VAR + VALUE + ) + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_OUT_VAR) + message(FATAL_ERROR "OUT_VAR must be set") + endif() + + if(NOT arg_VALUE) + message(FATAL_ERROR "VALUE must be set") + endif() + + # SPDX SBOM External reference type. + set(ext_ref_prefix "PACKAGE-MANAGER purl") + set(external_ref "${ext_ref_prefix} ${arg_VALUE}") + set(result "EXTREF" "${external_ref}") + set(${arg_OUT_VAR} "${result}" PARENT_SCOPE) +endfunction() + +# Collects app bundle related information and paths from an executable's target properties. +# Output variables: +# _name bundle base name, e.g. 'Linguist'. +# _dir_name bundle dir name, e.g. 'Linguist.app'. +# _contents_dir bundle contents dir, e.g. 'Linguist.app/Contents' +# _contents_binary_dir bundle contents dir, e.g. 'Linguist.app/Contents/MacOS' +function(_qt_internal_get_executable_bundle_info out_var target) + get_target_property(target_type ${target} TYPE) + if(NOT "${target_type}" STREQUAL "EXECUTABLE") + message(FATAL_ERROR "The target ${target} is not an executable") + endif() + + get_target_property(output_name ${target} OUTPUT_NAME) + if(NOT output_name) + set(output_name "${target}") + endif() + + set(${out_var}_name "${output_name}") + set(${out_var}_dir_name "${${out_var}_name}.app") + set(${out_var}_contents_dir "${${out_var}_dir_name}/Contents") + set(${out_var}_contents_binary_dir "${${out_var}_contents_dir}/MacOS") + + set(${out_var}_name "${${out_var}_name}" PARENT_SCOPE) + set(${out_var}_dir_name "${${out_var}_dir_name}" PARENT_SCOPE) + set(${out_var}_contents_dir "${${out_var}_contents_dir}" PARENT_SCOPE) + set(${out_var}_contents_binary_dir "${${out_var}_contents_binary_dir}" PARENT_SCOPE) +endfunction() + +# Helper function to add binary file to the sbom, while handling multi-config and different +# kind of paths. +# In multi-config builds, we assume that the non-default config file will be optional, because it +# might not be installed (the case for debug tools and apps in debug-and-release builds). +function(_qt_internal_sbom_handle_multi_config_target_binary_file target) + set(opt_args "") + set(single_args + PATH_KIND + PATH_SUFFIX + ) + set(multi_args + OPTIONS + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + _qt_internal_validate_all_args_are_parsed(arg) + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + else() + set(configs "${CMAKE_BUILD_TYPE}") + endif() + + foreach(config IN LISTS configs) + _qt_internal_sbom_get_and_check_multi_config_aware_single_arg_option( + arg "${arg_PATH_KIND}" "${config}" resolved_path) + _qt_internal_sbom_get_target_file_is_optional_in_multi_config("${config}" is_optional) + _qt_internal_path_join(file_path "${resolved_path}" "${arg_PATH_SUFFIX}") + _qt_internal_sbom_add_binary_file( + "${target}" + "${file_path}" + ${arg_OPTIONS} + ${is_optional} + CONFIG ${config} + ) + endforeach() +endfunction() + +# Helper to retrieve a list of multi-config aware option names that can be parsed by the binary +# file handling function. +# For example in single config we need to parse RUNTIME_PATH, in multi-config we need to parse +# RUNTIME_PATH_DEBUG and RUNTIME_PATH_RELEASE. +# +# Result is cached in a global property. +function(_qt_internal_sbom_get_multi_config_single_args out_var) + get_cmake_property(single_args + _qt_internal_sbom_multi_config_single_args) + + if(single_args) + set(${out_var} ${single_args} PARENT_SCOPE) + return() + endif() + + set(single_args "") + + set(single_args_to_process + INSTALL_PATH + RUNTIME_PATH + LIBRARY_PATH + ARCHIVE_PATH + FRAMEWORK_PATH + ) + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(configs ${CMAKE_CONFIGURATION_TYPES}) + foreach(config IN LISTS configs) + string(TOUPPER ${config} config_upper) + foreach(single_arg IN LISTS single_args_to_process) + list(APPEND single_args "${single_arg}_${config_upper}") + endforeach() + endforeach() + else() + list(APPEND single_args "${single_args_to_process}") + endif() + + set_property(GLOBAL PROPERTY + _qt_internal_sbom_multi_config_single_args "${single_args}") + set(${out_var} ${single_args} PARENT_SCOPE) +endfunction() + +# Helper to apped a an option and a value to a list of options, while being multi-config aware. +# It appends e.g. either RUNTIME_PATH foo or RUNTIME_PATH_DEBUG foo to the out_var_args variable. +function(_qt_internal_sbom_append_multi_config_aware_single_arg_option + arg_name arg_value config out_var_args) + set(values "${${out_var_args}}") + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + string(TOUPPER ${config} config_upper) + list(APPEND values "${arg_name}_${config_upper}" "${arg_value}") + else() + list(APPEND values "${arg_name}" "${arg_value}") + endif() + + set(${out_var_args} "${values}" PARENT_SCOPE) +endfunction() + +# Helper to check whether a given option was set in the outer scope, while being multi-config +# aware. +# It checks e.g. if either arg_RUNTIME_PATH or arg_RUNTIME_PATH_DEBUG is set in the outer scope. +function(_qt_internal_sbom_get_and_check_multi_config_aware_single_arg_option + arg_prefix arg_name config out_var) + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + + if(is_multi_config) + string(TOUPPER ${config} config_upper) + set(outer_scope_var_name "${arg_prefix}_${arg_name}_${config_upper}") + set(option_name "${arg_name}_${config_upper}") + else() + set(outer_scope_var_name "${arg_prefix}_${arg_name}") + set(option_name "${arg_name}") + endif() + + if(NOT DEFINED ${outer_scope_var_name}) + message(FATAL_ERROR "Missing ${option_name}") + endif() + + set(${out_var} "${${outer_scope_var_name}}" PARENT_SCOPE) +endfunction() + +# Checks if given config is not the first config in a multi-config build, and thus file installation +# for that config should be optional. +function(_qt_internal_sbom_is_config_optional_in_multi_config config out_var) + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + + if(QT_MULTI_CONFIG_FIRST_CONFIG) + set(first_config_type "${QT_MULTI_CONFIG_FIRST_CONFIG}") + elseif(CMAKE_CONFIGURATION_TYPES) + list(GET CMAKE_CONFIGURATION_TYPES 0 first_config_type) + endif() + + if(is_multi_config AND NOT (cmake_config STREQUAL first_config_type)) + set(is_optional TRUE) + else() + set(is_optional FALSE) + endif() + + set(${out_var} "${is_optional}" PARENT_SCOPE) +endfunction() + +# Checks if given config is not the first config in a multi-config build, and thus file installation +# for that config should be optional, sets the actual option name. +function(_qt_internal_sbom_get_target_file_is_optional_in_multi_config config out_var) + _qt_internal_sbom_is_config_optional_in_multi_config("${config}" is_optional) + + if(is_optional) + set(option "OPTIONAL") + else() + set(option "") + endif() + + set(${out_var} "${option}" PARENT_SCOPE) +endfunction() + +# Joins two license IDs with the given ${op}, avoiding parenthesis when possible. +function(_qt_internal_sbom_join_two_license_ids_with_op left_id op right_id out_var) + if(NOT left_id) + set(${out_var} "${right_id}" PARENT_SCOPE) + return() + endif() + + if(NOT right_id) + set(${out_var} "${left_id}" PARENT_SCOPE) + return() + endif() + + set(value "(${left_id}) ${op} (${right_id})") + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +# Returns the configure line used to configure the current repo or top-level build, by reading +# the config.opt file that the configure script writes out. +# Returns an empty string if configure was not called, but CMake was called directly. +# If the build is reconfigured with bare CMake, the config.opt remains untouched, and thus +# the previous contents is returned. +function(_qt_internal_get_configure_line out_var) + set(content "") + + if(QT_SUPERBUILD OR PROJECT_NAME STREQUAL "QtBase") + set(configure_script_name "qt6/configure") + elseif(PROJECT_NAME STREQUAL "QtBase") + set(configure_script_name "qtbase/configure") + else() + _qt_internal_sbom_get_root_project_name_lower_case(repo_project_name_lowercase) + set(configure_script_name "qt-configure-module /${repo_project_name_lowercase}") + endif() + + if(QT_SUPERBUILD) + set(config_opt_path "${PROJECT_BINARY_DIR}/../config.opt") + else() + set(config_opt_path "${PROJECT_BINARY_DIR}/config.opt") + endif() + + if(NOT EXISTS "${config_opt_path}") + message(DEBUG "Couldn't find config.opt file in ${config_opt} for argument extraction.") + set(${out_var} "${content}" PARENT_SCOPE) + return() + endif() + + file(STRINGS "${config_opt_path}" args) + list(JOIN args " " joined_args) + + set(content "${configure_script_name} ${joined_args}") + string(STRIP "${content}" content) + + set(${out_var} "${content}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicTargetHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicTargetHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dff044a113abc0a14f34905e805081a49e2bb10d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicTargetHelpers.cmake @@ -0,0 +1,426 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(__qt_internal_strip_target_directory_scope_token target out_var) + # In CMake versions earlier than CMake 3.18, a subdirectory scope id is appended to the + # target name if the target is referenced in a target_link_libraries command from a + # different directory scope than where the target was created. + # Strip it. + # + # For informational purposes, in CMake 3.18, the target name looks as follows: + # ::@(0x5604cb3f6b50);Threads::Threads;::@ + # This case doesn't have to be stripped (at least for now), because when we iterate over + # link libraries, the tokens appear as separate target names. + # + # Example: Threads::Threads::@<0x5604cb3f6b50> + # Output: Threads::Threads + string(REGEX REPLACE "::@<.+>$" "" target "${target}") + set("${out_var}" "${target}" PARENT_SCOPE) +endfunction() + +# Tests if linker could resolve circular dependencies between object files and static libraries. +function(__qt_internal_static_link_order_public_test result) + # We could trust iOS linker + if(IOS) + set(QT_HAVE_LINK_ORDER_MATTERS "FALSE" CACHE INTERNAL "Link order matters") + endif() + + if(DEFINED QT_HAVE_LINK_ORDER_MATTERS) + set(${result} "${QT_HAVE_LINK_ORDER_MATTERS}" PARENT_SCOPE) + return() + endif() + + if(EXISTS "${QT_CMAKE_DIR}") + set(test_source_basedir "${QT_CMAKE_DIR}/..") + else() + set(test_source_basedir "${_qt_cmake_dir}/${QT_CMAKE_EXPORT_NAMESPACE}") + endif() + + try_compile(${result} + "${CMAKE_CURRENT_BINARY_DIR}/config.tests/static_link_order" + "${test_source_basedir}/config.tests/static_link_order" + static_link_order_test + static_link_order_test + ) + message(STATUS "Check if linker can resolve circular dependencies - ${${result}}") + + # Invert the result + if(${result}) + set(${result} FALSE) + else() + set(${result} TRUE) + endif() + + set(QT_HAVE_LINK_ORDER_MATTERS "${${result}}" CACHE INTERNAL "Link order matters") + + set(${result} "${${result}}" PARENT_SCOPE) +endfunction() + +# Sets _qt_link_order_matters flag for the target. +function(__qt_internal_set_link_order_matters target link_order_matters) + if(NOT TARGET ${target}) + message(FATAL_ERROR "Unable to set _qt_link_order_matters flag. ${target} is not a target.") + endif() + + get_target_property(aliased_target ${target} ALIASED_TARGET) + if(aliased_target) + set(target "${aliased_target}") + endif() + + if(link_order_matters) + set(link_order_matters TRUE) + else() + set(link_order_matters FALSE) + endif() + set_target_properties(${target} PROPERTIES _qt_link_order_matters "${link_order_matters}") +endfunction() + +# Function combines __qt_internal_static_link_order_public_test and +# __qt_internal_set_link_order_matters calls on Qt::Platform target. +function(__qt_internal_check_link_order_matters) + __qt_internal_static_link_order_public_test( + link_order_matters + ) + __qt_internal_set_link_order_matters( + ${QT_CMAKE_EXPORT_NAMESPACE}::Platform "${link_order_matters}" + ) + + if("${ARGC}" GREATER "0" AND NOT ARGV0 STREQUAL "") + set(${ARGV0} ${link_order_matters} PARENT_SCOPE) + endif() +endfunction() + +# Constructs a TARGET_POLICY genex expression if the policy is available. +function(__qt_internal_get_cmp0099_genex_check result) + if(POLICY CMP0099) + set(${result} "$>" PARENT_SCOPE) + else() + set(${result} "$" PARENT_SCOPE) + endif() +endfunction() + +function(__qt_internal_check_cmp0099_available) + set(platform_target ${QT_CMAKE_EXPORT_NAMESPACE}::Platform) + get_target_property(aliased_target ${platform_target} ALIASED_TARGET) + if(aliased_target) + set(platform_target "${aliased_target}") + endif() + + __qt_internal_get_cmp0099_genex_check(cmp0099_check) + set_target_properties(${platform_target} PROPERTIES + _qt_cmp0099_policy_check "${cmp0099_check}" + ) + + set(result TRUE) + if(NOT POLICY CMP0099) + set(result FALSE) + endif() + + if("${ARGC}" GREATER "0" AND NOT ARGV0 STREQUAL "") + set(${ARGV0} ${result} PARENT_SCOPE) + endif() +endfunction() + +function(__qt_internal_process_dependency_object_libraries target) + # The CMake versions greater than 3.21 take care about the order of object files in a + # linker line, it's expected that all object files are located at the beginning of the linker + # line. + # So circular dependencies between static libraries and object files are resolved and no need + # to call the finalizer code. + if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.21) + return() + endif() + get_target_property(processed ${target} _qt_object_libraries_finalizer_processed) + if(processed) + return() + endif() + set_target_properties(${target} PROPERTIES _qt_object_libraries_finalizer_processed TRUE) + + get_target_property(qt_link_order_matters + ${QT_CMAKE_EXPORT_NAMESPACE}::Platform _qt_link_order_matters + ) + __qt_internal_check_finalizer_mode(${target} + use_finalizer_mode + object_libraries + DEFAULT_VALUE "${qt_link_order_matters}" + ) + + if(NOT use_finalizer_mode) + return() + endif() + + __qt_internal_collect_dependency_object_libraries(${target} objects) + target_sources(${target} PRIVATE "${objects}") +endfunction() + +function(__qt_internal_collect_dependency_object_libraries target out_var) + set_property(GLOBAL PROPERTY _qt_processed_object_libraries "") + + __qt_internal_collect_object_libraries_recursively(object_libraries ${target} ${target}) + + # Collect object libraries of plugins and plugin dependencies. + __qt_internal_collect_plugin_targets_from_dependencies(${target} plugin_targets) + __qt_internal_collect_dependency_plugin_object_libraries(${target} + "${plugin_targets}" + plugin_objects + ) + + set_property(GLOBAL PROPERTY _qt_processed_object_libraries "") + __qt_internal_get_cmp0099_genex_check(cmp0099_check) + + list(REMOVE_DUPLICATES object_libraries) + set(objects "") + foreach(dep IN LISTS object_libraries) + list(PREPEND objects "$<$:$>") + endforeach() + + set(${out_var} "${plugin_objects};${objects}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_collect_dependency_plugin_object_libraries target plugin_targets out_var) + __qt_internal_get_cmp0099_genex_check(cmp0099_check) + set(plugin_objects "") + foreach(plugin_target IN LISTS plugin_targets) + __qt_internal_collect_object_libraries_recursively(plugin_object_libraries + "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}" + ${target} + ) + __qt_internal_get_static_plugin_condition_genex("${plugin_target}" plugin_condition) + + foreach(plugin_object_library IN LISTS plugin_object_libraries) + string(JOIN "" plugin_objects_genex + "$<" + "$," + "${plugin_condition}" + ">" + ":$" + ">" + ) + list(APPEND plugin_objects "${plugin_objects_genex}") + endforeach() + endforeach() + set(${out_var} "${plugin_objects}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_collect_object_libraries_recursively out_var target initial_target) + get_property(processed_object_libraries GLOBAL PROPERTY _qt_processed_object_libraries) + + set(interface_libs "") + set(libs "") + if(NOT "${target}" STREQUAL "${initial_target}") + get_target_property(interface_libs ${target} INTERFACE_LINK_LIBRARIES) + endif() + get_target_property(type ${target} TYPE) + if(NOT type STREQUAL "INTERFACE_LIBRARY") + get_target_property(libs ${target} LINK_LIBRARIES) + endif() + + set(object_libraries "") + foreach(lib IN LISTS libs interface_libs) + # Extract possible target from exported LINK_ONLY dependencies. + # This is super important for traversing backing library dependencies of qml plugins. + if(lib MATCHES "^\\$$") + set(lib "${CMAKE_MATCH_1}") + endif() + if(TARGET ${lib}) + get_target_property(aliased_target ${lib} ALIASED_TARGET) + if(aliased_target) + set(lib ${aliased_target}) + endif() + + if(${lib} IN_LIST processed_object_libraries) + continue() + else() + list(APPEND processed_object_libraries ${lib}) + set_property(GLOBAL APPEND PROPERTY _qt_processed_object_libraries ${lib}) + endif() + + get_target_property(is_qt_propagated_object_library ${lib} + _is_qt_propagated_object_library + ) + if(is_qt_propagated_object_library) + list(APPEND object_libraries ${lib}) + else() + __qt_internal_collect_object_libraries_recursively(next_level_object_libraries + ${lib} + ${initial_target} + ) + list(APPEND object_libraries ${next_level_object_libraries}) + endif() + endif() + endforeach() + set(${out_var} "${object_libraries}" PARENT_SCOPE) +endfunction() + +# Sets out_var to to TRUE if the target was marked to not be promoted to global scope. +function(_qt_internal_should_not_promote_package_target_to_global target out_var) + get_property(should_not_promote TARGET "${target}" PROPERTY _qt_no_promote_global) + set("${out_var}" "${should_not_promote}" PARENT_SCOPE) +endfunction() + +# This function recursively walks transitive link libraries of the given target +# and promotes encountered 3rd party targets to be IMPORTED_GLOBAL if they are not. +# +# This is required for .prl file generation in top-level builds, to make sure that imported 3rd +# party library targets in any repo are made global, so there are no scoping issues. +# +# The promotion needs to happen in the same directory scope where the imported target is +# first created. +# +# Uses __qt_internal_walk_libs. +function(_qt_internal_promote_3rd_party_link_targets_to_global target) + __qt_internal_walk_libs("${target}" _discarded_out_var _discarded_out_var_2 + "qt_find_package_targets_dict" "promote_3rd_party_global") +endfunction() + +# Check if a target is an internal target (one added by qt_internal_* API, executables, libraries, +# etc). +function(_qt_internal_is_internal_target target out_var) + get_target_property(is_internal ${target} _qt_is_internal_target) + if(is_internal) + set(value TRUE) + else() + set(value FALSE) + endif() + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +# Check if a target should never be promoted to global. +# Some targets like the Platform target is public, and can't have _qt_is_internal_target set. +# But we still want to avoid promoting it to global. Setting this property achieves that. +function(_qt_internal_should_skip_3rd_party_global_promotion target out_var) + get_target_property(should_skip ${target} _qt_should_skip_3rd_party_global_promotion) + if(should_skip) + set(value TRUE) + else() + set(value FALSE) + endif() + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +# Tries to promote any non-global imported target to global scope. +function(__qt_internal_promote_target_to_global target) + get_property(is_global TARGET ${target} PROPERTY IMPORTED_GLOBAL) + if(NOT is_global) + message(DEBUG "Promoting target to global: '${target}'") + set_property(TARGET ${target} PROPERTY IMPORTED_GLOBAL TRUE) + endif() +endfunction() + +# Promotes a 3rd party provided target to global, which was found by qt_find_package or +# _qt_internal_find_third_party_dependencies. +# Only does it when building Qt, but not when building user projects. +function(_qt_internal_promote_3rd_party_provided_target_and_3rd_party_deps_to_global target) + # Return early if building a user project, and not Qt. + # QT_BUILDING_QT is set when building a qt repo, but we also check for QT_REPO_MODULE_VERSION, + # which is set in .cmake.conf, because _qt_internal_find_third_party_dependencies is called + # before QT_BUILDING_QT is set. + if(NOT (QT_BUILDING_QT OR QT_REPO_MODULE_VERSION)) + return() + endif() + + # Return early if the provided target does not exist, which can happen in the case of zstd, + # where we list multiple possible target names, but only some will be available. + if(NOT TARGET "${target}") + return() + endif() + + get_property(is_global TARGET "${target}" PROPERTY IMPORTED_GLOBAL) + _qt_internal_should_not_promote_package_target_to_global("${target}" should_not_promote) + if(NOT is_global AND NOT should_not_promote) + _qt_internal_promote_3rd_party_target_to_global(${target}) + _qt_internal_promote_3rd_party_link_targets_to_global("${target}") + endif() +endfunction() + +# Tries to promote a non-global imported 3rd party target to global scope. +# 3rd party targets are usually system library targets. +# - targets that were not created by qt_internal_add_foo commands +# - targets that don't have the should_skip_global_promotion property +function(_qt_internal_promote_3rd_party_target_to_global target) + get_property(is_global TARGET ${target} PROPERTY IMPORTED_GLOBAL) + + if(NOT is_global) + _qt_internal_is_internal_target("${target}" is_internal) + _qt_internal_should_skip_3rd_party_global_promotion("${target}" should_skip) + if(NOT is_internal AND NOT should_skip) + __qt_internal_promote_target_to_global("${target}") + endif() + endif() +endfunction() + +function(__qt_internal_promote_target_to_global_checked target) + # With CMake version 3.21 we use a different mechanism that allows us to promote all targets + # within a scope. + if(QT_PROMOTE_TO_GLOBAL_TARGETS AND CMAKE_VERSION VERSION_LESS 3.21) + __qt_internal_promote_target_to_global(${target}) + endif() +endfunction() + +function(__qt_internal_promote_targets_in_dir_scope_to_global) + # IMPORTED_TARGETS got added in 3.21. + if(CMAKE_VERSION VERSION_LESS 3.21) + return() + endif() + + get_directory_property(targets IMPORTED_TARGETS) + foreach(target IN LISTS targets) + __qt_internal_promote_target_to_global(${target}) + endforeach() +endfunction() + +function(__qt_internal_promote_targets_in_dir_scope_to_global_checked) + if(QT_PROMOTE_TO_GLOBAL_TARGETS) + __qt_internal_promote_targets_in_dir_scope_to_global() + endif() +endfunction() + +# This function ends up being called multiple times as part of a find_package(Qt6Foo) call, +# due sub-packages depending on the Qt6 package. Ensure the finalizer is ran only once per +# directory scope. +function(__qt_internal_defer_promote_targets_in_dir_scope_to_global) + get_directory_property(is_deferred _qt_promote_targets_is_deferred) + if(NOT is_deferred) + set_property(DIRECTORY PROPERTY _qt_promote_targets_is_deferred TRUE) + + if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.19) + cmake_language(DEFER CALL __qt_internal_promote_targets_in_dir_scope_to_global_checked) + endif() + endif() +endfunction() + +function(_qt_internal_set_up_static_runtime_library target) + if(QT_FEATURE_static_runtime) + if(MSVC) + set_property(TARGET ${target} PROPERTY + MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") + elseif(MINGW) + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "EXECUTABLE") + set(link_option PRIVATE) + else() + set(link_option INTERFACE) + endif() + if(CLANG) + target_link_options(${target} ${link_option} "LINKER:-Bstatic") + else() + target_link_options(${target} ${link_option} "-static") + endif() + endif() + endif() +endfunction() + +function(_qt_internal_warn_about_example_add_subdirectory) + # This is set by qt_build_repo_impl_examples() in QtBuildRepoHelpers.cmake, only for developer + # builds, to catch examples that are added via add_subdirectory instead of via + # qt_internal_add_example. + if(QT_WARN_ABOUT_EXAMPLE_ADD_SUBDIRECTORY) + get_filename_component(dir_name "${PROJECT_SOURCE_DIR}" NAME) + message(AUTHOR_WARNING + "It looks like this example project was added via add_subdirectory instead of via " + "qt_internal_add_example. This causes issues in certain build configurations. Please " + "change the code to use\n qt_internal_add_example(${dir_name})\ninstead." + ) + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicTestHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicTestHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f7a256131e2430fa866e8c15d28b8ebfb6aa0222 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicTestHelpers.cmake @@ -0,0 +1,108 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This function wraps COMMAND with cmake script, that makes possible standalone run with external +# arguments. +# +# Generated wrapper will be written to OUTPUT_FILE. +# If WORKING_DIRECTORY is not set COMMAND will be executed in CMAKE_CURRENT_BINARY_DIR. +# Variables from ENVIRONMENT will be set before COMMAND execution. +# PRE_RUN and POST_RUN arguments may contain extra cmake code that supposed to be executed before +# and after COMMAND, respectively. Both arguments accept a list of cmake script language +# constructions. Each item of the list will be concantinated into single string with '\n' separator. +# COMMAND_ECHO option takes a value like it does for execute_process, and passes that value to +# execute_process. +function(_qt_internal_create_command_script) + #This style of parsing keeps ';' in ENVIRONMENT variables + cmake_parse_arguments(PARSE_ARGV 0 arg + "" + "OUTPUT_FILE;WORKING_DIRECTORY;COMMAND_ECHO" + "COMMAND;ENVIRONMENT;PRE_RUN;POST_RUN" + ) + + if(NOT arg_COMMAND) + message(FATAL_ERROR "qt_internal_create_command_script: COMMAND is not specified") + endif() + + if(NOT arg_OUTPUT_FILE) + message(FATAL_ERROR "qt_internal_create_command_script: Wrapper OUTPUT_FILE\ +is not specified") + endif() + + if(NOT arg_WORKING_DIRECTORY AND NOT QNX) + set(arg_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") + endif() + + set(environment_extras) + set(skipNext false) + if(arg_ENVIRONMENT) + list(LENGTH arg_ENVIRONMENT length) + math(EXPR length "${length} - 1") + foreach(envIdx RANGE ${length}) + if(skipNext) + set(skipNext FALSE) + continue() + endif() + + set(envVariable "") + set(envValue "") + + list(GET arg_ENVIRONMENT ${envIdx} envVariable) + math(EXPR envIdx "${envIdx} + 1") + if (envIdx LESS_EQUAL ${length}) + list(GET arg_ENVIRONMENT ${envIdx} envValue) + endif() + + if(NOT "${envVariable}" STREQUAL "") + set(environment_extras "${environment_extras}\nset(ENV{${envVariable}} \ +\"${envValue}\")") + endif() + set(skipNext TRUE) + endforeach() + endif() + + #Escaping environment variables before expand them by file GENERATE + string(REPLACE "\\" "\\\\" environment_extras "${environment_extras}") + + if(CMAKE_HOST_WIN32) + # It's necessary to call actual test inside 'cmd.exe', because 'execute_process' uses + # SW_HIDE to avoid showing a console window, it affects other GUI as well. + # See https://gitlab.kitware.com/cmake/cmake/-/issues/17690 for details. + set(extra_runner "cmd /c") + endif() + + if(arg_PRE_RUN) + string(JOIN "\n" pre_run ${arg_PRE_RUN}) + endif() + + if(arg_POST_RUN) + string(JOIN "\n" post_run ${arg_POST_RUN}) + endif() + + set(command_echo "") + if(arg_COMMAND_ECHO) + set(command_echo "COMMAND_ECHO ${arg_COMMAND_ECHO}") + endif() + + file(GENERATE OUTPUT "${arg_OUTPUT_FILE}" CONTENT +"#!${CMAKE_COMMAND} -P +# Qt generated command wrapper + +${environment_extras} +${pre_run} +execute_process(COMMAND ${extra_runner} ${arg_COMMAND} + WORKING_DIRECTORY \"${arg_WORKING_DIRECTORY}\" + ${command_echo} + RESULT_VARIABLE result +) +${post_run} +if(NOT result EQUAL 0) + string(JOIN \" \" full_command ${extra_runner} ${arg_COMMAND}) + message(FATAL_ERROR \"\${full_command} execution failed with exit code \${result}.\") +endif()" + ) +endfunction() + +function(_qt_internal_test_batch_target_name out) + set(${out} "test_batch" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicToolHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicToolHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c54096fee869d7a1a5a6c5835b64c0fee02fc853 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicToolHelpers.cmake @@ -0,0 +1,145 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# The function returns location of the imported 'tool', returns an empty string if tool is not +# imported. +function(__qt_internal_get_tool_imported_location out_var tool) + unset(${out_var}) + if("${tool}" MATCHES "^Qt[0-9]?::.+$") + # The tool target has namespace already + set(target ${tool}) + else() + set(target ${QT_CMAKE_EXPORT_NAMESPACE}::${tool}) + endif() + + if(NOT TARGET ${target}) + message(FATAL_ERROR "${target} is not a target.") + endif() + + get_target_property(is_imported ${target} IMPORTED) + if(NOT is_imported) + set(${out_var} "" PARENT_SCOPE) + return() + endif() + + get_target_property(configs ${target} IMPORTED_CONFIGURATIONS) + list(TRANSFORM configs PREPEND _) + # Well-known configuration types + list(APPEND configs + _RELWITHDEBINFO + _RELEASE + _MINSIZEREL + _DEBUG + ) + list(REMOVE_DUPLICATES configs) + # Look for the default empty configuration type at the first place. + list(PREPEND configs "") + + foreach(config ${configs}) + get_target_property(${out_var} ${target} "IMPORTED_LOCATION${config}") + if(${out_var}) + break() + endif() + endforeach() + + set(${out_var} "${${out_var}}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_collect_tool_paths out_paths) + set(prefixes "") + + # In a prefix build, the just-built tools should pick up libraries from the current repo build + # dir. + if(QT_BUILD_DIR) + list(APPEND prefixes "${QT_BUILD_DIR}") + endif() + + # Pick up libraries from the main location where Qt was installed during a Qt build. + if(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX) + list(APPEND prefixes "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}") + endif() + + # Needed for ExternalProjects examples, where the Qt build dir is passed via this variable + # to the example project. + if(QT_ADDITIONAL_PACKAGES_PREFIX_PATH) + __qt_internal_prefix_paths_to_roots(additional_roots + "${QT_ADDITIONAL_PACKAGES_PREFIX_PATH}") + list(APPEND prefixes ${QT_ADDITIONAL_PACKAGES_PREFIX_PATH}) + endif() + + # Fallback to wherever Qt6 package is. + if(QT6_INSTALL_PREFIX) + list(APPEND prefixes "${QT6_INSTALL_PREFIX}") + endif() + + # When building qtbase, QT6_INSTALL_BINS is not set yet. + if(INSTALL_BINDIR) + set(bin_suffix "${INSTALL_BINDIR}") + else() + set(bin_suffix "${QT6_INSTALL_BINS}") + endif() + + set(path_dirs "") + foreach(prefix IN LISTS prefixes) + set(bin_dir "${prefix}/${bin_suffix}") + if(EXISTS "${bin_dir}") + file(TO_NATIVE_PATH "${bin_dir}" path_dir) + list(APPEND path_dirs "${path_dir}") + endif() + endforeach() + + set(${out_paths} "${path_dirs}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_generate_tool_command_wrapper) + get_property(is_called GLOBAL PROPERTY _qt_internal_generate_tool_command_wrapper_called) + if(NOT CMAKE_HOST_WIN32 OR is_called) + return() + endif() + _qt_internal_collect_tool_paths(path_dirs) + + set(tool_command_wrapper_dir "${CMAKE_BINARY_DIR}/.qt/bin") + file(MAKE_DIRECTORY "${tool_command_wrapper_dir}") + set(tool_command_wrapper_path "${tool_command_wrapper_dir}/qt_setup_tool_path.bat") + + file(WRITE "${tool_command_wrapper_path}" "@echo off +set PATH=${path_dirs};%PATH% +%*") + + set(QT_TOOL_COMMAND_WRAPPER_PATH "${tool_command_wrapper_path}" + CACHE INTERNAL "Path to the wrapper of the tool commands") + + set_property(GLOBAL PROPERTY _qt_internal_generate_tool_command_wrapper_called TRUE) +endfunction() + +# Gets the path to tool wrapper shell script. +function(_qt_internal_get_tool_wrapper_script_path out_variable) + # Ensure the script wrapper exists. + _qt_internal_generate_tool_command_wrapper() + + set(${out_variable} "${QT_TOOL_COMMAND_WRAPPER_PATH}" PARENT_SCOPE) +endfunction() + +# Attempts to run execute_process command in the Qt environment. The macro +# sets the PATH on windows platforms so the executable can locate the required +# Qt dlls. Marco arguments should be preliminary packed inside variable. The +# variable name then should be used as an execute_process_args_var argument: +# +# set(execute_echo_command +# ${CMAKE_COMMAND} -E echo [["Test _qt_internal_execute_proccess_in_qt_env"]] +# ) +# _qt_internal_execute_proccess_in_qt_env(execute_echo_command) +# +macro(_qt_internal_execute_proccess_in_qt_env execute_process_args_var) + if(CMAKE_HOST_WIN32) + _qt_internal_collect_tool_paths(path_dirs) + set(_qt_internal_execute_proccess_in_qt_env_path_backup "$ENV{PATH}") + set(ENV{PATH} "$ENV{PATH};${path_dirs}") + endif() + # We avoid escaping issues this way. + execute_process(${${execute_process_args_var}}) + if(CMAKE_HOST_WIN32) + set(ENV{PATH} "${path_backup}") + unset(_qt_internal_execute_proccess_in_qt_env_path_backup) + endif() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicWalkLibsHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicWalkLibsHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d2b484d593be9a745373e951392243c21e41d9bf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicWalkLibsHelpers.cmake @@ -0,0 +1,342 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Add libraries to variable ${out_libs_var} in a way that duplicates +# are added at the end. This ensures the library order needed for the +# linker. +function(__qt_internal_merge_libs out_libs_var) + foreach(dep ${ARGN}) + list(REMOVE_ITEM ${out_libs_var} ${dep}) + list(APPEND ${out_libs_var} ${dep}) + endforeach() + set(${out_libs_var} ${${out_libs_var}} PARENT_SCOPE) +endfunction() + + +# Extracts value from per-target dict key and assigns it to out_var. +# Assumes dict_name to be an existing INTERFACE target. +function(__qt_internal_get_dict_key_values out_var target_infix dict_name dict_key) + get_target_property(values "${dict_name}" "INTERFACE_${target_infix}_${dict_key}") + set(${out_var} "${values}" PARENT_SCOPE) +endfunction() + + +# Assigns 'values' to per-target dict key, including for aliases of the target. +# Assumes dict_name to be an existing INTERFACE target. +function(__qt_internal_memoize_values_in_dict target dict_name dict_key values) + # Memoize the computed values for the target as well as its aliases. + # + # Aka assigns the contents of ${values} to INTERFACE_Core, INTERFACE_Qt::Core, + # INTERFACE_Qt6::Core. + # + # Yes, i know it's crazy that target names are legal property names. + # + # Assigning for library aliases is needed to avoid multiple recomputation of values. + # Scenario in the context of __qt_internal_walk_libs: + # 'values' are computed for Core target and memoized to INTERFACE_Core. + # When processing Gui, it depends on Qt::Core, but there are no values for INTERFACE_Qt::Core. + set_target_properties(${dict_name} PROPERTIES INTERFACE_${target}_${dict_key} "${values}") + + get_target_property(versionless_alias "${target}" "_qt_versionless_alias") + if(versionless_alias) + __qt_internal_get_dict_key_values( + versionless_values "${versionless_alias}" "${dict_name}" "${dict_key}") + if(versionless_values MATCHES "-NOTFOUND$") + set_target_properties(${dict_name} + PROPERTIES INTERFACE_${versionless_alias}_${dict_key} "${values}") + endif() + endif() + + get_target_property(versionfull_alias "${target}" "_qt_versionfull_alias") + if(versionfull_alias) + __qt_internal_get_dict_key_values( + versionfull_values "${versionfull_alias}" "${dict_name}" "${dict_key}") + if(versionfull_values MATCHES "-NOTFOUND$") + set_target_properties(${dict_name} + PROPERTIES INTERFACE_${versionfull_alias}_${dict_key} "${values}") + endif() + endif() +endfunction() + + +# Walks a target's public link libraries recursively, and performs some actions (poor man's +# polypmorphism) +# +# Walks INTERFACE_LINK_LIBRARIES for all target types, as well as LINK_LIBRARIES for static +# library targets. +# +# out_var: the name of the variable where the result will be assigned. The result is a list of +# libraries, mostly in generator expression form. +# rcc_objects_out_var: the name of the variable where the collected rcc object files will be +# assigned (for the initial target and its dependencies) +# dict_name: used for caching the results, and preventing the same target from being processed +# twice +# operation: a string to tell the function what additional behaviors to execute. +# 'collect_libs' (default) operation is to collect linker file paths and flags. +# Used for prl file generation. +# 'promote_3rd_party_global' promotes walked 3rd party imported targets to global scope. +# 'collect_targets' collects all target names (discards framework or link flags) +# 'direct_targets' collects only the direct target names (discards framework or link +# flags) +# +# +function(__qt_internal_walk_libs + target out_var rcc_objects_out_var dict_name operation) + set(collected ${ARGN}) + if(target IN_LIST collected) + return() + endif() + list(APPEND collected ${target}) + + if(operation MATCHES "^direct") + set(direct TRUE) + else() + set(direct FALSE) + endif() + + if(target STREQUAL "${QT_CMAKE_EXPORT_NAMESPACE}::EntryPointPrivate") + # We can't (and don't need to) process EntryPointPrivate because it brings in + # $ genexes which get replaced with + # $ genexes in the code below and that causes + # 'INTERFACE_LIBRARY targets may only have whitelisted properties.' errors with CMake + # versions equal to or lower than 3.18. These errors are super unintuitive to debug + # because there's no mention that it's happening during a file(GENERATE) call. + return() + endif() + + if(NOT TARGET ${dict_name}) + add_library(${dict_name} INTERFACE IMPORTED GLOBAL) + endif() + __qt_internal_get_dict_key_values(libs "${target}" "${dict_name}" "libs") + __qt_internal_get_dict_key_values(rcc_objects "${target}" "${dict_name}" "rcc_objects") + + if(libs MATCHES "-NOTFOUND$") + unset(libs) + unset(rcc_objects) + get_target_property(target_libs ${target} INTERFACE_LINK_LIBRARIES) + if(NOT target_libs) + unset(target_libs) + endif() + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "STATIC_LIBRARY") + get_target_property(link_libs ${target} LINK_LIBRARIES) + if(link_libs) + list(APPEND target_libs ${link_libs}) + endif() + endif() + + # Need to record the rcc object file info not only for dependencies, but also for + # the current target too. Otherwise the saved information is incomplete for prl static + # build purposes. + get_target_property(main_target_rcc_objects ${target} _qt_rcc_objects) + if(main_target_rcc_objects) + __qt_internal_merge_libs(rcc_objects ${main_target_rcc_objects}) + endif() + + foreach(lib ${target_libs}) + # Cannot use $ in add_custom_command. + # Check the policy now, and replace the generator expression with the value. + while(lib MATCHES "\\$]+)>") + cmake_policy(GET ${CMAKE_MATCH_1} value) + if(value STREQUAL "NEW") + set(value "TRUE") + else() + set(value "FALSE") + endif() + string(REPLACE "${CMAKE_MATCH_0}" "${value}" lib "${lib}") + endwhile() + + # Fix up $ expressions that refer to the "current" target. + # Those cannot be used with add_custom_command. + while(lib MATCHES "\\$]+)>") + string(REPLACE "${CMAKE_MATCH_0}" "$" + lib "${lib}") + endwhile() + + # Skip static plugins. + set(_is_plugin_marker_genex "\\$") + if(lib MATCHES "${_is_plugin_marker_genex}") + continue() + endif() + + # Skip optional dependencies for now. They are likely to be handled manually for prl + # file purposes (like nolink handling). And for one of the other operations, we don't + # have a use case yet. This might be revisited. + if(lib MATCHES "^\\$$") + set(lib_target ${CMAKE_MATCH_1}) + else() + set(lib_target ${lib}) + endif() + + # Skip CMAKE_DIRECTORY_ID_SEP. If a target_link_libraries is applied to a target + # that was defined in a different scope, CMake appends and prepends a special directory + # id separator. Filter those out. + if(lib_target MATCHES "^::@") + continue() + elseif(TARGET ${lib_target}) + if(NOT "${lib_target}" MATCHES "^(Qt|${QT_CMAKE_EXPORT_NAMESPACE})::.+") + # If both, Qt::Foo and Foo targets exist, prefer the target name with versioned + # namespace. Which one is preferred doesn't really matter. This code exists to + # avoid ending up with both, Qt::Foo and Foo in our dependencies. + set(versioned_qt_target "${QT_CMAKE_EXPORT_NAMESPACE}::${lib_target}") + if(TARGET "${versioned_qt_target}") + set(lib_target ${versioned_qt_target}) + endif() + endif() + get_target_property(lib_target_type ${lib_target} TYPE) + if(lib_target_type STREQUAL "INTERFACE_LIBRARY") + if(NOT ${direct}) + __qt_internal_walk_libs( + ${lib_target} + lib_libs_${target} + lib_rcc_objects_${target} + "${dict_name}" "${operation}" ${collected}) + if(lib_libs_${target}) + __qt_internal_merge_libs(libs ${lib_libs_${target}}) + set(is_module 0) + endif() + if(lib_rcc_objects_${target}) + __qt_internal_merge_libs(rcc_objects ${lib_rcc_objects_${target}}) + endif() + else() + __qt_internal_merge_libs(libs ${lib}) + endif() + elseif(NOT lib_target_type STREQUAL "OBJECT_LIBRARY") + + if(operation MATCHES "^(collect|direct)_targets$") + __qt_internal_merge_libs(libs ${lib_target}) + else() + __qt_internal_merge_libs(libs "$") + endif() + + get_target_property(target_rcc_objects "${lib_target}" _qt_rcc_objects) + if(target_rcc_objects) + __qt_internal_merge_libs(rcc_objects ${target_rcc_objects}) + endif() + + if(NOT ${direct}) + __qt_internal_walk_libs( + ${lib_target} + lib_libs_${target} + lib_rcc_objects_${target} + "${dict_name}" "${operation}" ${collected}) + endif() + if(lib_libs_${target}) + __qt_internal_merge_libs(libs ${lib_libs_${target}}) + endif() + if(lib_rcc_objects_${target}) + __qt_internal_merge_libs(rcc_objects ${lib_rcc_objects_${target}}) + endif() + endif() + if(operation STREQUAL "promote_3rd_party_global") + set(lib_target_unaliased "${lib_target}") + get_target_property(aliased_target ${lib_target} ALIASED_TARGET) + if(aliased_target) + set(lib_target_unaliased ${aliased_target}) + endif() + + get_property(is_imported TARGET ${lib_target_unaliased} PROPERTY IMPORTED) + + # Allow opting out of promotion. This is useful in certain corner cases + # like with WrapLibClang and Threads in qttools. + _qt_internal_should_not_promote_package_target_to_global( + "${lib_target_unaliased}" should_not_promote) + if(is_imported AND NOT should_not_promote) + _qt_internal_promote_3rd_party_target_to_global( + ${lib_target_unaliased}) + endif() + endif() + elseif("${lib_target}" MATCHES "^(Qt|${QT_CMAKE_EXPORT_NAMESPACE})::(.*)") + if(QT_BUILDING_QT OR QT_BUILD_STANDALONE_TESTS) + set(message_type FATAL_ERROR) + set(message_addition "") + else() + set(message_type WARNING) + set(message_addition " The linking might be incomplete.") + endif() + message(${message_type} "The ${CMAKE_MATCH_2} target is mentioned as a dependency" + " for ${target}, but not declared.${message_addition}") + else() + if(NOT operation MATCHES "^(collect|direct)_targets$") + set(final_lib_name_to_merge "${lib_target}") + if(lib_target MATCHES "/([^/]+).framework$") + set(final_lib_name_to_merge "-framework ${CMAKE_MATCH_1}") + endif() + __qt_internal_merge_libs(libs "${final_lib_name_to_merge}") + endif() + endif() + endforeach() + __qt_internal_memoize_values_in_dict("${target}" "${dict_name}" "libs" "${libs}") + __qt_internal_memoize_values_in_dict("${target}" "${dict_name}" + "rcc_objects" "${rcc_objects}") + + endif() + set(${out_var} ${libs} PARENT_SCOPE) + set(${rcc_objects_out_var} ${rcc_objects} PARENT_SCOPE) +endfunction() + +function(__qt_internal_print_missing_dependency_target_warning target dep) + if(QT_SILENCE_MISSING_DEPENDENCY_TARGET_WARNING) + return() + endif() + message(WARNING + "When trying to collect dependencies of target '${target}', " + "the non-existent target '${dep}' was encountered. " + "This can likely be fixed by moving the find_package call that pulls in " + "'${dep}' to the scope of directory '${CMAKE_CURRENT_LIST_DIR}' or higher. " + "This warning can be silenced by setting QT_SILENCE_MISSING_DEPENDENCY_TARGET_WARNING to " + "ON.") +endfunction() + +# Given ${target}, collect all its private dependencies that are CMake targets. +# +# Discards non-CMake-target dependencies like linker flags or file paths. +# Does nothing when given an interface library. +# +# To be used to extract the full list of target dependencies of a library or executable. +function(__qt_internal_collect_all_target_dependencies target out_var) + set(dep_targets "") + + get_target_property(target_type ${target} TYPE) + + if(NOT target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(link_libs ${target} LINK_LIBRARIES) + if(link_libs) + foreach(lib ${link_libs}) + if(TARGET "${lib}") + list(APPEND dep_targets "${lib}") + + __qt_internal_walk_libs( + "${lib}" + lib_walked_targets + _discarded_out_var + "qt_private_link_library_targets" + "collect_targets") + + foreach(lib_target IN LISTS lib_walked_targets) + if(NOT TARGET "${lib_target}") + __qt_internal_print_missing_dependency_target_warning(${target} + ${lib_target}) + continue() + endif() + list(APPEND dep_targets ${lib_target}) + endforeach() + endif() + endforeach() + endif() + endif() + + list(REMOVE_DUPLICATES dep_targets) + + set(${out_var} "${dep_targets}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicWasmToolchainHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicWasmToolchainHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..206afba032594dd5ccede31becf5e13cd0343839 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtPublicWasmToolchainHelpers.cmake @@ -0,0 +1,106 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Assuming EMSDK == /path/emsdk +# +# Then we expect /path/emsdk/.emscripten file to contain the following line +# EMSCRIPTEN_ROOT = emsdk_path + '/upstream/emscripten' +# +# then we set out_var to '/upstream/emscripten', so it's not a full path +function(__qt_internal_get_emroot_path_suffix_from_emsdk_env out_var) + # Query EMSCRIPTEN_ROOT path. + file(READ "$ENV{EMSDK}/.emscripten" ver) + string(REGEX MATCH "EMSCRIPTEN_ROOT.*$" EMROOT "${ver}") + string(REGEX MATCH "'([^' ]*)'" EMROOT2 "${EMROOT}") + string(REPLACE "'" "" EMROOT_PATH "${EMROOT2}") + + set(${out_var} "${EMROOT_PATH}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_get_emscripten_cmake_toolchain_file_path_from_emsdk_env emroot_path out_var) + set(wasm_toolchain_file "$ENV{EMSDK}/${emroot_path}/cmake/Modules/Platform/Emscripten.cmake") + set(${out_var} "${wasm_toolchain_file}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_query_emsdk_version emroot_path is_fatal out_var) + # get emscripten version + if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") + set(EXECUTE_COMMANDPATH "$ENV{EMSDK}/${emroot_path}/emcc.bat") + else() + set(EXECUTE_COMMANDPATH "$ENV{EMSDK}/${emroot_path}/emcc") + endif() + + file(TO_CMAKE_PATH "${EXECUTE_COMMANDPATH}" EXECUTE_COMMAND) + execute_process(COMMAND ${EXECUTE_COMMAND} --version + OUTPUT_VARIABLE emOutput + OUTPUT_STRIP_TRAILING_WHITESPACE + ERROR_VARIABLE emrun_error + RESULT_VARIABLE result) + message(DEBUG "emcc --version output: ${emOutput}") + + if(NOT emOutput) + if(is_fatal) + message(FATAL_ERROR + "Couldn't determine Emscripten version from running ${EXECUTE_COMMAND} --version. " + "Error: ${emrun_error}") + endif() + set(${out_var} "" PARENT_SCOPE) + else() + string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" CMAKE_EMSDK_REGEX_VERSION "${emOutput}") + set(${out_var} "${CMAKE_EMSDK_REGEX_VERSION}" PARENT_SCOPE) + endif() +endfunction() + +function(__qt_internal_get_emcc_recommended_version out_var) + # This version of Qt needs this version of emscripten. + set(QT_EMCC_RECOMMENDED_VERSION "3.1.56") + set(${out_var} "${QT_EMCC_RECOMMENDED_VERSION}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_show_error_no_emscripten_toolchain_file_found_when_building_qt) + message(FATAL_ERROR + "Cannot find the toolchain file Emscripten.cmake. " + "Please specify the toolchain file with -DCMAKE_TOOLCHAIN_FILE= " + "or provide a path to a valid emscripten installation via the EMSDK " + "environment variable.") +endfunction() + +function(__qt_internal_show_error_no_emscripten_toolchain_file_found_when_using_qt) + message(FATAL_ERROR + "Cannot find the toolchain file Emscripten.cmake. " + "Please specify the toolchain file with -DQT_CHAINLOAD_TOOLCHAIN_FILE= " + "or provide a path to a valid emscripten installation via the EMSDK " + "environment variable.") +endfunction() + +function(__qt_internal_get_qt_build_emsdk_version out_var) + if(QT6_INSTALL_PREFIX) + set(WASM_BUILD_DIR "${QT6_INSTALL_PREFIX}") + elseif(QT_BUILD_DIR) + set(WASM_BUILD_DIR "${QT_BUILD_DIR}") + endif() + if(EXISTS "${WASM_BUILD_DIR}/src/corelib/global/qconfig.h") + file(READ "${WASM_BUILD_DIR}/src/corelib/global/qconfig.h" ver) + elseif(EXISTS "${WASM_BUILD_DIR}/include/QtCore/qconfig.h") + file(READ "${WASM_BUILD_DIR}/include/QtCore/qconfig.h" ver) + endif() + if (ver) + string(REGEX MATCH "#define QT_EMCC_VERSION.\"[0-9]+\\.[0-9]+\\.[0-9]+\"" emOutput ${ver}) + string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" build_emcc_version "${emOutput}") + set(${out_var} "${build_emcc_version}" PARENT_SCOPE) + endif() +endfunction() + +function(_qt_test_emscripten_version) + __qt_internal_get_emcc_recommended_version(_recommended_emver) + __qt_internal_get_emroot_path_suffix_from_emsdk_env(emroot_path) + __qt_internal_query_emsdk_version("${emroot_path}" TRUE current_emsdk_ver) + __qt_internal_get_qt_build_emsdk_version(qt_build_emcc_version) + + if(NOT "${qt_build_emcc_version}" STREQUAL "" AND NOT "${qt_build_emcc_version}" STREQUAL "${current_emsdk_ver}") + message("Qt Wasm built with Emscripten version: ${qt_build_emcc_version}") + message("You are using Emscripten version: ${current_emsdk_ver}") + message("The recommended version of Emscripten for this Qt is: ${_recommended_emver}") + message("This may not work correctly") + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtQmakeHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtQmakeHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..80a916981eb6a4de715d6a30c7b4930167a54285 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtQmakeHelpers.cmake @@ -0,0 +1,251 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Create a QMake list (values space-separated) containing paths. +# Entries that contain whitespace characters are quoted. +function(qt_to_qmake_path_list out_var) + set(quoted_paths "") + foreach(path ${ARGN}) + if(path MATCHES "[ \t]") + list(APPEND quoted_paths "\"${path}\"") + else() + list(APPEND quoted_paths "${path}") + endif() + endforeach() + list(JOIN quoted_paths " " result) + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + + +function(qt_generate_qconfig_cpp in_file out_file) + set(QT_CONFIG_STRS "") + + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_DOCDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_INCLUDEDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_LIBDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_LIBEXECDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_BINDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_PLUGINSDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_QMLDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_ARCHDATADIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_DATADIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_TRANSLATIONSDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_EXAMPLESDIR})qconfig\",\n") + string(APPEND QT_CONFIG_STRS " R\"qconfig(${INSTALL_TESTSDIR})qconfig\"") + + # Settings path / sysconf dir. + set(QT_SYS_CONF_DIR "${INSTALL_SYSCONFDIR}") + + # Compute and set relocation prefixes. + if(WIN32) + set(lib_location_absolute_path + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_BINDIR}") + else() + set(lib_location_absolute_path + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_LIBDIR}") + endif() + file(RELATIVE_PATH from_lib_location_to_prefix + "${lib_location_absolute_path}" "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}") + set(QT_CONFIGURE_LIBLOCATION_TO_PREFIX_PATH "${from_lib_location_to_prefix}") + + # Ensure Windows drive letter is prepended to the install prefix hardcoded + # into qconfig.cpp, otherwise qmake can't find Qt modules in a static Qt + # build if there's no qt.conf. Mostly relevant for CI. + # Given input like + # \work/qt/install + # or + # \work\qt\install + # Expected output is something like + # C:/work/qt/install + # so it includes a drive letter and forward slashes. + if(QT_FEATURE_relocatable) + # A relocatable Qt does not need a hardcoded prefix path. + # This makes reproducible builds a closer reality, because we don't embed a CI path + # into the binaries. + set(QT_CONFIGURE_PREFIX_PATH_STR "") + else() + set(QT_CONFIGURE_PREFIX_PATH_STR "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}") + if(CMAKE_HOST_WIN32) + get_filename_component( + QT_CONFIGURE_PREFIX_PATH_STR + "${QT_CONFIGURE_PREFIX_PATH_STR}" REALPATH) + endif() + endif() + + configure_file(${in_file} ${out_file} @ONLY) +endfunction() + +# In the cross-compiling case, creates a wrapper around the host Qt's +# qmake and qtpaths executables. Also creates a qmake configuration file that sets +# up the host qmake's properties for cross-compiling with this Qt +# build. +function(qt_generate_qmake_and_qtpaths_wrapper_for_target) + if(NOT CMAKE_CROSSCOMPILING OR QT_NO_GENERATE_QMAKE_WRAPPER_FOR_TARGET) + return() + endif() + + # Call the configuration file something else but qt.conf to avoid + # being picked up by the qmake executable that's created if + # QT_FORCE_BUILD_TOOLS is enabled. + qt_path_join(qt_conf_path "${INSTALL_BINDIR}" "target_qt.conf") + + set(prefix "${CMAKE_INSTALL_PREFIX}") + set(ext_prefix "${QT_STAGING_PREFIX}") + set(host_prefix "${QT_HOST_PATH}") + file(RELATIVE_PATH host_prefix_relative_to_conf_file "${ext_prefix}/${INSTALL_BINDIR}" + "${host_prefix}") + file(RELATIVE_PATH ext_prefix_relative_to_conf_file "${ext_prefix}/${INSTALL_BINDIR}" + "${ext_prefix}") + file(RELATIVE_PATH ext_datadir_relative_to_host_prefix "${host_prefix}" + "${ext_prefix}/${INSTALL_MKSPECSDIR}/..") + + set(content "") + + # On Android CMAKE_SYSROOT is set, but from qmake's point of view it should not be set, because + # then qmake generates incorrect Qt module include flags (among other things). Do the same for + # darwin uikit cross-compilation. + set(sysroot "") + if(CMAKE_SYSROOT AND NOT ANDROID AND NOT UIKIT) + set(sysroot "${CMAKE_SYSROOT}") + endif() + + # Detect if automatic sysrootification should happen. All of the following must be true: + # sysroot is set (CMAKE_SYSRROT) + # prefix is set (CMAKE_INSTALL_PREFIX) + # extprefix is explicitly NOT set (CMAKE_STAGING_PREFIX, not QT_STAGING_PREFIX because that + # always ends up having a value) + if(NOT CMAKE_STAGING_PREFIX AND sysroot) + set(sysrootify_prefix true) + else() + set(sysrootify_prefix false) + if(NOT ext_prefix STREQUAL prefix) + string(APPEND content "[DevicePaths] +Prefix=${prefix} +") + endif() + endif() + + string(APPEND content + "[Paths] +Prefix=${ext_prefix_relative_to_conf_file} +Documentation=${INSTALL_DOCDIR} +Headers=${INSTALL_INCLUDEDIR} +Libraries=${INSTALL_LIBDIR} +LibraryExecutables=${INSTALL_LIBEXECDIR} +Binaries=${INSTALL_BINDIR} +Plugins=${INSTALL_PLUGINSDIR} +QmlImports=${INSTALL_QMLDIR} +ArchData=${INSTALL_ARCHDATADIR} +Data=${INSTALL_DATADIR} +Translations=${INSTALL_TRANSLATIONSDIR} +Examples=${INSTALL_EXAMPLESDIR} +Tests=${INSTALL_TESTSDIR} +Settings=${INSTALL_SYSCONFDIR} +HostPrefix=${host_prefix_relative_to_conf_file} +HostBinaries=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR} +HostLibraries=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBDIR} +HostLibraryExecutables=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR} +HostData=${ext_datadir_relative_to_host_prefix} +Sysroot=${sysroot} +SysrootifyPrefix=${sysrootify_prefix} +TargetSpec=${QT_QMAKE_TARGET_MKSPEC} +HostSpec=${QT_QMAKE_HOST_MKSPEC} +") + file(GENERATE OUTPUT "${qt_conf_path}" CONTENT "${content}") + qt_install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${qt_conf_path}" + DESTINATION "${INSTALL_BINDIR}") + + if(QT_GENERATE_WRAPPER_SCRIPTS_FOR_ALL_HOSTS) + set(hosts "unix" "non-unix") + elseif(CMAKE_HOST_UNIX) + set(hosts "unix") + else() + set(hosts "non-unix") + endif() + + set(wrapper_prefix) + if(QT_FORCE_BUILD_TOOLS) + # Avoid collisions with the cross-compiled qmake/qtpaths binaries. + set(wrapper_prefix "host-") + endif() + + set(host_qt_bindir "${host_prefix}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}") + file(TO_NATIVE_PATH "${host_qt_bindir}" host_qt_bindir) + + if(QT_CREATE_VERSIONED_HARD_LINK AND QT_WILL_INSTALL) + set(tool_version "${PROJECT_VERSION_MAJOR}") + endif() + + foreach(host_type ${hosts}) + foreach(tool_name qmake qtpaths) + set(wrapper_extension) + set(newline_style LF) + + if(host_type STREQUAL "non-unix") + set(wrapper_extension ".bat") + set(newline_style CRLF) + endif() + + set(wrapper_in_file + "${CMAKE_CURRENT_SOURCE_DIR}/bin/qmake-and-qtpaths-wrapper${wrapper_extension}.in") + + set(wrapper "preliminary/${wrapper_prefix}${tool_name}${wrapper_extension}") + configure_file("${wrapper_in_file}" "${wrapper}" @ONLY NEWLINE_STYLE ${newline_style}) + qt_copy_or_install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/${wrapper}" + DESTINATION "${INSTALL_BINDIR}") + + # Configuring a new wrapper file, this type setting the tool_version + if(QT_CREATE_VERSIONED_HARD_LINK AND QT_WILL_INSTALL) + set(versioned_wrapper "preliminary/${wrapper_prefix}${tool_name}${tool_version}${wrapper_extension}") + configure_file("${wrapper_in_file}" "${versioned_wrapper}" @ONLY NEWLINE_STYLE ${newline_style}) + qt_copy_or_install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/${versioned_wrapper}" + DESTINATION "${INSTALL_BINDIR}") + endif() + endforeach() + endforeach() +endfunction() + +# Transforms a CMake Qt module name to a qmake Qt module name. +# Example: Qt6FooPrivate becomes foo_private +function(qt_get_qmake_module_name result module) + string(REGEX REPLACE "^Qt6" "" module "${module}") + string(REGEX REPLACE "Private$" "_private" module "${module}") + string(REGEX REPLACE "Qpa$" "_qpa_lib_private" module "${module}") + string(REGEX REPLACE "Rhi$" "_rhi_lib_private" module "${module}") + string(REGEX REPLACE "Ssg$" "_ssg_lib_private" module "${module}") + string(TOLOWER "${module}" module) + set(${result} ${module} PARENT_SCOPE) +endfunction() + +function(qt_cmake_build_type_to_qmake_build_config out_var build_type) + if(build_type STREQUAL "Debug") + set(cfg debug) + else() + set(cfg release) + endif() + set(${out_var} ${cfg} PARENT_SCOPE) +endfunction() + +function(qt_guess_qmake_build_config out_var) + if(QT_GENERATOR_IS_MULTI_CONFIG) + unset(cfg) + foreach(config_type ${CMAKE_CONFIGURATION_TYPES}) + qt_cmake_build_type_to_qmake_build_config(tmp ${config_type}) + list(APPEND cfg ${tmp}) + endforeach() + if(cfg) + list(REMOVE_DUPLICATES cfg) + else() + set(cfg debug) + endif() + else() + qt_cmake_build_type_to_qmake_build_config(cfg ${CMAKE_BUILD_TYPE}) + endif() + set(${out_var} ${cfg} PARENT_SCOPE) +endfunction() + +macro(qt_add_qmake_lib_dependency lib dep) + string(REPLACE "-" "_" dep ${dep}) + string(TOUPPER "${dep}" ucdep) + list(APPEND QT_QMAKE_LIB_DEPS_${lib} ${ucdep}) +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtResourceHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtResourceHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e6eea0e3d4e865bce7e47704d953995d488da0f1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtResourceHelpers.cmake @@ -0,0 +1,133 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +function(qt_internal_add_resource target resourceName) + if(NOT TARGET "${target}") + message(FATAL_ERROR "${target} is not a target.") + endif() + qt_internal_is_skipped_test(skipped ${target}) + if(skipped) + return() + endif() + qt_internal_is_in_test_batch(in_batch ${target}) + if(in_batch) + _qt_internal_test_batch_target_name(target) + endif() + + # Don't try to add resources when cross compiling, and the target is actually a host target + # (like a tool). + qt_is_imported_target("${target}" is_imported) + if(is_imported) + return() + endif() + + cmake_parse_arguments(PARSE_ARGV 2 arg + "" + "PREFIX;LANG;BASE;OUTPUT_TARGETS" + "FILES") + _qt_internal_validate_all_args_are_parsed(arg) + + _qt_internal_process_resource(${target} ${resourceName} + PREFIX "${arg_PREFIX}" + LANG "${arg_LANG}" + BASE "${arg_BASE}" + FILES ${arg_FILES} + OUTPUT_TARGETS out_targets + ) + + if (out_targets) + qt_install(TARGETS ${out_targets} + EXPORT "${INSTALL_CMAKE_NAMESPACE}${target}Targets" + DESTINATION "${INSTALL_LIBDIR}" + ) + qt_internal_add_targets_to_additional_targets_export_file( + TARGETS ${out_targets} + EXPORT_NAME_PREFIX "${INSTALL_CMAKE_NAMESPACE}${target}" + ) + + qt_internal_install_resource_pdb_files("${out_targets}") + qt_internal_record_rcc_object_files("${target}" "${out_targets}" + INSTALL_DIRECTORY "${INSTALL_LIBDIR}") + endif() + + if (arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} "${out_targets}" PARENT_SCOPE) + endif() +endfunction() + +function(qt_internal_record_rcc_object_files target resource_targets) + set(args_optional "") + set(args_single INSTALL_DIRECTORY) + set(args_multi "") + + cmake_parse_arguments(arg + "${args_optional}" + "${args_single}" + "${args_multi}" + ${ARGN} + ) + + foreach(out_target ${resource_targets}) + get_target_property(resource_name ${out_target} _qt_resource_name) + if(NOT resource_name) + continue() + endif() + if(QT_WILL_INSTALL) + # Compute the install location of a resource object file in a prefix build. + # It's comprised of thee following path parts: + # + # part (1) INSTALL_DIRECTORY. + # A usual value is '${INSTALL_LIBDIR}/' for libraries + # and '${INSTALL_QMLDIR}/foo/bar/' for qml plugin resources. + # + # part (2) the value computed by CMake's computeInstallObjectDir comprised of an + # objects- dir and the target name of the object library. + # Example: objects-$/Gui_resources_qpdf + # + # part (3) path to the object file, relative to it's build directory. + # Example: .rcc/qrc_qpdf.cpp.o + # + # The final path is relative to CMAKE_INSTALL_PREFIX aka $qt_install_prefix. + # + # The relative path will be transformed into an absolute path when generating .prl + # files, by prepending $$[QT_INSTALL_PREFIX]/. + get_target_property(generated_cpp_file_relative_path + ${out_target} + _qt_resource_generated_cpp_relative_path) + + set(object_file_name "${generated_cpp_file_relative_path}${CMAKE_CXX_OUTPUT_EXTENSION}") + qt_path_join(rcc_object_file_path + "objects-$" ${out_target} "${object_file_name}") + if(arg_INSTALL_DIRECTORY) + qt_path_join(rcc_object_file_path + "${arg_INSTALL_DIRECTORY}" "${rcc_object_file_path}") + else() + message(FATAL_ERROR "No install location given for object files to be installed" + " for the following resource target: '${out_target}'") + endif() + else() + # In a non-prefix build we use the object file paths right away. + set(rcc_object_file_path $>) + endif() + set_property(TARGET ${target} APPEND PROPERTY _qt_rcc_objects "${rcc_object_file_path}") + + qt_internal_link_internal_platform_for_object_library("${out_target}") + endforeach() +endfunction() + +function(qt_internal_install_resource_pdb_files objlib_targets) + if(NOT MSVC OR NOT QT_WILL_INSTALL) + return() + endif() + + foreach(target IN LISTS objlib_targets) + qt_internal_set_compile_pdb_names(${target}) + + get_target_property(generated_cpp_file_relative_path + ${target} + _qt_resource_generated_cpp_relative_path) + get_filename_component(rel_obj_file_dir "${generated_cpp_file_relative_path}" DIRECTORY) + qt_internal_install_pdb_files(${target} + "${INSTALL_LIBDIR}/objects-$/${target}/${rel_obj_file_dir}") + endforeach() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtRpathHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtRpathHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a346ca1b45a8c4974210829e0e83cbfb4250b535 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtRpathHelpers.cmake @@ -0,0 +1,289 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Returns the platform-specific relative rpath base token, if it's supported. +# If it's not supported, returns the string NO_KNOWN_RPATH_REL_BASE. +function(qt_internal_get_relative_rpath_base_token out_var) + if(APPLE) + set(rpath_rel_base "@loader_path") + elseif(LINUX OR SOLARIS OR FREEBSD OR HURD OR OPENBSD) + set(rpath_rel_base "$ORIGIN") + else() + set(rpath_rel_base "NO_KNOWN_RPATH_REL_BASE") + endif() + set(${out_var} "${rpath_rel_base}" PARENT_SCOPE) +endfunction() + +# Computes a relative rpath between ${rpath} and ${install_location} using tokens +# like $ORIGIN / @loader_path +# Not all platforms support such tokens though, in which case the returned rpath will be invalid. +# +# install_location: a directory relative to CMAKE_INSTALL_PREFIX, where the binary will be installed +# rpath: an rpath to embed, can be either an absolute path or a path relative to +# ${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBDIR}. +function(qt_compute_relative_rpath_base rpath install_location out_var) + set(install_lib_dir_absolute "${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBDIR}") + get_filename_component(rpath_absolute "${rpath}" + ABSOLUTE BASE_DIR "${install_lib_dir_absolute}") + + set(install_location_absolute "${install_location}") + if(NOT IS_ABSOLUTE "${install_location_absolute}") + set(install_location_absolute "${CMAKE_INSTALL_PREFIX}/${install_location}") + endif() + # Compute relative rpath from where the target will be installed, to the place where libraries + # will be placed (INSTALL_LIBDIR). + file(RELATIVE_PATH rpath_relative "${install_location_absolute}" "${rpath_absolute}") + + if("${rpath_relative}" STREQUAL "") + # file(RELATIVE_PATH) returns an empty string if the given absolute paths are equal + set(rpath_relative ".") + endif() + + # Prepend $ORIGIN / @loader_path style tokens (qmake's QMAKE_REL_RPATH_BASE), to make the + # relative rpaths work. qmake does this automatically when generating a project, so it wasn't + # needed in the .prf files, but for CMake we need to prepend them ourselves. + qt_internal_get_relative_rpath_base_token(rpath_rel_base) + if(rpath_rel_base STREQUAL "NO_KNOWN_RPATH_REL_BASE") + message(WARNING "No known RPATH_REL_BASE for target platform.") + endif() + + if(rpath_relative STREQUAL ".") + set(rpath_relative "${rpath_rel_base}") + else() + set(rpath_relative "${rpath_rel_base}/${rpath_relative}") + endif() + + set("${out_var}" "${rpath_relative}" PARENT_SCOPE) +endfunction() + +# Applies necessary rpaths to a target upon target installation. +# No-op when targeting Windows, Android. +# +# Since abf72395411b135054b5820f64f93dfbcda430b8 rpaths are also applied in non-prefix builds, +# to address -rpath-link issues when cross-compiling, although this might not be needed anymore +# due to 606124c5cceba0dd4a406a9278588b58bb9f9800. +# See QTBUG-86533 for the whole saga. +# +# If no RELATIVE_RPATH option is given, embeds an absolute path rpath to +# ${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBDIR} into the target. + +# If RELATIVE_RPATH is given, the INSTALL_PATH value is used to compute the relative path from +# ${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBDIR} to wherever the target will be installed +# (the value of INSTALL_PATH). +# INSTALL_PATH is expected to be a relative directory where the binary / library will be installed. + +# RELATIVE_RPATH is the equivalent of qmake's relative_qt_rpath. +# INSTALL_PATH is used to implement the equivalent of qmake's $$qtRelativeRPathBase(). +# +# QT_DISABLE_RPATH can be set to disable embedding any Qt specific rpaths. +function(qt_apply_rpaths) + # No rpath support for win32 and android. + if(WIN32 OR ANDROID) + return() + endif() + + # Rpaths explicitly disabled (like for uikit), equivalent to qmake's no_qt_rpath. + # Or feature was turned OFF. + if(QT_DISABLE_RPATH OR NOT QT_FEATURE_rpath) + return() + endif() + + cmake_parse_arguments(PARSE_ARGV 0 arg + "RELATIVE_RPATH" + "TARGET;INSTALL_PATH" + "") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_TARGET) + message(FATAL_ERROR "No target given to qt_apply_rpaths.") + else() + set(target "${arg_TARGET}") + endif() + + # If a target is not built (which can happen for tools when crosscompiling, we shouldn't try + # to apply properties. + if(NOT TARGET "${target}") + return() + endif() + + # Protect against interface libraries. + get_target_property(target_type "${target}" TYPE) + if (target_type STREQUAL "INTERFACE_LIBRARY") + return() + endif() + + if(NOT arg_INSTALL_PATH) + message(FATAL_ERROR "No INSTALL_PATH given to qt_apply_rpaths.") + endif() + + set(rpaths "") + + # Modify the install path to contain the nested structure of a framework. + get_target_property(is_framework "${target}" FRAMEWORK) + if(is_framework) + qt_internal_get_framework_info(fw ${target}) + if(UIKIT) + # Shallow framework + string(APPEND arg_INSTALL_PATH "/${fw_dir}") + else() + # Full framework + string(APPEND arg_INSTALL_PATH "/${fw_dir}/Versions/Current") + endif() + endif() + + # Same but for an app bundle. + get_target_property(is_bundle "${target}" MACOSX_BUNDLE) + if(is_bundle AND NOT is_framework) + if(UIKIT) + # Shallow bundle + string(APPEND arg_INSTALL_PATH "/${target}.app") + else() + # Full bundle + string(APPEND arg_INSTALL_PATH "/${target}.app/Contents/MacOS") + endif() + endif() + + qt_internal_get_relative_rpath_base_token(rpath_base_token) + if(rpath_base_token STREQUAL "NO_KNOWN_RPATH_REL_BASE") + set(relative_rpath_supported FALSE) + else() + set(relative_rpath_supported TRUE) + endif() + + # Somewhat similar to mkspecs/features/qt.prf + # Embed either an absolute path to the installed Qt lib dir, or a relative one, based on + # where ${target} is installed. + # Don't embed relative rpaths if the platform does not support it. + if(arg_RELATIVE_RPATH AND relative_rpath_supported) + qt_compute_relative_rpath_base( + "${_default_install_rpath}" "${arg_INSTALL_PATH}" relative_rpath) + list(APPEND rpaths "${relative_rpath}") + else() + list(APPEND rpaths "${_default_install_rpath}") + endif() + + # Somewhat similar to mkspecs/features/qt_build_extra.prf. + foreach(rpath ${QT_EXTRA_RPATHS}) + if(IS_ABSOLUTE "${rpath}") + list(APPEND rpaths "${rpath}") + else() + if(relative_rpath_supported) + qt_compute_relative_rpath_base("${rpath}" "${arg_INSTALL_PATH}" relative_rpath) + list(APPEND rpaths "${relative_rpath}") + else() + # Any extra relative rpaths on a platform that does not support relative rpaths, + # need to be transformed into absolute ones. + set(install_lib_dir_absolute "${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBDIR}") + get_filename_component(rpath_absolute "${rpath}" + ABSOLUTE BASE_DIR "${install_lib_dir_absolute}") + list(APPEND rpaths "${rpath_absolute}") + endif() + endif() + endforeach() + + if(rpaths) + list(REMOVE_DUPLICATES rpaths) + if(QT_WILL_INSTALL) + set(prop_name "INSTALL_RPATH") + else() + set(prop_name "BUILD_RPATH") + endif() + set_property(TARGET "${target}" APPEND PROPERTY "${prop_name}" ${rpaths}) + endif() +endfunction() + +macro(qt_internal_set_default_rpath_settings) + # the default RPATH to be used when installing, but only if it's not a system directory + list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES + "${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBDIR}" isSystemDir) + if("${isSystemDir}" STREQUAL "-1") + set(_default_install_rpath "${CMAKE_INSTALL_PREFIX}/${INSTALL_LIBDIR}") + endif("${isSystemDir}" STREQUAL "-1") + + # The default rpath settings for installed targets is empty. + # The rpaths will instead be computed for each target separately using qt_apply_rpaths(). + # Additional rpaths can be passed via QT_EXTRA_RPATHS. + # By default this will include $ORIGIN / @loader_path, so the installation is relocatable. + # Bottom line: No need to pass anything to CMAKE_INSTALL_RPATH. + set(CMAKE_INSTALL_RPATH "" CACHE STRING "RPATH for installed binaries") + + # By default, don't embed auto-determined RPATHs pointing to directories + # outside of the build tree, into the installed binaries. + # This ended up adding rpaths like ${CMAKE_INSTALL_PREFIX}/lib (or /Users/qt/work/install/lib + # into the official libraries created by the CI) into the non-qtbase libraries, plugins, etc. + # + # It should not be necessary, given that qt_apply_rpaths() already adds the necessary rpaths, + # either relocatable ones or absolute ones, depending on what the platform supports. + if(NOT QT_NO_DISABLE_CMAKE_INSTALL_RPATH_USE_LINK_PATH) + set(CMAKE_INSTALL_RPATH_USE_LINK_PATH FALSE) + endif() + + # If Qt is built without rpath support, we should not add "user-project default rpaths" to + # qt qml plugins. Do this by setting QT_NO_QML_PLUGIN_RPATH to TRUE, which is + # then read by qt6_add_qml_plugin. + # We do this as part of the internal API, because we still want to allow user project qml + # plugins to have sensible default rpaths, even if Qt qml plugins were built without support + # for rpaths. + # + # Note that feature evaluation is not done yet in qtbase at this point, so we check both + # feature variable variants. In practice it doesn't really matter, because the variable is only + # read during qtdeclarative configuration time when the feature is already evaluated. + # + # We also make sure not to set it as a cache var just in case somebody wants to override it + # per directory scope. + if(NOT DEFINED QT_NO_QML_PLUGIN_RPATH + AND (QT_DISABLE_RPATH OR (NOT FEATURE_rpath) OR (NOT QT_FEATURE_rpath))) + set(QT_NO_QML_PLUGIN_RPATH "TRUE") + endif() +endmacro() + +# Overrides the CMAKE_STAGING_PREFIX in a subdirectory scope, to stop CMake from rewriting build +# rpaths to point into the original staging prefix, and thus breaking running executables from +# the build directory. +# See details at https://bugreports.qt.io/browse/QTBUG-102592 +# and https://gitlab.kitware.com/cmake/cmake/-/issues/23421 +# +# This macro is only meant to be called in functions like +# qt_internal_add_module / qt_internal_add_tool to ensure the variable is set in the +# subdirectory scope of the calling function, and not in the actual function scope (where the +# variable assignment would have no effect). +# +# This is the best workaround we can currently do, but it comes with the disadvantage that calling +# subdirectory-scoped install targets does not work anymore. +# e.g. calling ninja src/gui/install will try to install to the fake prefix and fail. +# A regular ninja install call works fine. +# +# Usage of this macro assumes there are no binaries or libraries added in the root CMakeLists.txt +# of the project because that would mean the macro is called at root level scope, which would +# break installation. +# +# The implementation has to be a macro, so we can propagate the variable into the calling +# subdirectory scope. The implementation can't use return(). +macro(qt_internal_apply_staging_prefix_build_rpath_workaround) + set(__qt_internal_should_apply_staging_prefix_build_rpath_workaround TRUE) + # Allow an opt out. + if(QT_NO_STAGING_PREFIX_BUILD_RPATH_WORKAROUND) + set(__qt_internal_should_apply_staging_prefix_build_rpath_workaround FALSE) + endif() + + # No need for workaround if CMAKE_STAGING_PREFIX is not set. + if(NOT CMAKE_STAGING_PREFIX) + set(__qt_internal_should_apply_staging_prefix_build_rpath_workaround FALSE) + endif() + + # No rpath support for win32, android, ios, so nothing to do. + if(WIN32 OR ANDROID OR UIKIT) + set(__qt_internal_should_apply_staging_prefix_build_rpath_workaround FALSE) + endif() + + # Set the staging prefix to a non-existent directory, which is unlikely to have permissions + # for installation. + # The verbose directory name is chosen to attract the user's attention in case if they end up + # calling a subdirectory-scope install file. + if(__qt_internal_should_apply_staging_prefix_build_rpath_workaround) + set_property(GLOBAL PROPERTY _qt_internal_staging_prefix_build_rpath_workaround TRUE) + set(CMAKE_STAGING_PREFIX + "/qt_fake_staging_prefix/check_qt_internal_apply_staging_prefix_build_rpath_workaround" + PARENT_SCOPE) + endif() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSanitizerHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSanitizerHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..76319d0af709e9436e33a80d4a57155ed6c45e8a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSanitizerHelpers.cmake @@ -0,0 +1,60 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Computes which sanitizer options should be set based on features evaluated in qtbase. +# Sets ECM_ENABLE_SANITIZERS with those options in the function calling scope. +function(qt_internal_set_up_sanitizer_options) + set(ECM_ENABLE_SANITIZERS "" CACHE STRING "Enable sanitizers") + set_property(CACHE ECM_ENABLE_SANITIZERS PROPERTY STRINGS + "address;memory;thread;undefined;fuzzer;fuzzer-no-link") + + # If QT_FEATURE_sanitize_foo was enabled, make sure to set the appropriate + # ECM_ENABLE_SANITIZERS value. + set(enabled_sanitizer_features "") + foreach(sanitizer_type address memory thread undefined) + if(QT_FEATURE_sanitize_${sanitizer_type}) + list(APPEND enabled_sanitizer_features "${sanitizer_type}") + endif() + endforeach() + + # There's a mismatch between fuzzer-no-link ECM option and fuzzer_no_link Qt feature. + if(QT_FEATURE_sanitize_fuzzer_no_link) + list(APPEND enabled_sanitizer_features "fuzzer-no-link") + endif() + + if(enabled_sanitizer_features) + set(ECM_ENABLE_SANITIZERS "${enabled_sanitizer_features}" PARENT_SCOPE) + endif() +endfunction() + +# This function clears the previously set sanitizer flags from CMAKE__FLAGS +function(qt_internal_skip_sanitizer) + if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR + CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR + CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + foreach(sanitizer ${ECM_ENABLE_SANITIZERS}) + string(TOLOWER "${sanitizer}" sanitizer) + enable_sanitizer_flags("${sanitizer}") + qt_internal_remove_compiler_flags(${XSAN_COMPILE_FLAGS}) + endforeach() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" PARENT_SCOPE) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" PARENT_SCOPE) + endif() +endfunction() + +# This function disables the sanitizer library linking to all targets created in a subdirectory +# where the function is called. Note that the function should be called after all involved targets +# are created, to make sure they are collected by the function. +function(qt_internal_skip_linking_sanitizer) + _qt_internal_collect_buildsystem_targets(all_targets "${CMAKE_CURRENT_SOURCE_DIR}" + INCLUDE + STATIC_LIBRARY + MODULE_LIBRARY + SHARED_LIBRARY + OBJECT_LIBRARY + EXECUTABLE + ) + foreach(t IN LISTS all_targets) + set_property(TARGET ${t} PROPERTY SKIP_SANITIZER TRUE) + endforeach() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSbomHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSbomHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4b18f87bf61fe1c843a517dd42bf5b873331789d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSbomHelpers.cmake @@ -0,0 +1,24 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# For now these are simple internal forwarding wrappers for the public counterparts, which are +# meant to be used in qt repo CMakeLists.txt files. +function(qt_internal_add_sbom) + _qt_internal_add_sbom(${ARGN}) +endfunction() + +function(qt_internal_extend_sbom) + _qt_internal_extend_sbom(${ARGN}) +endfunction() + +function(qt_internal_sbom_add_license) + _qt_internal_sbom_add_license(${ARGN}) +endfunction() + +function(qt_internal_extend_sbom_dependencies) + _qt_internal_extend_sbom_dependencies(${ARGN}) +endfunction() + +function(qt_find_package_extend_sbom) + _qt_find_package_extend_sbom(${ARGN}) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtScopeFinalizerHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtScopeFinalizerHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c080a1e4787158b969506147d4100b365406c739 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtScopeFinalizerHelpers.cmake @@ -0,0 +1,115 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Add a finalizer function for the current CMake list file. +# It will be processed just before leaving the current source directory scope. +# +# When using CMake 3.18 or lower: +# You may add up to nine arguments that are passed to the finalizer. +# A finalizer that is registered with qt_add_list_file_finalizer(foo bar baz) +# will be called with nine arguments: foo(bar baz IGNORE IGNORE IGNORE...), +# because CMake's handling of empty list elements is a cruel joke. +# For CMake < 3.18 the function qt_watch_current_list_dir must know about the finalizer. +# +# When using CMake 3.19 or higher, no more IGNORE parameters are passed. Instead we +# use cmake_language(DEFER CALL) and pass arguments as usual. +# qt_watch_current_list_dir also doesn't need to know about the finalizer +function(qt_add_list_file_finalizer func) + set(use_cmake_defer_call TRUE) + if(CMAKE_VERSION VERSION_LESS "3.19.0") + set(use_cmake_defer_call FALSE) + endif() + + if(use_cmake_defer_call) + cmake_language(EVAL CODE "cmake_language(DEFER CALL \"${func}\" ${ARGN}) ") + else() + set_property(GLOBAL APPEND + PROPERTY QT_LIST_FILE_FINALIZER_FILES "${CMAKE_CURRENT_LIST_FILE}") + set_property(GLOBAL APPEND + PROPERTY QT_LIST_FILE_FINALIZER_FUNCS ${func}) + foreach(i RANGE 1 9) + set(arg "${ARGV${i}}") + if(i GREATER_EQUAL ARGC OR "${arg}" STREQUAL "") + set(arg "IGNORE") + endif() + set_property(GLOBAL APPEND + PROPERTY QT_LIST_FILE_FINALIZER_ARGV${i} "${arg}") + endforeach() + endif() +endfunction() + +# Watcher function for the variable CMAKE_CURRENT_LIST_DIR. +# This is the driver of the finalizer facility. +function(qt_watch_current_list_dir variable access value current_list_file stack) + if(NOT access STREQUAL "MODIFIED_ACCESS") + # We are only interested in modifications of CMAKE_CURRENT_LIST_DIR. + return() + endif() + list(GET stack -1 stack_top) + if(stack_top STREQUAL current_list_file) + # If the top of the stack equals the current list file then + # we're entering a file. We're not interested in this case. + return() + endif() + get_property(files GLOBAL PROPERTY QT_LIST_FILE_FINALIZER_FILES) + if(NOT files) + return() + endif() + get_property(funcs GLOBAL PROPERTY QT_LIST_FILE_FINALIZER_FUNCS) + foreach(i RANGE 1 9) + get_property(args${i} GLOBAL PROPERTY QT_LIST_FILE_FINALIZER_ARGV${i}) + endforeach() + list(LENGTH files n) + set(i 0) + while(i LESS n) + list(GET files ${i} file) + if(file STREQUAL stack_top) + list(GET funcs ${i} func) + foreach(k RANGE 1 9) + list(GET args${k} ${i} a${k}) + endforeach() + # We've found a file we're looking for. Call the finalizer. + if(${CMAKE_VERSION} VERSION_LESS "3.18.0") + # Make finalizer known functions here: + if(func STREQUAL "qt_finalize_module") + qt_finalize_module(${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + elseif(func STREQUAL "qt_finalize_plugin") + qt_finalize_plugin(${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + elseif(func STREQUAL "qt_internal_finalize_app") + qt_internal_finalize_app(${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + elseif(func STREQUAL "qt_internal_finalize_tool") + qt_internal_finalize_tool(${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + elseif(func STREQUAL "qt_internal_finalize_3rdparty_library") + qt_internal_finalize_3rdparty_library( + ${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + elseif(func STREQUAL "qt_internal_export_additional_targets_file_finalizer") + qt_internal_export_additional_targets_file_finalizer( + ${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + elseif(func STREQUAL "_qt_internal_finalize_sbom") + _qt_internal_finalize_sbom( + ${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + elseif(func STREQUAL "qt6_finalize_target") + qt6_finalize_target( + ${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + else() + message(FATAL_ERROR "qt_watch_current_list_dir doesn't know about ${func}. Consider adding it.") + endif() + else() + cmake_language(CALL ${func} ${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9}) + endif() + list(REMOVE_AT files ${i}) + list(REMOVE_AT funcs ${i}) + foreach(k RANGE 1 9) + list(REMOVE_AT args${k} ${i}) + endforeach() + math(EXPR n "${n} - 1") + else() + math(EXPR i "${i} + 1") + endif() + endwhile() + set_property(GLOBAL PROPERTY QT_LIST_FILE_FINALIZER_FILES ${files}) + set_property(GLOBAL PROPERTY QT_LIST_FILE_FINALIZER_FUNCS ${funcs}) + foreach(i RANGE 1 9) + set_property(GLOBAL PROPERTY QT_LIST_FILE_FINALIZER_ARGV${i} "${args${i}}") + endforeach() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSeparateDebugInfo.Info.plist.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSeparateDebugInfo.Info.plist.in new file mode 100644 index 0000000000000000000000000000000000000000..55cd2dd19c08306bb418ee0a3fd2604b5e2c54e9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSeparateDebugInfo.Info.plist.in @@ -0,0 +1,21 @@ + + + + + + + CFBundleIdentifier + com.apple.xcode.dsym.${BUNDLE_ID} + CFBundlePackageType + dSYM + CFBundleSignature + ???? + CFBundleShortVersionString + ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR} + CFBundleVersion + ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH} + + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSeparateDebugInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSeparateDebugInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..10d4c6ad29ee1c844decb24dca06c503b615efb6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSeparateDebugInfo.cmake @@ -0,0 +1,323 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if(CMAKE_VERSION VERSION_LESS 3.17.0) +set(CMAKE_CURRENT_FUNCTION_LIST_DIR ${CMAKE_CURRENT_LIST_DIR}) +endif() + +# Builds a shared library which will have strip run on it. +function(qt_internal_try_compile_binary_for_strip binary_out_var) + # Need to find the config.tests files depending whether the qtbase sources are available. + # This mirrors the logic in qt_set_up_build_internals_paths. + # TODO: Clean this up, together with qt_set_up_build_internals_paths to only use the + # the qtbase sources when building qtbase. And perhaps also when doing a non-prefix + # developer-build. + + set(config_test_dir "config.tests/binary_for_strip") + set(qtbase_config_test_dir "${QT_SOURCE_TREE}/${config_test_dir}") + set(installed_config_test_dir + "${_qt_cmake_dir}/${QT_CMAKE_EXPORT_NAMESPACE}/${config_test_dir}") + + # qtbase sources available, always use them, regardless of prefix or non-prefix builds. + if(EXISTS "${qtbase_config_test_dir}") + set(src_dir "${qtbase_config_test_dir}") + + # qtbase sources unavailable, use installed files. + elseif(EXISTS "${installed_config_test_dir}") + set(src_dir "${installed_config_test_dir}") + else() + message(FATAL_ERROR "Can't find binary_for_strip config test project.") + endif() + + # Make sure the built project files are not installed when doing an in-source build (like it + # happens in Qt's CI) by choosing a build dir that does not coincide with the installed + # source dir. Otherwise the config test binaries will be packaged up, which we don't want. + set(binary_dir "${CMAKE_CURRENT_BINARY_DIR}/${config_test_dir}_built") + + set(flags "") + qt_get_platform_try_compile_vars(platform_try_compile_vars) + list(APPEND flags ${platform_try_compile_vars}) + + # CI passes the project dir of the Qt repository as absolute path without drive letter: + # \Users\qt\work\qt\qtbase + # Ensure that arg_PROJECT_PATH is an absolute path with drive letter: + # C:/Users/qt/work/qt/qtbase + # This works around CMake upstream issue #22534. + if(CMAKE_HOST_WIN32) + get_filename_component(src_dir "${src_dir}" REALPATH) + endif() + + # Build a real binary that strip can be run on. + try_compile(QT_INTERNAL_BUILT_BINARY_FOR_STRIP + "${binary_dir}" + "${src_dir}" + binary_for_strip # project name + OUTPUT_VARIABLE build_output + CMAKE_FLAGS ${flags} + ) + + # Retrieve the binary path from the build output. + string(REGEX REPLACE ".+###(.+)###.+" "\\1" output_binary_path "${build_output}") + + if(NOT EXISTS "${output_binary_path}") + message(FATAL_ERROR "Extracted binary path for strip does not exist: ${output_binary_path}") + endif() + + set(${binary_out_var} "${output_binary_path}" PARENT_SCOPE) +endfunction() + +# When using the MinGW 11.2.0 toolchain, cmake --install --strip as used by +# qt-cmake-private-install.cmake, removes the .gnu_debuglink section in binaries and thus +# breaks the separate debug info feature. +# +# Generate a wrapper shell script that passes an option to keep the debug section. +# The wrapper is used when targeting Linux or MinGW with a shared Qt build. +# The check to see if the option is supported by 'strip', is done once for every repo configured, +# because different machines might have different strip versions installed, without support for +# the option we need. +# +# Once CMake supports custom strip arguments, we can remove the part that creates a shell wrapper. +# https://gitlab.kitware.com/cmake/cmake/-/issues/23346 +function(qt_internal_generate_binary_strip_wrapper) + # Return early if check was done already, if explicitly skipped, or when building a static Qt. + if(DEFINED CACHE{QT_INTERNAL_STRIP_SUPPORTS_KEEP_SECTION} + OR QT_NO_STRIP_WRAPPER + OR (NOT QT_BUILD_SHARED_LIBS) + ) + return() + endif() + + # Backup the original strip path on very first configuration call. + # The value might have been determined by CMake via CMakeDetermineCXXCompiler -> + # CMakeFindBinUtils -> find_program(), or it might have been set by a toolchain file. + if(NOT QT_INTERNAL_ORIGINAL_CMAKE_STRIP AND CMAKE_STRIP) + set(QT_INTERNAL_ORIGINAL_CMAKE_STRIP "${CMAKE_STRIP}" CACHE INTERNAL + "Original strip binary") + endif() + + message(STATUS "CMAKE_STRIP (original): ${QT_INTERNAL_ORIGINAL_CMAKE_STRIP}") + + # Target Linux and MinGW. + if((UNIX OR MINGW) + AND NOT APPLE + AND NOT ANDROID + AND CMAKE_STRIP) + + # To make reconfiguration more robust when QT_INTERNAL_STRIP_SUPPORTS_KEEP_SECTION is + # manually removed, make sure to always restore the original strip first, by + # re-assigning the original value. + set(CMAKE_STRIP "${QT_INTERNAL_ORIGINAL_CMAKE_STRIP}" CACHE STRING "") + + # Getting path to a binary we can run strip on. + qt_internal_try_compile_binary_for_strip(valid_binary_path) + + # The strip arguments are used both for the execute_process test and also as content + # in the file created by configure_file. + set(strip_arguments "--keep-section=.gnu_debuglink") + + # Check if the option is supported. + message(STATUS "Performing Test strip --keep-section") + execute_process( + COMMAND + "${CMAKE_STRIP}" ${strip_arguments} "${valid_binary_path}" + OUTPUT_VARIABLE strip_probe_output + ERROR_VARIABLE strip_probe_output + RESULT_VARIABLE strip_result_var + ) + + # A successful strip of a binary should have a '0' exit code. + if(NOT strip_result_var STREQUAL "0") + set(keep_section_supported FALSE) + else() + set(keep_section_supported TRUE) + endif() + + # Cache the result. + set(QT_INTERNAL_STRIP_SUPPORTS_KEEP_SECTION "${keep_section_supported}" CACHE BOOL + "strip supports --keep-section") + + message(DEBUG + "qt_internal_generate_binary_strip_wrapper:\n" + "original strip: ${QT_INTERNAL_ORIGINAL_CMAKE_STRIP}\n" + "strip probe output: ${strip_probe_output}\n" + "strip result: ${strip_result_var}\n" + "keep section supported: ${keep_section_supported}\n" + ) + message(STATUS "Performing Test strip --keep-section - ${keep_section_supported}") + + # If the option is not supported, don't generate a wrapper and just use the stock binary. + if(NOT keep_section_supported) + return() + endif() + + set(wrapper_extension "") + + if(NOT CMAKE_HOST_UNIX) + set(wrapper_extension ".bat") + endif() + + set(script_name "qt-internal-strip") + + # the libexec literal is used on purpose for the source, so the file is found + # on Windows hosts. + set(wrapper_rel_path "libexec/${script_name}${wrapper_extension}.in") + + # Need to find the libexec input file depending whether the qtbase sources are available. + # This mirrors the logic in qt_set_up_build_internals_paths. + # TODO: Clean this up, together with qt_set_up_build_internals_paths to only use the + # the qtbase sources when building qtbase. And perhaps also when doing a non-prefix + # developer-build. + set(qtbase_wrapper_in_path "${QT_SOURCE_TREE}/${wrapper_rel_path}") + set(installed_wrapper_in_path + "${_qt_cmake_dir}/${QT_CMAKE_EXPORT_NAMESPACE}/${wrapper_rel_path}") + + # qtbase sources available, always use them, regardless of prefix or non-prefix builds. + if(EXISTS "${qtbase_wrapper_in_path}") + set(wrapper_in "${qtbase_wrapper_in_path}") + + # qtbase sources unavailable, use installed files. + elseif(EXISTS "${installed_wrapper_in_path}") + set(wrapper_in "${installed_wrapper_in_path}") + else() + message(FATAL_ERROR "Can't find ${script_name}${wrapper_extension}.in file.") + endif() + + set(wrapper_out "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${script_name}${wrapper_extension}") + + # Used in the template file. + set(original_strip "${QT_INTERNAL_ORIGINAL_CMAKE_STRIP}") + + configure_file("${wrapper_in}" "${wrapper_out}" @ONLY) + + # Override the strip binary to be used by CMake install target. + set(CMAKE_STRIP "${wrapper_out}" CACHE INTERNAL "Custom Qt strip wrapper") + + message(STATUS "CMAKE_STRIP (used by Qt): ${CMAKE_STRIP}") + endif() +endfunction() + +# Enable separate debug information for the given target +function(qt_enable_separate_debug_info target installDestination) + set(flags QT_EXECUTABLE) + if(APPLE) + set(options DSYM_OUTPUT_DIR) + else() + set(options) + endif() + set(multiopts ADDITIONAL_INSTALL_ARGS) + cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN}) + + if (NOT QT_FEATURE_separate_debug_info) + return() + endif() + if (NOT UNIX AND NOT MINGW) + return() + endif() + get_target_property(target_type ${target} TYPE) + if (NOT target_type STREQUAL "MODULE_LIBRARY" AND + NOT target_type STREQUAL "SHARED_LIBRARY" AND + NOT target_type STREQUAL "EXECUTABLE") + return() + endif() + get_property(target_source_dir TARGET ${target} PROPERTY SOURCE_DIR) + get_property(skip_separate_debug_info DIRECTORY "${target_source_dir}" PROPERTY _qt_skip_separate_debug_info) + if (skip_separate_debug_info) + return() + endif() + + unset(commands) + if(APPLE) + find_program(DSYMUTIL_PROGRAM dsymutil) + set(copy_bin ${DSYMUTIL_PROGRAM}) + set(strip_bin ${CMAKE_STRIP}) + set(debug_info_suffix dSYM) + set(copy_bin_out_arg --flat -o) + set(strip_args -S) + else() + set(copy_bin ${CMAKE_OBJCOPY}) + set(strip_bin ${CMAKE_OBJCOPY}) + if(QNX) + set(debug_info_suffix sym) + set(debug_info_keep --keep-file-symbols) + set(strip_args "--strip-debug -R.ident") + else() + set(debug_info_suffix debug) + set(debug_info_keep --only-keep-debug) + set(strip_args --strip-debug) + endif() + endif() + if(APPLE) + get_target_property(is_framework ${target} FRAMEWORK) + if(is_framework) + qt_internal_get_framework_info(fw ${target}) + set(BUNDLE_ID ${fw_name}) + else() + set(BUNDLE_ID ${target}) + endif() + + if (NOT "x${arg_DSYM_OUTPUT_DIR}" STREQUAL "x") + set(debug_info_bundle_dir "${arg_DSYM_OUTPUT_DIR}/${target}") + elseif(is_framework) + set(debug_info_bundle_dir "$") + else() + set(debug_info_bundle_dir "$") + endif() + set(debug_info_bundle_dir "${debug_info_bundle_dir}.${debug_info_suffix}") + + set(debug_info_contents_dir "${debug_info_bundle_dir}/Contents") + set(debug_info_target_dir "${debug_info_contents_dir}/Resources/DWARF") + configure_file( + "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/QtSeparateDebugInfo.Info.plist.in" + "Info.dSYM.plist" + ) + list(APPEND commands + COMMAND ${CMAKE_COMMAND} -E make_directory ${debug_info_target_dir} + COMMAND ${CMAKE_COMMAND} -E copy "Info.dSYM.plist" "${debug_info_contents_dir}/Info.plist" + ) + set(debug_info_target "${debug_info_target_dir}/$") + + if(arg_QT_EXECUTABLE AND QT_FEATURE_debug_and_release) + qt_get_cmake_configurations(cmake_configs) + foreach(cmake_config ${cmake_configs}) + # Make installation optional for targets that are not built by default in this config + if(NOT (cmake_config STREQUAL QT_MULTI_CONFIG_FIRST_CONFIG)) + set(install_optional_arg OPTIONAL) + else() + unset(install_optional_arg) + endif() + qt_install(DIRECTORY ${debug_info_bundle_dir} + ${arg_ADDITIONAL_INSTALL_ARGS} + ${install_optional_arg} + CONFIGURATIONS ${cmake_config} + DESTINATION ${installDestination}) + endforeach() + else() + qt_install(DIRECTORY ${debug_info_bundle_dir} + ${arg_ADDITIONAL_INSTALL_ARGS} + DESTINATION ${installDestination}) + endif() + else() + set(debug_info_target "$/$.${debug_info_suffix}") + qt_install(FILES ${debug_info_target} DESTINATION ${installDestination}) + endif() + list(APPEND commands + COMMAND ${copy_bin} ${debug_info_keep} $ + ${copy_bin_out_arg} ${debug_info_target} + COMMAND ${strip_bin} ${strip_args} $ + ) + if(NOT APPLE) + list(APPEND commands + COMMAND ${CMAKE_OBJCOPY} --add-gnu-debuglink=${debug_info_target} $ + ) + endif() + if(NOT CMAKE_HOST_WIN32) + list(APPEND commands + COMMAND chmod -x ${debug_info_target} + ) + endif() + add_custom_command( + TARGET ${target} + POST_BUILD + ${commands} + VERBATIM) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSetup.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSetup.cmake new file mode 100644 index 0000000000000000000000000000000000000000..49645154edc78554ccf9b2f2dc283841ca9886f4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSetup.cmake @@ -0,0 +1,6 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Any new code should go into QtBuildHelpers.cmake or other appropriate files and then called in +# qt_internal_setup_build_and_global_variables(). +include(QtBuild) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSimdHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSimdHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2b2ecf6e03abda10364c01ce1abf762820beae16 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSimdHelpers.cmake @@ -0,0 +1,114 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Handle files that need special SIMD-related flags. +# +# This function adds the passed source files to the given target only if the SIMD specific condition +# evaluates to true. It also adds the SIMD architecture specific flags as compile options to those +# source files. +# +# Arguments +# NAME: is deprecated, don't use it. +# SIMD: name of the simd architecture, e.g. sse2, avx, neon. A Qt feature named QT_FEATURE_foo +# should exist, as well as QT_CFLAGS_foo assignment in QtCompilerOptimization.cmake. +# COMPILE_FLAGS: extra compile flags to set for the passed source files +# EXCLUDE_OSX_ARCHITECTURES: On apple platforms, specifies which architectures should not get the +# SIMD compiler flags. This is mostly relevant for fat / universal builds +# +function(qt_internal_add_simd_part target) + cmake_parse_arguments(PARSE_ARGV 1 arg + "" + "NAME;SIMD" + "${__default_private_args};COMPILE_FLAGS;EXCLUDE_OSX_ARCHITECTURES") + _qt_internal_validate_all_args_are_parsed(arg) + + if ("x${arg_SIMD}" STREQUAL x) + message(FATAL_ERROR "qt_add_simd_part needs a SIMD type to be set.") + endif() + + set(condition "QT_FEATURE_${arg_SIMD}") + string(TOUPPER "QT_CFLAGS_${arg_SIMD}" simd_flags_var_name) + set(simd_flags_expanded "") + + # As per mkspecs/features/simd.prf, the arch_haswell SIMD compiler is enabled when + # qmake's CONFIG contains "avx2", which maps to CMake's QT_FEATURE_avx2. + # The list of dependencies 'avx2 bmi bmi2 f16c fma lzcnt popcnt' only influences whether + # the 'arch_haswell' SIMD flags need to be added explicitly to the compiler invocation. + # If the compiler adds them implicitly, they must be present in qmake's QT_CPU_FEATURES as + # detected by the architecture test, and thus they are present in TEST_subarch_result. + if("${arg_SIMD}" STREQUAL arch_haswell) + set(condition "QT_FEATURE_avx2") + + # Use avx2 flags as per simd.prf, if there are no specific arch_haswell flags specified in + # QtCompilerOptimization.cmake. + if("${simd_flags_var_name}" STREQUAL "") + set(simd_flags_var_name "QT_CFLAGS_AVX2") + endif() + + # The avx512 profiles dependencies DO influence if the SIMD compiler will be executed, + # so each of the profile dependencies have to be in qmake's CONFIG for the compiler to be + # enabled, which means the CMake features have to evaluate to true. + # Also the profile flags to be used are a combination of arch_haswell, avx512f and each of the + # dependencies. + elseif("${arg_SIMD}" STREQUAL avx512common) + set(condition "QT_FEATURE_avx512cd") + list(APPEND simd_flags_expanded "${QT_CFLAGS_ARCH_HASWELL}") + list(APPEND simd_flags_expanded "${QT_CFLAGS_AVX512F}") + list(APPEND simd_flags_expanded "${QT_CFLAGS_AVX512CD}") + list(REMOVE_DUPLICATES simd_flags_expanded) + elseif("${arg_SIMD}" STREQUAL avx512core) + set(condition "QT_FEATURE_avx512cd AND QT_FEATURE_avx512bw AND QT_FEATURE_avx512dq AND QT_FEATURE_avx512vl") + list(APPEND simd_flags_expanded "${QT_CFLAGS_ARCH_HASWELL}") + list(APPEND simd_flags_expanded "${QT_CFLAGS_AVX512F}") + list(APPEND simd_flags_expanded "${QT_CFLAGS_AVX512CD}") + list(APPEND simd_flags_expanded "${QT_CFLAGS_AVX512BW}") + list(APPEND simd_flags_expanded "${QT_CFLAGS_AVX512DQ}") + list(APPEND simd_flags_expanded "${QT_CFLAGS_AVX512VL}") + list(REMOVE_DUPLICATES simd_flags_expanded) + endif() + + qt_evaluate_config_expression(result ${condition}) + if(${result}) + if(QT_CMAKE_DEBUG_EXTEND_TARGET) + message("qt_add_simd_part(${target} SIMD ${arg_SIMD} ...): Evaluated") + endif() + + if(NOT simd_flags_expanded) + set(simd_flags_expanded "${${simd_flags_var_name}}") + endif() + + # Only process OSX_ARCHITECTURES when targeting Apple platforms, otherwise it might fail + # non-Apple builds when CMAKE_OSX_ARCHITECTURES is accidentally passed to configure. + if(APPLE) + # If requested, don't pass the simd specific flags to excluded arches on apple platforms. + # Mostly important for universal / fat builds. + get_target_property(osx_architectures ${target} OSX_ARCHITECTURES) + if(simd_flags_expanded AND osx_architectures AND arg_EXCLUDE_OSX_ARCHITECTURES) + list(REMOVE_ITEM osx_architectures ${arg_EXCLUDE_OSX_ARCHITECTURES}) + + # Assumes that simd_flags_expanded contains only one item on apple platforms. + list(TRANSFORM osx_architectures + REPLACE "^(.+)$" "-Xarch_\\1;${simd_flags_expanded}" + OUTPUT_VARIABLE simd_flags_expanded) + endif() + endif() + + # The manual loop is done on purpose. Check Gerrit comments for + # 1b7008a3d784f3f266368f824cb43d473a301ba1. + foreach(source IN LISTS arg_SOURCES) + set_property(SOURCE "${source}" APPEND + PROPERTY COMPILE_OPTIONS + ${simd_flags_expanded} + ${arg_COMPILE_FLAGS} + ) + endforeach() + set_source_files_properties(${arg_SOURCES} PROPERTIES + SKIP_PRECOMPILE_HEADERS TRUE + SKIP_UNITY_BUILD_INCLUSION TRUE) + target_sources(${target} PRIVATE ${arg_SOURCES}) + else() + if(QT_CMAKE_DEBUG_EXTEND_TARGET) + message("qt_add_simd_part(${target} SIMD ${arg_SIMD} ...): Skipped") + endif() + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSingleRepoTargetSetBuildHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSingleRepoTargetSetBuildHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4647b7b6d7ea59f2cb7769f8f55a076ab43d9b24 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSingleRepoTargetSetBuildHelpers.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Macro that checks for a single repo target set build, and returns from the current file, directory +# or function. Use this at the top of project files to whitelist the file for the given package. +macro(qt_internal_include_in_repo_target_set _repo_target_set_name) + if(DEFINED QT_BUILD_SINGLE_REPO_TARGET_SET) + if(NOT "${_repo_target_set_name}" STREQUAL QT_BUILD_SINGLE_REPO_TARGET_SET) + message(STATUS "Not part of repo target set ${QT_BUILD_SINGLE_REPO_TARGET_SET}: " + "${CMAKE_CURRENT_LIST_DIR}") + return() + endif() + endif() +endmacro() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtStandaloneTestsConfig.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtStandaloneTestsConfig.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..a5d368e59539be67d3e6d847f58eb9df0ace5695 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtStandaloneTestsConfig.cmake.in @@ -0,0 +1,8 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# TODO: Ideally this should look for each Qt module separately, with each module's specific version, +# bypassing the Qt6 Config file, aka find_package(Qt6SpecificFoo) repated x times. But it's not +# critical. +find_package(@INSTALL_CMAKE_NAMESPACE@ @main_qt_package_version@ + COMPONENTS @QT_REPO_KNOWN_MODULES_STRING@) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSyncQtHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSyncQtHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee4c825254976b9b7b5322fcf117a662e7c12693 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtSyncQtHelpers.cmake @@ -0,0 +1,324 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# The function generates the Qt module header structure in build directory and creates install +# rules. Apart the lists of header files the function takes into account +# QT_REPO_PUBLIC_NAMESPACE_REGEX cache variable, that can be set by repository in .cmake.conf file. +# The variable tells the syncqt program, what namespaces are treated as public. Symbols in public +# namespaces are considered when generating CaMeL case header files. +function(qt_internal_target_sync_headers target module_headers module_headers_generated) + if(NOT TARGET ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt) + message(FATAL_ERROR "${QT_CMAKE_EXPORT_NAMESPACE}::syncqt is not a target.") + endif() + get_target_property(has_headers ${target} _qt_module_has_headers) + if(NOT has_headers) + return() + endif() + + qt_internal_module_info(module "${target}") + + get_target_property(sync_source_directory ${target} _qt_sync_source_directory) + set(syncqt_timestamp "${CMAKE_CURRENT_BINARY_DIR}/${target}_syncqt_timestamp") + set(syncqt_outputs "${syncqt_timestamp}") + + set(is_interface_lib FALSE) + get_target_property(type ${target} TYPE) + if(type STREQUAL "INTERFACE_LIBRARY") + set(is_interface_lib TRUE) + endif() + + set(version_script_private_content_file "") + if(NOT is_interface_lib) + list(APPEND syncqt_outputs + "${module_build_interface_include_dir}/${module}Version" + "${module_build_interface_include_dir}/qt${module_lower}version.h") + if(TEST_ld_version_script) + set(version_script_private_content_file + "${CMAKE_CURRENT_BINARY_DIR}/${target}.version.private_content") + set(version_script_args + "-versionScript" "${version_script_private_content_file}") + list(APPEND syncqt_outputs "${version_script_private_content_file}") + qt_internal_add_linker_version_script(${target} + PRIVATE_CONTENT_FILE "${version_script_private_content_file}") + endif() + endif() + + # Check for _qt_module_is_3rdparty_header_library flag to detect non-Qt modules and + # indicate this to syncqt. + get_target_property(is_3rd_party_library ${target} _qt_module_is_3rdparty_header_library) + set(non_qt_module_argument "") + if(is_3rd_party_library) + set(non_qt_module_argument "-nonQt") + else() + list(APPEND syncqt_outputs "${module_build_interface_include_dir}/${module}") + get_target_property(no_headersclean_check ${target} _qt_no_headersclean_check) + if(NOT no_headersclean_check) + list(APPEND syncqt_outputs + "${CMAKE_CURRENT_BINARY_DIR}/${module}_header_check_exceptions") + endif() + endif() + + set(is_framework FALSE) + if(NOT is_interface_lib) + get_target_property(is_framework ${target} FRAMEWORK) + endif() + + qt_internal_get_qt_all_known_modules(known_modules) + + get_target_property(is_internal_module ${target} _qt_is_internal_module) + set(internal_module_argument "") + if(is_internal_module) + set(internal_module_argument "-internal") + endif() + + get_target_property(qpa_filter_regex ${target} _qt_module_qpa_headers_filter_regex) + get_target_property(rhi_filter_regex ${target} _qt_module_rhi_headers_filter_regex) + get_target_property(ssg_filter_regex ${target} _qt_module_ssg_headers_filter_regex) + get_target_property(private_filter_regex ${target} _qt_module_private_headers_filter_regex) + + # We need to use the real paths since otherwise it may lead to the invalid work of the + # std::filesystem API + get_filename_component(source_dir_real "${sync_source_directory}" REALPATH) + get_filename_component(binary_dir_real "${CMAKE_CURRENT_BINARY_DIR}" REALPATH) + + if(QT_REPO_PUBLIC_NAMESPACE_REGEX) + set(public_namespaces_filter -publicNamespaceFilter "${QT_REPO_PUBLIC_NAMESPACE_REGEX}") + endif() + + if(qpa_filter_regex) + set(qpa_filter_argument + -qpaHeadersFilter "${qpa_filter_regex}" + ) + endif() + + if(rhi_filter_regex) + set(rhi_filter_argument + -rhiHeadersFilter "${rhi_filter_regex}" + ) + endif() + + if(ssg_filter_regex) + set(ssg_filter_argument + -ssgHeadersFilter "${ssg_filter_regex}" + ) + endif() + + set(common_syncqt_arguments + -module "${module}" + -sourceDir "${source_dir_real}" + -binaryDir "${binary_dir_real}" + -privateHeadersFilter "${private_filter_regex}" + -includeDir "${module_build_interface_include_dir}" + -privateIncludeDir "${module_build_interface_private_include_dir}" + -qpaIncludeDir "${module_build_interface_qpa_include_dir}" + -rhiIncludeDir "${module_build_interface_rhi_include_dir}" + -ssgIncludeDir "${module_build_interface_ssg_include_dir}" + -generatedHeaders ${module_headers_generated} + ${qpa_filter_argument} + ${rhi_filter_argument} + ${ssg_filter_argument} + ${public_namespaces_filter} + ${non_qt_module_argument} + ${internal_module_argument} + ) + + if(QT_INTERNAL_ENABLE_SYNCQT_DEBUG_OUTPUT) + list(APPEND common_syncqt_arguments -debug) + endif() + + set(build_time_syncqt_arguments "") + if(WARNINGS_ARE_ERRORS) + if(is_interface_lib) + set(warnings_are_errors_enabled_genex 1) + else() + set(warnings_are_errors_enabled_genex + "$>>") + endif() + list(APPEND build_time_syncqt_arguments + "$<${warnings_are_errors_enabled_genex}:-warningsAreErrors>") + endif() + + if(is_framework) + list(REMOVE_ITEM module_headers "${CMAKE_CURRENT_BINARY_DIR}/${target}_fake_header.h") + endif() + + # Filter the generated ui_ header files and header files located in the 'doc/' subdirectory. + list(FILTER module_headers EXCLUDE REGEX + "(.+/(ui_)[^/]+\\.h|${CMAKE_CURRENT_SOURCE_DIR}(/.+)?/doc/+\\.h)") + + set(syncqt_staging_dir "${module_build_interface_include_dir}/.syncqt_staging") + + set(syncqt_args "${common_syncqt_arguments}") + list(APPEND syncqt_args + -headers ${module_headers} + -stagingDir "${syncqt_staging_dir}" + -knownModules ${known_modules} + ${version_script_args} + ) + list(JOIN syncqt_args "\n" syncqt_args_string) + set(syncqt_args_rsp "${binary_dir_real}/${target}_syncqt_args") + qt_configure_file(OUTPUT "${syncqt_args_rsp}" CONTENT "${syncqt_args_string}") + + get_target_property(external_headers_dir ${target} _qt_external_headers_dir) + if(external_headers_dir) + if(NOT IS_ABSOLUTE "${external_headers_dir}") + get_filename_component(external_headers_dir "${external_headers_dir}" ABSOLUTE) + endif() + if(EXISTS "${external_headers_dir}") + set(external_headers_dir_copy_cmd + COMMAND + ${CMAKE_COMMAND} + -E copy_directory + "${external_headers_dir}" + "${module_build_interface_include_dir}" + ) + endif() + endif() + add_custom_command( + OUTPUT + ${syncqt_outputs} + COMMAND + ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt + "@${syncqt_args_rsp}" + ${build_time_syncqt_arguments} + ${external_headers_dir_copy_cmd} + COMMAND + ${CMAKE_COMMAND} -E touch "${syncqt_timestamp}" + DEPENDS + ${syncqt_args_rsp} + ${module_headers} + ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt + "$>" + COMMENT + "Running syncqt.cpp for module: ${module}" + VERBATIM + ) + + set(add_sync_headers_to_all "") + if(is_interface_lib) + set(add_sync_headers_to_all ALL) + endif() + + add_custom_target(${target}_sync_headers + ${add_sync_headers_to_all} + DEPENDS + ${syncqt_outputs} + ) + add_dependencies(sync_headers ${target}_sync_headers) + set_target_properties(${target} + PROPERTIES _qt_internal_sync_headers_target ${target}_sync_headers) + + if(is_3rd_party_library) + add_dependencies(thirdparty_sync_headers ${target}_sync_headers) + endif() + # This target is required when building docs, to make all header files and their aliases + # available for qdoc. + # ${target}_sync_headers is added as dependency to make sure that + # ${target}_sync_all_public_headers is running after ${target}_sync_headers, when building docs. + set(syncqt_all_args "${common_syncqt_arguments};-all") + list(JOIN syncqt_all_args "\n" syncqt_all_args_string) + set(syncqt_all_args_rsp "${binary_dir_real}/${target}_syncqt_all_args") + qt_configure_file(OUTPUT "${syncqt_all_args_rsp}" CONTENT "${syncqt_all_args_string}") + add_custom_target(${target}_sync_all_public_headers + COMMAND + ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt + "@${syncqt_all_args_rsp}" + ${external_headers_dir_copy_cmd} + DEPENDS + ${module_headers} + ${syncqt_all_args_rsp} + ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt + ${target}_sync_headers + VERBATIM + ) + + if(NOT TARGET sync_all_public_headers) + add_custom_target(sync_all_public_headers) + endif() + add_dependencies(sync_all_public_headers ${target}_sync_all_public_headers) + + if(NOT is_3rd_party_library AND NOT is_framework AND module_headers) + # Install all the CaMeL style aliases of header files from the staging directory in one rule + qt_install(DIRECTORY "${syncqt_staging_dir}/" + DESTINATION "${module_install_interface_include_dir}" + ) + endif() + + if(NOT is_interface_lib) + set_property(TARGET ${target} + APPEND PROPERTY AUTOGEN_TARGET_DEPENDS "${target}_sync_headers") + endif() + add_dependencies(${target} "${target}_sync_headers") + + + get_target_property(private_module_target ${target} _qt_private_module_target_name) + if(private_module_target) + add_dependencies(${private_module_target} "${target}_sync_headers") + endif() + + # Run sync Qt first time at configure step to make all header files available for the code model + # of IDEs. + get_property(synced_modules GLOBAL PROPERTY _qt_synced_modules) + if(NOT "${module}" IN_LIST synced_modules AND QT_SYNC_HEADERS_AT_CONFIGURE_TIME) + message(STATUS "Running syncqt.cpp for module: ${module}") + get_target_property(syncqt_location ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt LOCATION) + execute_process( + COMMAND + ${syncqt_location} + "@${syncqt_args_rsp}" + RESULT_VARIABLE syncqt_result + OUTPUT_VARIABLE syncqt_output + ERROR_VARIABLE syncqt_output + ) + if(NOT syncqt_result EQUAL 0) + if(syncqt_output STREQUAL "") + string(JOIN "" syncqt_output "The syncqt process exited with code ${syncqt_result}" + " and without any useful output. This can happen if syncqt crashes due to the" + " incompatibilities with the standard C++ library located by either PATH or" + " LD_LIBRARY_PATH environment variables. Please make sure that PATH or" + " LD_LIBRARY_PATH don't point to the standard libraries different from the one you" + " use for building Qt.") + endif() + message(FATAL_ERROR + "syncqt.cpp failed for module ${module}:\n${syncqt_output}") + endif() + if(syncqt_output) + message(WARNING "${syncqt_output}") + endif() + set_property(GLOBAL APPEND PROPERTY _qt_synced_modules ${module}) + endif() +endfunction() + +function(qt_internal_collect_sync_header_dependencies out_var skip_non_existing) + list(LENGTH ARGN sync_headers_target_count) + if(sync_headers_target_count EQUAL 0) + message(FATAL_ERROR "Invalid use of qt_internal_collect_sync_header_dependencies," + " dependencies are not specified") + endif() + + set(${out_var} "") + foreach(sync_headers_target IN LISTS ARGN) + set(sync_headers_target "${sync_headers_target}_sync_headers") + if(NOT skip_non_existing OR TARGET ${sync_headers_target}) + list(APPEND ${out_var} ${sync_headers_target}) + endif() + endforeach() + list(REMOVE_DUPLICATES ${out_var}) + + set(${out_var} "${${out_var}}" PARENT_SCOPE) +endfunction() + +function(qt_internal_add_sync_header_dependencies target) + qt_internal_collect_sync_header_dependencies(sync_headers_targets FALSE ${ARGN}) + if(sync_headers_targets) + add_dependencies(${target} ${sync_headers_targets}) + endif() +endfunction() + +function(qt_internal_add_autogen_sync_header_dependencies target) + qt_internal_collect_sync_header_dependencies(sync_headers_targets TRUE ${ARGN}) + foreach(sync_headers_target IN LISTS sync_headers_targets) + set_property(TARGET ${target} APPEND PROPERTY AUTOGEN_TARGET_DEPENDS + "${sync_headers_target}") + endforeach() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtTargetHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtTargetHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..14248191ebe911cbbe9e7819f6ce5e1dcb9738c0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtTargetHelpers.cmake @@ -0,0 +1,1768 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This function can be used to add sources/libraries/etc. to the specified CMake target +# if the provided CONDITION evaluates to true. +# One-value Arguments: +# PRECOMPILED_HEADER +# Name of the precompiled header that is used for the target. +# Multi-value Arguments: +# CONDITION +# The condition under which the target will be extended. +# CONDITION_INDEPENDENT_SOURCES +# Source files that should be added to the target unconditionally. Note that if target is Qt +# module, these files will raise a warning at configure time if the condition is not met. +# COMPILE_FLAGS +# Custom compilation flags. +# EXTRA_LINKER_SCRIPT_CONTENT +# Extra content that should be appended to a target linker script. Applicable for ld only. +# EXTRA_LINKER_SCRIPT_EXPORTS +# Extra content that should be added to export section of the linker script. +# NO_PCH_SOURCES +# Exclude the specified source files from PRECOMPILE_HEADERS and UNITY_BUILD builds. +function(qt_internal_extend_target target) + if(NOT TARGET "${target}") + message(FATAL_ERROR "${target} is not a target.") + endif() + qt_internal_is_skipped_test(skipped ${target}) + if(skipped) + return() + endif() + qt_internal_is_in_test_batch(in_batch ${target}) + if(in_batch) + _qt_internal_test_batch_target_name(target) + endif() + + # Don't try to extend_target when cross compiling an imported host target (like a tool). + qt_is_imported_target("${target}" is_imported) + if(is_imported) + return() + endif() + + set(option_args + NO_UNITY_BUILD + ${__qt_internal_sbom_optional_args} + ) + set(single_args + PRECOMPILED_HEADER + EXTRA_LINKER_SCRIPT_CONTENT + ${__qt_internal_sbom_single_args} + ) + set(multi_args + ${__default_public_args} + ${__default_private_args} + ${__default_private_module_args} + CONDITION + CONDITION_INDEPENDENT_SOURCES + COMPILE_FLAGS + EXTRA_LINKER_SCRIPT_EXPORTS + ${__qt_internal_sbom_multi_args} + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" + "${single_args}" + "${multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + if("x${arg_CONDITION}" STREQUAL "x") + set(arg_CONDITION ON) + endif() + + qt_evaluate_config_expression(result ${arg_CONDITION}) + if(${result}) + if(QT_CMAKE_DEBUG_EXTEND_TARGET) + message("qt_extend_target(${target} CONDITION ${arg_CONDITION} ...): Evaluated") + endif() + set(dbus_sources "") + foreach(adaptor ${arg_DBUS_ADAPTOR_SOURCES}) + _qt_internal_forward_function_args( + FORWARD_PREFIX arg_DBUS_ADAPTOR + FORWARD_OUT_VAR forwarded_args + FORWARD_SINGLE + BASENAME + FLAGS + ) + qt_create_qdbusxml2cpp_command("${target}" "${adaptor}" ADAPTOR ${forwarded_args}) + list(APPEND dbus_sources "${adaptor}") + endforeach() + + foreach(interface ${arg_DBUS_INTERFACE_SOURCES}) + _qt_internal_forward_function_args( + FORWARD_PREFIX arg_DBUS_INTERFACE + FORWARD_OUT_VAR forwarded_args + FORWARD_SINGLE + BASENAME + FLAGS + ) + qt_create_qdbusxml2cpp_command("${target}" "${interface}" INTERFACE ${forwarded_args}) + list(APPEND dbus_sources "${interface}") + endforeach() + + set(all_sources + ${arg_SOURCES} + ${dbus_sources} + ) + + get_target_property(target_type ${target} TYPE) + set(is_library FALSE) + set(is_interface_lib FALSE) + set(is_executable FALSE) + if(${target_type} STREQUAL "STATIC_LIBRARY" OR ${target_type} STREQUAL "SHARED_LIBRARY") + set(is_library TRUE) + elseif(target_type STREQUAL "INTERFACE_LIBRARY") + set(is_interface_lib TRUE) + elseif(target_type STREQUAL "EXECUTABLE") + set(is_executable TRUE) + endif() + + foreach(lib ${arg_PUBLIC_LIBRARIES} ${arg_LIBRARIES}) + # Automatically generate PCH for 'target' using public dependencies. + # But only if 'target' is a library/module that does not specify its own PCH file. + if(NOT arg_PRECOMPILED_HEADER AND ${is_library}) + qt_update_precompiled_header_with_library("${target}" "${lib}") + endif() + + string(REGEX REPLACE "_nolink$" "" base_lib "${lib}") + if(NOT base_lib STREQUAL lib) + qt_create_nolink_target("${base_lib}" ${target}) + endif() + + # Collect _sync_headers targets from libraries that the target depends on. This is + # heuristic way of building the dependency tree between the _sync_headers targets of + # different Qt modules. + if(TARGET "${lib}") + get_target_property(is_imported ${lib} IMPORTED) + if(NOT is_imported) + get_target_property(is_private ${lib} _qt_is_private_module) + if(is_private) + get_target_property(lib ${lib} _qt_public_module_target_name) + endif() + set(out_genex "$") + set_property(TARGET ${target} + APPEND PROPERTY _qt_internal_sync_headers_deps "${out_genex}") + endif() + endif() + endforeach() + + list(TRANSFORM arg_PUBLIC_LIBRARIES REPLACE "^Qt::" "${QT_CMAKE_EXPORT_NAMESPACE}::") + list(TRANSFORM arg_LIBRARIES REPLACE "^Qt::" "${QT_CMAKE_EXPORT_NAMESPACE}::") + + # Set-up the target + + # CMake versions less than 3.19 don't support adding the source files to the PRIVATE scope + # of the INTERFACE libraries. These PRIVATE sources are only needed by IDEs to display + # them in a project tree, so to avoid build issues and appearing the sources in + # INTERFACE_SOURCES property of INTERFACE_LIBRARY. Collect them inside the + # _qt_internal_target_sources property, since they can be useful in the source processing + # functions. The property itself is not exported and should only be used in the Qt internal + # build tree. + if(NOT is_interface_lib OR CMAKE_VERSION VERSION_GREATER_EQUAL "3.19") + target_sources("${target}" PRIVATE ${all_sources}) + if(arg_COMPILE_FLAGS) + set_source_files_properties(${all_sources} PROPERTIES + COMPILE_FLAGS "${arg_COMPILE_FLAGS}") + endif() + else() + set_property(TARGET ${target} APPEND PROPERTY + _qt_internal_target_sources ${all_sources}) + endif() + + set(public_visibility_option "PUBLIC") + set(private_visibility_option "PRIVATE") + if(is_interface_lib) + set(public_visibility_option "INTERFACE") + set(private_visibility_option "INTERFACE") + endif() + target_include_directories("${target}" + ${public_visibility_option} ${arg_PUBLIC_INCLUDE_DIRECTORIES} + ${private_visibility_option} ${arg_INCLUDE_DIRECTORIES}) + target_include_directories("${target}" SYSTEM + ${private_visibility_option} ${arg_SYSTEM_INCLUDE_DIRECTORIES}) + target_compile_definitions("${target}" + ${public_visibility_option} ${arg_PUBLIC_DEFINES} + ${private_visibility_option} ${arg_DEFINES}) + target_link_libraries("${target}" + ${public_visibility_option} ${arg_PUBLIC_LIBRARIES} + ${private_visibility_option} ${arg_LIBRARIES}) + target_compile_options("${target}" + ${public_visibility_option} ${arg_PUBLIC_COMPILE_OPTIONS} + ${private_visibility_option} ${arg_COMPILE_OPTIONS}) + target_link_options("${target}" + ${public_visibility_option} ${arg_PUBLIC_LINK_OPTIONS} + ${private_visibility_option} ${arg_LINK_OPTIONS}) + + if(NOT is_interface_lib) + set_property(TARGET "${target}" APPEND PROPERTY + AUTOMOC_MOC_OPTIONS "${arg_MOC_OPTIONS}" + ) + # Plugin types associated to a module + if(NOT "x${arg_PLUGIN_TYPES}" STREQUAL "x") + qt_internal_add_plugin_types("${target}" "${arg_PLUGIN_TYPES}") + endif() + endif() + + # When computing the private library dependencies, we need to check not only the known + # modules added by this repo's qt_build_repo(), but also all module dependencies that + # were found via find_package(). + qt_internal_get_qt_all_known_modules(known_modules) + + # When a public module depends on a private module (Gui on CorePrivate) + # make its private module depend on the other private module (GuiPrivate will depend on + # CorePrivate). + set(qt_libs_private "") + foreach(it ${known_modules}) + list(FIND arg_LIBRARIES "Qt::${it}Private" pos) + if(pos GREATER -1) + list(APPEND qt_libs_private "Qt::${it}Private") + endif() + endforeach() + + if(arg_LIBRARIES) + _qt_internal_append_to_target_property_without_duplicates(${target} + _qt_extend_target_libraries "${arg_LIBRARIES}" + ) + endif() + + if(arg_PUBLIC_LIBRARIES) + _qt_internal_append_to_target_property_without_duplicates(${target} + _qt_extend_target_public_libraries "${arg_PUBLIC_LIBRARIES}" + ) + endif() + + if(QT_GENERATE_SBOM) + set(sbom_args "") + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + ${__qt_internal_sbom_optional_args} + FORWARD_SINGLE + ${__qt_internal_sbom_single_args} + FORWARD_MULTI + ${__qt_internal_sbom_multi_args} + ) + _qt_internal_extend_sbom(${target} ${sbom_args}) + endif() + + set(target_private "${target}Private") + get_target_property(is_internal_module ${target} _qt_is_internal_module) + # Internal modules don't have Private targets but we still need to + # propagate their private dependencies. + if(is_internal_module) + set(target_private "${target}") + endif() + if(TARGET "${target_private}") + target_link_libraries("${target_private}" + INTERFACE ${arg_PRIVATE_MODULE_INTERFACE}) + elseif(arg_PRIVATE_MODULE_INTERFACE) + set(warning_message "") + string(APPEND warning_message + "The PRIVATE_MODULE_INTERFACE option was provided the values:" + "'${arg_PRIVATE_MODULE_INTERFACE}' " + "but there is no ${target}Private target to assign them to." + "Ensure the target exists or remove the option.") + message(AUTHOR_WARNING "${warning_message}") + endif() + qt_register_target_dependencies("${target}" + "${arg_PUBLIC_LIBRARIES};${arg_PRIVATE_MODULE_INTERFACE}" + "${qt_libs_private};${arg_LIBRARIES}") + + + qt_autogen_tools(${target} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS}) + + qt_update_precompiled_header("${target}" "${arg_PRECOMPILED_HEADER}") + ## Also exclude them from unity build + qt_update_ignore_pch_source("${target}" "${arg_NO_PCH_SOURCES}") + ## Ignore objective-c files for PCH (not supported atm) + qt_ignore_pch_obj_c_sources("${target}" "${arg_SOURCES}") + + if(arg_NO_UNITY_BUILD) + set_target_properties("${target}" PROPERTIES UNITY_BUILD OFF) + qt_update_ignore_unity_build_sources("${target}" "${arg_SOURCES}") + endif() + if(arg_NO_UNITY_BUILD_SOURCES) + qt_update_ignore_unity_build_sources("${target}" "${arg_NO_UNITY_BUILD_SOURCES}") + endif() + else() + if(QT_CMAKE_DEBUG_EXTEND_TARGET) + message("qt_extend_target(${target} CONDITION ${arg_CONDITION} ...): Skipped") + endif() + endif() + + if(arg_CONDITION_INDEPENDENT_SOURCES) + set_source_files_properties(${arg_CONDITION_INDEPENDENT_SOURCES} PROPERTIES + _qt_extend_target_condition "${arg_CONDITION}" + SKIP_AUTOGEN TRUE + ) + + qt_internal_get_target_sources_property(sources_property) + set_property(TARGET ${target} APPEND PROPERTY + ${sources_property} "${arg_CONDITION_INDEPENDENT_SOURCES}") + endif() + + if(arg_EXTRA_LINKER_SCRIPT_CONTENT) + set_target_properties(${target} PROPERTIES + _qt_extra_linker_script_content "${arg_EXTRA_LINKER_SCRIPT_CONTENT}") + endif() + if(arg_EXTRA_LINKER_SCRIPT_EXPORTS) + set_target_properties(${target} PROPERTIES + _qt_extra_linker_script_exports "${arg_EXTRA_LINKER_SCRIPT_EXPORTS}") + endif() + + if(is_executable) + # If linking against Gui, make sure to also build the default QPA plugin. + # This makes the experience of an initial Qt configuration to build and run one single + # test / executable nicer. + set(linked_libs ${arg_PUBLIC_LIBRARIES} ${arg_LIBRARIES}) + if(linked_libs MATCHES "(^|;)(${QT_CMAKE_EXPORT_NAMESPACE}::|Qt::)?Gui($|;)" AND + TARGET qpa_default_plugins) + add_dependencies("${target}" qpa_default_plugins) + endif() + + # For executables collect static plugins that these targets depend on. + qt_internal_import_plugins(${target} ${linked_libs}) + endif() +endfunction() + +# Given CMAKE_CONFIG and ALL_CMAKE_CONFIGS, determines if a directory suffix needs to be appended +# to each destination, and sets the computed install target destination arguments in OUT_VAR. +# Defaults used for each of the destination types, and can be configured per destination type. +function(qt_get_install_target_default_args) + cmake_parse_arguments(PARSE_ARGV 0 arg + "" + "OUT_VAR;OUT_VAR_RUNTIME;CMAKE_CONFIG;RUNTIME;LIBRARY;ARCHIVE;INCLUDES;BUNDLE" + "ALL_CMAKE_CONFIGS") + _qt_internal_validate_all_args_are_parsed(arg) + + if(NOT arg_CMAKE_CONFIG) + message(FATAL_ERROR "No value given for CMAKE_CONFIG.") + endif() + if(NOT arg_ALL_CMAKE_CONFIGS) + message(FATAL_ERROR "No value given for ALL_CMAKE_CONFIGS.") + endif() + list(LENGTH arg_ALL_CMAKE_CONFIGS all_configs_count) + list(GET arg_ALL_CMAKE_CONFIGS 0 first_config) + + set(suffix "") + if(all_configs_count GREATER 1 AND NOT arg_CMAKE_CONFIG STREQUAL first_config) + set(suffix "/${arg_CMAKE_CONFIG}") + endif() + + set(runtime "${INSTALL_BINDIR}") + if(arg_RUNTIME) + set(runtime "${arg_RUNTIME}") + endif() + + set(library "${INSTALL_LIBDIR}") + if(arg_LIBRARY) + set(library "${arg_LIBRARY}") + endif() + + set(archive "${INSTALL_LIBDIR}") + if(arg_ARCHIVE) + set(archive "${arg_ARCHIVE}") + endif() + + set(includes "${INSTALL_INCLUDEDIR}") + if(arg_INCLUDES) + set(includes "${arg_INCLUDES}") + endif() + + set(bundle "${INSTALL_BINDIR}") + if(arg_BUNDLE) + set(bundle "${arg_BUNDLE}") + endif() + + set(args + RUNTIME DESTINATION "${runtime}${suffix}" + LIBRARY DESTINATION "${library}${suffix}" + ARCHIVE DESTINATION "${archive}${suffix}" COMPONENT Devel + BUNDLE DESTINATION "${bundle}${suffix}" + INCLUDES DESTINATION "${includes}${suffix}") + set(${arg_OUT_VAR} "${args}" PARENT_SCOPE) + + if(arg_OUT_VAR_RUNTIME) + set(args + "${runtime}${suffix}" + ) + set(${arg_OUT_VAR_RUNTIME} "${args}" PARENT_SCOPE) + endif() +endfunction() + +macro(qt_internal_setup_default_target_function_options) + set(__default_private_args + SOURCES + LIBRARIES + INCLUDE_DIRECTORIES + SYSTEM_INCLUDE_DIRECTORIES + DEFINES + DBUS_ADAPTOR_BASENAME + DBUS_ADAPTOR_FLAGS + DBUS_ADAPTOR_SOURCES + DBUS_INTERFACE_BASENAME + DBUS_INTERFACE_FLAGS + DBUS_INTERFACE_SOURCES + FEATURE_DEPENDENCIES + COMPILE_OPTIONS + LINK_OPTIONS + MOC_OPTIONS + DISABLE_AUTOGEN_TOOLS + ENABLE_AUTOGEN_TOOLS + PLUGIN_TYPES + NO_PCH_SOURCES + NO_UNITY_BUILD_SOURCES + ) + set(__default_public_args + PUBLIC_LIBRARIES + PUBLIC_INCLUDE_DIRECTORIES + PUBLIC_DEFINES + PUBLIC_COMPILE_OPTIONS + PUBLIC_LINK_OPTIONS + ) + set(__default_private_module_args + PRIVATE_MODULE_INTERFACE + ) + set(__default_target_info_args + TARGET_VERSION + TARGET_PRODUCT + TARGET_DESCRIPTION + TARGET_COMPANY + TARGET_COPYRIGHT + ) + + _qt_internal_get_sbom_add_target_common_options( + __qt_internal_sbom_optional_args + __qt_internal_sbom_single_args + __qt_internal_sbom_multi_args + ) + + # Collection of arguments so they can be shared across qt_internal_add_executable + # and qt_internal_add_test_helper. + set(__qt_internal_add_executable_optional_args + GUI + NO_INSTALL + EXCEPTIONS + DELAY_RC + DELAY_TARGET_INFO + QT_APP + QT_TEST + QT_MANUAL_TEST + NO_UNITY_BUILD + ${__qt_internal_sbom_optional_args} + ) + set(__qt_internal_add_executable_single_args + CORE_LIBRARY + OUTPUT_DIRECTORY + INSTALL_DIRECTORY + VERSION + ${__default_target_info_args} + ${__qt_internal_sbom_single_args} + ) + set(__qt_internal_add_executable_multi_args + ${__default_private_args} + ${__default_public_args} + ${__qt_internal_sbom_multi_args} + ) +endmacro() + +# Append a config-specific postfix to library names to ensure distinct names +# in a multi-config build. +# e.g. lib/libQt6DBus_relwithdebinfo.6.3.0.dylib +# Don't apply the postfix to the first encountered release-like config, so we have at least one +# config without a postifx. +# If postfixes are set by user warn about potential issues. +function(qt_internal_setup_cmake_config_postfix) + # Collect configuration that require postfix in Qt library names. + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(postfix_configurations ${CMAKE_CONFIGURATION_TYPES}) + else() + set(postfix_configurations ${CMAKE_BUILD_TYPE}) + + # Set the default postfix to empty by default for single-config builds. + string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lower) + set(default_cmake_${build_type_lower}_postfix "") + endif() + + # Override the generic debug postfixes above with custom debug postfixes (even in a single + # config build) to follow the conventions we had since Qt 5. + # e.g. lib/libQt6DBus_debug.6.3.0.dylib + if(WIN32) + if(MINGW) + # On MinGW we don't have "d" suffix for debug libraries like on Linux, + # unless we're building debug and release libraries in one go. + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(default_cmake_debug_postfix "d") + endif() + else() + set(default_cmake_debug_postfix "d") + endif() + elseif(APPLE) + # Only add a suffix for explicit no-framework builds. + # For framework builds the library inside the framework + # is always unsuffixed, and we want to match that for + # plugins and other non-framework (static) libraries. + if(NOT (QT_FEATURE_framework OR FEATURE_framework + # Account for default in configure.json being ON + OR (NOT DEFINED QT_FEATURE_framework AND NOT DEFINED FEATURE_framework))) + set(default_cmake_debug_postfix "_debug") + endif() + endif() + + set(custom_postfix_vars "") + set(release_configs Release RelWithDebInfo MinSizeRel) + set(found_first_release_config FALSE) + foreach(config_type IN LISTS postfix_configurations) + string(TOLOWER "${config_type}" config_type_lower) + string(TOUPPER "${config_type}" config_type_upper) + set(postfix_var CMAKE_${config_type_upper}_POSTFIX) + + # Skip assigning postfix for the first release-like config. + if(NOT found_first_release_config + AND config_type IN_LIST release_configs) + set(found_first_release_config TRUE) + if(NOT "${${postfix_var}}" STREQUAL "") + list(APPEND custom_postfix_vars ${postfix_var}) + endif() + continue() + endif() + + # Check if the default postfix is set, use '_' otherwise. + set(default_postfix_var + default_cmake_${config_type_lower}_postfix) + if(NOT DEFINED ${default_postfix_var}) + set(${default_postfix_var} + "_${config_type_lower}") + endif() + + # If postfix is set by user avoid changing it, but save postfix variable that has + # a non-default value for further warning. + if("${${postfix_var}}" STREQUAL "") + set(${postfix_var} "${${default_postfix_var}}") + set(${postfix_var} "${${default_postfix_var}}" PARENT_SCOPE) + elseif(NOT "${${postfix_var}}" STREQUAL "${${default_postfix_var}}") + list(APPEND custom_postfix_vars ${postfix_var}) + endif() + + # Adjust framework postfixes accordingly + if(APPLE) + set(CMAKE_FRAMEWORK_MULTI_CONFIG_POSTFIX_${config_type_upper} + "${${postfix_var}}" PARENT_SCOPE) + endif() + endforeach() + if(custom_postfix_vars) + list(REMOVE_DUPLICATES custom_postfix_vars) + list(JOIN custom_postfix_vars ", " postfix_vars_string) + + message(WARNING "You are using custom library postfixes: '${postfix_vars_string}' which are" + " considered experimental and are not officially supported by Qt." + " Expect unforeseen issues and user projects built with qmake to be broken." + ) + endif() +endfunction() + +function(qt_is_imported_target target out_var) + if(NOT TARGET "${target}") + set(target "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + endif() + if(NOT TARGET "${target}") + message(FATAL_ERROR "Invalid target given to qt_is_imported_target: ${target}") + endif() + get_target_property(is_imported "${target}" IMPORTED) + set(${out_var} "${is_imported}" PARENT_SCOPE) +endfunction() + +# Add Qt::target and Qt6::target as aliases for the target +function(qt_internal_add_target_aliases target) + set(versionless_alias "Qt::${target}") + set(versionfull_alias "Qt${PROJECT_VERSION_MAJOR}::${target}") + set_target_properties("${target}" PROPERTIES _qt_versionless_alias "${versionless_alias}") + set_target_properties("${target}" PROPERTIES _qt_versionfull_alias "${versionfull_alias}") + + get_target_property(type "${target}" TYPE) + if (type STREQUAL EXECUTABLE) + add_executable("${versionless_alias}" ALIAS "${target}") + add_executable("${versionfull_alias}" ALIAS "${target}") + else() + add_library("${versionless_alias}" ALIAS "${target}") + add_library("${versionfull_alias}" ALIAS "${target}") + endif() +endfunction() + +function(qt_get_cmake_configurations out_var) + set(possible_configs "${CMAKE_BUILD_TYPE}") + if(CMAKE_CONFIGURATION_TYPES) + set(possible_configs "${CMAKE_CONFIGURATION_TYPES}") + endif() + set(${out_var} "${possible_configs}" PARENT_SCOPE) +endfunction() + +function(qt_clone_property_for_configs target property configs) + get_target_property(value "${target}" "${property}") + foreach(config ${configs}) + string(TOUPPER "${config}" upper_config) + set_property(TARGET "${target}" PROPERTY "${property}_${upper_config}" "${value}") + endforeach() +endfunction() + +function(qt_handle_multi_config_output_dirs target) + qt_get_cmake_configurations(possible_configs) + qt_clone_property_for_configs(${target} LIBRARY_OUTPUT_DIRECTORY "${possible_configs}") + qt_clone_property_for_configs(${target} RUNTIME_OUTPUT_DIRECTORY "${possible_configs}") + qt_clone_property_for_configs(${target} ARCHIVE_OUTPUT_DIRECTORY "${possible_configs}") +endfunction() + +# Set target properties that are the same for all modules, plugins, executables +# and 3rdparty libraries. +function(qt_set_common_target_properties target) + if(QT_FEATURE_reduce_exports) + set_target_properties(${target} PROPERTIES + C_VISIBILITY_PRESET hidden + CXX_VISIBILITY_PRESET hidden + OBJC_VISIBILITY_PRESET hidden + OBJCXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN 1) + endif() + qt_internal_set_compile_pdb_names("${target}") +endfunction() + +# Set common, informational target properties. +# +# On Windows, these properties are used to generate the version information resource. +function(qt_set_target_info_properties target) + cmake_parse_arguments(arg "" "${__default_target_info_args}" "" ${ARGN}) + if(NOT arg_TARGET_VERSION) + set(arg_TARGET_VERSION "${PROJECT_VERSION}.0") + endif() + if(NOT arg_TARGET_PRODUCT) + set(arg_TARGET_PRODUCT "Qt6") + endif() + if(NOT arg_TARGET_DESCRIPTION) + set(arg_TARGET_DESCRIPTION "C++ Application Development Framework") + endif() + if(NOT arg_TARGET_COMPANY) + set(arg_TARGET_COMPANY "The Qt Company Ltd.") + endif() + if(NOT arg_TARGET_COPYRIGHT) + set(arg_TARGET_COPYRIGHT "${QT_COPYRIGHT}") + endif() + set_target_properties(${target} PROPERTIES + QT_TARGET_VERSION "${arg_TARGET_VERSION}" + QT_TARGET_COMPANY_NAME "${arg_TARGET_COMPANY}" + QT_TARGET_DESCRIPTION "${arg_TARGET_DESCRIPTION}" + QT_TARGET_COPYRIGHT "${arg_TARGET_COPYRIGHT}" + QT_TARGET_PRODUCT_NAME "${arg_TARGET_PRODUCT}") +endfunction() + +# Uses the QT_DELAYED_TARGET_* property values to set the final QT_TARGET_* properties. +# Needed when doing executable finalization at the end of a subdirectory scope +# (aka scope finalization). +function(qt_internal_set_target_info_properties_from_delayed_properties target) + set(args "") + foreach(prop ${__default_target_info_args}) + get_target_property(prop_value "${target}" "QT_DELAYED_${prop}") + list(APPEND args "${prop}" "${prop_value}") + endforeach() + qt_set_target_info_properties(${target} ${args}) +endfunction() + +# Updates the QT_DELAYED_ properties with values from the QT_ variants, in case if they were +# set in-between a qt_add_* call and before scope finalization. +function(qt_internal_update_delayed_target_info_properties target) + foreach(prop ${__default_target_info_args}) + get_target_property(prop_value "${target}" "QT_${prop}") + get_target_property(delayed_prop_value ${target} "QT_DELAYED_${prop}") + set(final_value "${delayed_prop_value}") + if(prop_value) + set(final_value "${prop_value}") + endif() + set_target_properties(${target} PROPERTIES "QT_DELAYED_${prop}" "${final_value}") + endforeach() +endfunction() + +function(qt_internal_check_directory_or_type name dir type default result_var) + if ("x${dir}" STREQUAL x) + if("x${type}" STREQUAL x) + message(FATAL_ERROR + "qt_internal_add_plugin called without setting either PLUGIN_TYPE or ${name}.") + endif() + set(${result_var} "${default}" PARENT_SCOPE) + else() + set(${result_var} "${dir}" PARENT_SCOPE) + endif() +endfunction() + +macro(qt_internal_get_export_additional_targets_keywords option_args single_args multi_args) + set(${option_args} + ) + set(${single_args} + EXPORT_NAME_PREFIX + ) + set(${multi_args} + TARGETS + TARGET_EXPORT_NAMES + ) +endmacro() + +# Create a Qt*AdditionalTargetInfo.cmake file that is included by Qt*Config.cmake +# and sets IMPORTED_*_ properties on the exported targets. +# +# The file also makes the targets global if the QT_PROMOTE_TO_GLOBAL_TARGETS property is set in the +# consuming project. +# When using a CMake version lower than 3.21, only the specified TARGETS are made global. +# E.g. transitive non-Qt 3rd party targets of the specified targets are not made global. +# +# EXPORT_NAME_PREFIX: +# The portion of the file name before AdditionalTargetInfo.cmake +# CONFIG_INSTALL_DIR: +# Installation location for the target info file +# TARGETS: +# The internal target names. Those must be actual targets. +# TARGET_EXPORT_NAMES: +# The target names how they appear in the QtXXXTargets.cmake files. +# The names get prefixed by ${QT_CMAKE_EXPORT_NAMESPACE}:: unless they already are. +# This argument may be empty, then the target export names are the same as the internal ones. +# +# TARGETS and TARGET_EXPORT_NAMES must contain exactly the same number of elements. +# Example: TARGETS = qmljs_native +# TARGET_EXPORT_NAMES = Qt6::qmljs +# +function(qt_internal_export_additional_targets_file) + qt_internal_get_export_additional_targets_keywords(option_args single_args multi_args) + cmake_parse_arguments(arg + "${option_args}" + "${single_args};CONFIG_INSTALL_DIR" + "${multi_args}" + ${ARGN}) + + qt_internal_append_export_additional_targets() + + set_property(GLOBAL APPEND PROPERTY _qt_export_additional_targets_ids "${id}") + set_property(GLOBAL APPEND + PROPERTY _qt_export_additional_targets_export_name_prefix_${id} "${arg_EXPORT_NAME_PREFIX}") + set_property(GLOBAL APPEND + PROPERTY _qt_export_additional_targets_config_install_dir_${id} "${arg_CONFIG_INSTALL_DIR}") + + qt_add_list_file_finalizer(qt_internal_export_additional_targets_file_finalizer) +endfunction() + +function(qt_internal_get_export_additional_targets_id export_name out_var) + string(MAKE_C_IDENTIFIER "${export_name}" id) + set(${out_var} "${id}" PARENT_SCOPE) +endfunction() + +# Uses outer-scope variables to keep the implementation less verbose. +macro(qt_internal_append_export_additional_targets) + qt_internal_validate_export_additional_targets( + EXPORT_NAME_PREFIX "${arg_EXPORT_NAME_PREFIX}" + TARGETS ${arg_TARGETS} + TARGET_EXPORT_NAMES ${arg_TARGET_EXPORT_NAMES}) + + qt_internal_get_export_additional_targets_id("${arg_EXPORT_NAME_PREFIX}" id) + + set_property(GLOBAL APPEND + PROPERTY _qt_export_additional_targets_${id} "${arg_TARGETS}") + set_property(GLOBAL APPEND + PROPERTY _qt_export_additional_target_export_names_${id} "${arg_TARGET_EXPORT_NAMES}") +endmacro() + +# Can be called to add additional targets to the file after the initial setup call. +# Used for resources. +function(qt_internal_add_targets_to_additional_targets_export_file) + qt_internal_get_export_additional_targets_keywords(option_args single_args multi_args) + cmake_parse_arguments(arg + "${option_args}" + "${single_args}" + "${multi_args}" + ${ARGN}) + + qt_internal_append_export_additional_targets() +endfunction() + +function(qt_internal_validate_export_additional_targets) + qt_internal_get_export_additional_targets_keywords(option_args single_args multi_args) + cmake_parse_arguments(arg + "${option_args}" + "${single_args}" + "${multi_args}" + ${ARGN}) + + if(NOT arg_EXPORT_NAME_PREFIX) + message(FATAL_ERROR "qt_internal_validate_export_additional_targets: " + "Missing EXPORT_NAME_PREFIX argument.") + endif() + + list(LENGTH arg_TARGETS num_TARGETS) + list(LENGTH arg_TARGET_EXPORT_NAMES num_TARGET_EXPORT_NAMES) + if(num_TARGET_EXPORT_NAMES GREATER 0) + if(NOT num_TARGETS EQUAL num_TARGET_EXPORT_NAMES) + message(FATAL_ERROR "qt_internal_validate_export_additional_targets: " + "TARGET_EXPORT_NAMES is set but has ${num_TARGET_EXPORT_NAMES} elements while " + "TARGETS has ${num_TARGETS} elements. " + "They must contain the same number of elements.") + endif() + else() + set(arg_TARGET_EXPORT_NAMES ${arg_TARGETS}) + endif() + + set(arg_TARGETS "${arg_TARGETS}" PARENT_SCOPE) + set(arg_TARGET_EXPORT_NAMES "${arg_TARGET_EXPORT_NAMES}" PARENT_SCOPE) +endfunction() + +# The finalizer might be called multiple times in the same scope, but only the first one will +# process all the ids. +function(qt_internal_export_additional_targets_file_finalizer) + get_property(ids GLOBAL PROPERTY _qt_export_additional_targets_ids) + + foreach(id ${ids}) + qt_internal_export_additional_targets_file_handler("${id}") + endforeach() + + set_property(GLOBAL PROPERTY _qt_export_additional_targets_ids "") +endfunction() + +function(qt_internal_export_additional_targets_file_handler id) + get_property(arg_EXPORT_NAME_PREFIX GLOBAL PROPERTY + _qt_export_additional_targets_export_name_prefix_${id}) + get_property(arg_CONFIG_INSTALL_DIR GLOBAL PROPERTY + _qt_export_additional_targets_config_install_dir_${id}) + get_property(arg_TARGETS GLOBAL PROPERTY + _qt_export_additional_targets_${id}) + get_property(arg_TARGET_EXPORT_NAMES GLOBAL PROPERTY + _qt_export_additional_target_export_names_${id}) + + list(LENGTH arg_TARGETS num_TARGETS) + + # Determine the release configurations we're currently building + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(active_configurations ${CMAKE_CONFIGURATION_TYPES}) + else() + set(active_configurations ${CMAKE_BUILD_TYPE}) + endif() + unset(active_release_configurations) + foreach(config ${active_configurations}) + string(TOUPPER ${config} ucconfig) + if(NOT ucconfig STREQUAL "DEBUG") + list(APPEND active_release_configurations ${config}) + endif() + endforeach() + + if(active_release_configurations) + # Use the first active release configuration as *the* release config for imported targets + # and for QT_DEFAULT_IMPORT_CONFIGURATION. + list(GET active_release_configurations 0 release_cfg) + string(TOUPPER ${release_cfg} uc_release_cfg) + set(uc_default_cfg ${uc_release_cfg}) + + # Determine the release configurations we do *not* build currently + set(configurations_to_export Release;RelWithDebInfo;MinSizeRel) + list(REMOVE_ITEM configurations_to_export ${active_configurations}) + else() + # There are no active release configurations. + # Use the first active configuration for QT_DEFAULT_IMPORT_CONFIGURATION. + unset(uc_release_cfg) + list(GET active_configurations 0 default_cfg) + string(TOUPPER ${default_cfg} uc_default_cfg) + unset(configurations_to_export) + endif() + + set(content "# Additional target information for ${arg_EXPORT_NAME_PREFIX} +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION ${uc_default_cfg}) +endif() +") + + math(EXPR n "${num_TARGETS} - 1") + foreach(i RANGE ${n}) + list(GET arg_TARGETS ${i} target) + list(GET arg_TARGET_EXPORT_NAMES ${i} target_export_name) + + set(full_target ${target_export_name}) + if(NOT full_target MATCHES "^${QT_CMAKE_EXPORT_NAMESPACE}::") + string(PREPEND full_target "${QT_CMAKE_EXPORT_NAMESPACE}::") + endif() + + # Tools are already made global unconditionally in QtFooToolsConfig.cmake. + # And the + get_target_property(target_type ${target} TYPE) + if(NOT target_type STREQUAL "EXECUTABLE") + string(APPEND content + "__qt_internal_promote_target_to_global_checked(${full_target})\n") + endif() + + # INTERFACE libraries don't have IMPORTED_LOCATION-like properties. + # Skip the rest of the processing for those. + if(target_type STREQUAL "INTERFACE_LIBRARY") + continue() + endif() + + set(properties_retrieved TRUE) + + get_target_property(is_configure_time_target ${target} _qt_internal_configure_time_target) + if(is_configure_time_target) + # For Multi-config developer builds we should simply reuse IMPORTED_LOCATION of the + # target. + if(NOT QT_WILL_INSTALL AND QT_FEATURE_debug_and_release) + set(configure_time_target_build_location "") + get_target_property(configure_time_target_install_location ${target} + IMPORTED_LOCATION) + else() + if(IS_ABSOLUTE "${arg_CONFIG_INSTALL_DIR}") + file(RELATIVE_PATH reverse_relative_prefix_path + "${arg_CONFIG_INSTALL_DIR}" "${CMAKE_INSTALL_PREFIX}") + else() + file(RELATIVE_PATH reverse_relative_prefix_path + "${CMAKE_INSTALL_PREFIX}/${arg_CONFIG_INSTALL_DIR}" + "${CMAKE_INSTALL_PREFIX}") + endif() + + get_target_property(configure_time_target_build_location ${target} + _qt_internal_configure_time_target_build_location) + string(TOUPPER "${QT_CMAKE_EXPORT_NAMESPACE}_INSTALL_PREFIX" install_prefix_var) + string(JOIN "" configure_time_target_build_location + "$\{CMAKE_CURRENT_LIST_DIR}/" + "${reverse_relative_prefix_path}" + "${configure_time_target_build_location}") + + get_target_property(configure_time_target_install_location ${target} + _qt_internal_configure_time_target_install_location) + + string(JOIN "" configure_time_target_install_location + "$\{CMAKE_CURRENT_LIST_DIR}/" + "${reverse_relative_prefix_path}" + "${configure_time_target_install_location}") + endif() + if(configure_time_target_install_location) + string(APPEND content " +# Import configure-time executable ${full_target} +if(NOT TARGET ${full_target}) + set(_qt_imported_build_location \"${configure_time_target_build_location}\") + set(_qt_imported_install_location \"${configure_time_target_install_location}\") + set(_qt_imported_location \"\${_qt_imported_install_location}\") + if(NOT EXISTS \"$\{_qt_imported_location}\" + AND NOT \"$\{_qt_imported_build_location}\" STREQUAL \"\") + set(_qt_imported_location \"\${_qt_imported_build_location}\") + endif() + if(NOT EXISTS \"$\{_qt_imported_location}\") + message(FATAL_ERROR \"Unable to add configure time executable ${full_target}\" + \" $\{_qt_imported_location} doesn't exists\") + endif() + add_executable(${full_target} IMPORTED) + set_property(TARGET ${full_target} APPEND PROPERTY IMPORTED_CONFIGURATIONS ${default_cfg}) + set_target_properties(${full_target} PROPERTIES IMPORTED_LOCATION_${uc_default_cfg} + \"$\{_qt_imported_location}\") + set_property(TARGET ${full_target} PROPERTY IMPORTED_GLOBAL TRUE) + unset(_qt_imported_location) + unset(_qt_imported_build_location) + unset(_qt_imported_install_location) +endif() +\n") + endif() + endif() + + # Non-prefix debug-and-release builds: add check for the existence of the debug binary of + # the target. It is not built by default. + if(NOT QT_WILL_INSTALL AND QT_FEATURE_debug_and_release) + get_target_property(excluded_genex ${target} EXCLUDE_FROM_ALL) + if(excluded_genex) + string(APPEND content " +# ${full_target} is not built by default in the Debug configuration. Check existence. +get_target_property(_qt_imported_location ${full_target} IMPORTED_LOCATION_DEBUG) +if(NOT EXISTS \"$\{_qt_imported_location}\") + get_target_property(_qt_imported_configs ${full_target} IMPORTED_CONFIGURATIONS) + list(REMOVE_ITEM _qt_imported_configs DEBUG) + set_property(TARGET ${full_target} PROPERTY IMPORTED_CONFIGURATIONS $\{_qt_imported_configs}) + set_property(TARGET ${full_target} PROPERTY IMPORTED_LOCATION_DEBUG) +endif()\n") + endif() + endif() + + set(write_implib FALSE) + set(write_soname FALSE) + set(write_objects FALSE) + set(write_link_dependencies FALSE) + set(write_location TRUE) + + if(target_type STREQUAL "SHARED_LIBRARY") + if(WIN32) + set(write_implib TRUE) + elseif(WASM) + # Keep write_soname at FALSE + else() + set(write_soname TRUE) + endif() + set(write_link_dependencies TRUE) + elseif(target_type STREQUAL "OBJECT_LIBRARY") + set(write_objects TRUE) + set(write_location FALSE) + endif() + + if(NOT "${uc_release_cfg}" STREQUAL "") + if(write_location) + string(APPEND content "get_target_property(_qt_imported_location ${full_target} IMPORTED_LOCATION_${uc_release_cfg})\n") + endif() + if(write_implib) + string(APPEND content "get_target_property(_qt_imported_implib ${full_target} IMPORTED_IMPLIB_${uc_release_cfg})\n") + endif() + if(write_soname) + string(APPEND content "get_target_property(_qt_imported_soname ${full_target} IMPORTED_SONAME_${uc_release_cfg})\n") + endif() + if(write_link_dependencies) + string(APPEND content "get_target_property(_qt_imported_link_dependencies ${full_target} IMPORTED_LINK_DEPENDENT_LIBRARIES_${uc_release_cfg})\n") + endif() + if(write_objects) + string(APPEND content "get_target_property(_qt_imported_objects ${full_target} IMPORTED_OBJECTS_${uc_release_cfg})\n") + # We generate CLR props as well, because that's what CMake generates for object + # libraries with CMake 3.27. They are usually empty strings though, aka "". + string(APPEND content "get_target_property(_qt_imported_clr ${full_target} IMPORTED_COMMON_LANGUAGE_RUNTIME_${uc_release_cfg})\n") + endif() + endif() + if(write_location) + string(APPEND content "get_target_property(_qt_imported_location_default ${full_target} IMPORTED_LOCATION_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n") + endif() + if(write_implib) + string(APPEND content "get_target_property(_qt_imported_implib_default ${full_target} IMPORTED_IMPLIB_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n") + endif() + if(write_soname) + string(APPEND content "get_target_property(_qt_imported_soname_default ${full_target} IMPORTED_SONAME_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n") + endif() + if(write_link_dependencies) + string(APPEND content "get_target_property(_qt_imported_link_dependencies_default ${full_target} IMPORTED_LINK_DEPENDENT_LIBRARIES_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n") + endif() + if(write_objects) + string(APPEND content "get_target_property(_qt_imported_objects_default ${full_target} IMPORTED_OBJECTS_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n") + string(APPEND content "get_target_property(_qt_imported_clr_default ${full_target} IMPORTED_COMMON_LANGUAGE_RUNTIME_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n") + endif() + foreach(config ${configurations_to_export} "") + string(TOUPPER "${config}" ucconfig) + if("${config}" STREQUAL "") + set(property_suffix "") + set(var_suffix "_default") + string(APPEND content "\n# Default configuration") + else() + set(property_suffix "_${ucconfig}") + set(var_suffix "") + string(APPEND content " +# Import target \"${full_target}\" for configuration \"${config}\" +set_property(TARGET ${full_target} APPEND PROPERTY IMPORTED_CONFIGURATIONS ${ucconfig}) +") + endif() + if(write_location) + string(APPEND content " +if(_qt_imported_location${var_suffix}) + set_property(TARGET ${full_target} PROPERTY IMPORTED_LOCATION${property_suffix} \"$\{_qt_imported_location${var_suffix}}\") +endif()") + endif() + if(write_implib) + string(APPEND content " +if(_qt_imported_implib${var_suffix}) + set_property(TARGET ${full_target} PROPERTY IMPORTED_IMPLIB${property_suffix} \"$\{_qt_imported_implib${var_suffix}}\") +endif()") + endif() + if(write_soname) + string(APPEND content " +if(_qt_imported_soname${var_suffix}) + set_property(TARGET ${full_target} PROPERTY IMPORTED_SONAME${property_suffix} \"$\{_qt_imported_soname${var_suffix}}\") +endif()") + endif() + if(write_link_dependencies) + string(APPEND content " +if(_qt_imported_link_dependencies${var_suffix}) + set_property(TARGET ${full_target} PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES${property_suffix} \"$\{_qt_imported_link_dependencies${var_suffix}}\") +endif()") + endif() + if(write_objects) + string(APPEND content " +if(_qt_imported_objects${var_suffix}) + set_property(TARGET ${full_target} PROPERTY IMPORTED_OBJECTS${property_suffix} \"$\{_qt_imported_objects${var_suffix}}\") +endif()") + string(APPEND content " +if(_qt_imported_clr${var_suffix}) + set_property(TARGET ${full_target} PROPERTY IMPORTED_COMMON_LANGUAGE_RUNTIME${property_suffix} \"$\{_qt_imported_clr${var_suffix}}\") +endif()") + endif() + string(APPEND content "\n") + endforeach() + endforeach() + + if(properties_retrieved) + string(APPEND content " +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs)") + endif() + + qt_path_join(output_file "${arg_CONFIG_INSTALL_DIR}" + "${arg_EXPORT_NAME_PREFIX}AdditionalTargetInfo.cmake") + if(NOT IS_ABSOLUTE "${output_file}") + qt_path_join(output_file "${QT_BUILD_DIR}" "${output_file}") + endif() + qt_configure_file(OUTPUT "${output_file}" CONTENT "${content}") + qt_install(FILES "${output_file}" DESTINATION "${arg_CONFIG_INSTALL_DIR}") +endfunction() + +function(qt_internal_export_modern_cmake_config_targets_file) + cmake_parse_arguments(arg + "" + "EXPORT_NAME_PREFIX;CONFIG_BUILD_DIR;CONFIG_INSTALL_DIR" + "TARGETS" + ${ARGN} + ) + + if("${arg_TARGETS}" STREQUAL "") + message(FATAL_ERROR "Target list is empty") + endif() + + if("${arg_CONFIG_BUILD_DIR}" STREQUAL "") + message(FATAL_ERROR "CONFIG_BUILD_DIR is not specified") + endif() + + if("${arg_CONFIG_INSTALL_DIR}" STREQUAL "") + message(FATAL_ERROR "CONFIG_INSTALL_DIR is not specified") + endif() + + if("${arg_EXPORT_NAME_PREFIX}" STREQUAL "") + message(FATAL_ERROR "EXPORT_NAME_PREFIX is not specified") + endif() + + set(versionless_targets ${arg_TARGETS}) + + # CMake versions < 3.18 compatibility code. Creates the mimics of the versioned libraries. + set(versionless_targets_export "${arg_CONFIG_BUILD_DIR}/${arg_EXPORT_NAME_PREFIX}VersionlessTargets.cmake") + configure_file("${QT_CMAKE_DIR}/QtVersionlessTargets.cmake.in" + "${versionless_targets_export}" + @ONLY + ) + + # CMake versions >= 3.18 code. Create the versionless ALIAS targets. + set(alias_export "${arg_CONFIG_BUILD_DIR}/${arg_EXPORT_NAME_PREFIX}VersionlessAliasTargets.cmake") + configure_file("${QT_CMAKE_DIR}/QtVersionlessAliasTargets.cmake.in" + "${alias_export}" + @ONLY + ) + + qt_install(FILES + "${alias_export}" + "${versionless_targets_export}" + DESTINATION "${arg_CONFIG_INSTALL_DIR}" + COMPONENT Devel + ) +endfunction() + +function(qt_internal_create_tracepoints name tracepoints_file) + string(TOLOWER "${name}" provider_name) + string(PREPEND provider_name "qt") + set(header_filename "${provider_name}_tracepoints_p.h") + set(header_path "${CMAKE_CURRENT_BINARY_DIR}/${header_filename}") + + if(QT_FEATURE_lttng OR QT_FEATURE_etw OR QT_FEATURE_ctf) + set(source_path "${CMAKE_CURRENT_BINARY_DIR}/${provider_name}_tracepoints.cpp") + qt_configure_file(OUTPUT "${source_path}" + CONTENT "#define TRACEPOINT_CREATE_PROBES +#define TRACEPOINT_DEFINE +#include \"${header_filename}\"") + target_sources(${name} PRIVATE "${source_path}") + target_compile_definitions(${name} PUBLIC Q_TRACEPOINT) + + if(QT_FEATURE_lttng) + set(tracegen_arg "lttng") + target_link_libraries(${name} PRIVATE LTTng::UST) + elseif(QT_FEATURE_etw) + set(tracegen_arg "etw") + elseif(QT_FEATURE_ctf) + set(tracegen_arg "ctf") + endif() + + if(NOT "${QT_HOST_PATH}" STREQUAL "") + qt_path_join(tracegen + "${QT_HOST_PATH}" + "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}" + "tracegen") + else() + set(tracegen "${QT_CMAKE_EXPORT_NAMESPACE}::tracegen") + endif() + + get_filename_component(tracepoints_filepath "${tracepoints_file}" ABSOLUTE) + add_custom_command(OUTPUT "${header_path}" + COMMAND ${tracegen} ${tracegen_arg} "${tracepoints_filepath}" "${header_path}" + VERBATIM) + add_custom_target(${name}_tracepoints_header DEPENDS "${header_path}") + add_dependencies(${name} ${name}_tracepoints_header) + else() + qt_configure_file(OUTPUT "${header_path}" CONTENT "#include \n") + endif() +endfunction() + +function(qt_internal_generate_tracepoints name provider) + cmake_parse_arguments(arg "" "" "SOURCES" ${ARGN} ) + set(provider_name ${provider}) + string(PREPEND provider_name "qt") + set(tracepoint_filename "${provider_name}.tracepoints") + set(tracepoints_path "${CMAKE_CURRENT_BINARY_DIR}/${tracepoint_filename}") + set(header_filename "${provider_name}_tracepoints_p.h") + set(header_path "${CMAKE_CURRENT_BINARY_DIR}/${header_filename}") + + if(QT_FEATURE_lttng OR QT_FEATURE_etw OR QT_FEATURE_ctf) + + set(absolute_file_paths "") + foreach(file IN LISTS arg_SOURCES) + get_filename_component(absolute_file ${file} ABSOLUTE) + list(APPEND absolute_file_paths ${absolute_file}) + endforeach() + + if(NOT "${QT_HOST_PATH}" STREQUAL "") + qt_path_join(tracepointgen + "${QT_HOST_PATH}" + "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}" + "tracepointgen") + else() + set(tracepointgen "${QT_CMAKE_EXPORT_NAMESPACE}::tracepointgen") + endif() + + add_custom_command(OUTPUT "${tracepoints_path}" + COMMAND ${tracepointgen} ${provider_name} "${tracepoints_path}" "I$,;>" ${absolute_file_paths} + DEPENDS ${absolute_file_paths} + VERBATIM) + add_custom_target(${name}_${provider_name}_tracepoints_file DEPENDS "${tracepoints_path}") + add_dependencies(${name} ${name}_${provider_name}_tracepoints_file) + + set(source_path "${CMAKE_CURRENT_BINARY_DIR}/${provider_name}_tracepoints.cpp") + qt_configure_file(OUTPUT "${source_path}" + CONTENT "#define TRACEPOINT_CREATE_PROBES + #define TRACEPOINT_DEFINE + #include \"${header_filename}\"") + target_sources(${name} PRIVATE "${source_path}") + target_compile_definitions(${name} PUBLIC Q_TRACEPOINT) + + if(QT_FEATURE_lttng) + set(tracegen_arg "lttng") + target_link_libraries(${name} PRIVATE LTTng::UST) + elseif(QT_FEATURE_etw) + set(tracegen_arg "etw") + elseif(QT_FEATURE_ctf) + set(tracegen_arg "ctf") + endif() + + if(NOT "${QT_HOST_PATH}" STREQUAL "") + qt_path_join(tracegen + "${QT_HOST_PATH}" + "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}" + "tracegen") + else() + set(tracegen "${QT_CMAKE_EXPORT_NAMESPACE}::tracegen") + endif() + + get_filename_component(tracepoints_filepath "${tracepoints_path}" ABSOLUTE) + add_custom_command(OUTPUT "${header_path}" + COMMAND ${tracegen} ${tracegen_arg} "${tracepoints_filepath}" "${header_path}" + DEPENDS "${tracepoints_path}" + VERBATIM) + add_custom_target(${name}_${provider_name}_tracepoints_header DEPENDS "${header_path}") + add_dependencies(${name} ${name}_${provider_name}_tracepoints_header) + else() + qt_configure_file(OUTPUT "${header_path}" CONTENT "#include \n") + endif() +endfunction() + +function(qt_internal_set_compile_pdb_names target) + if(MSVC) + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "STATIC_LIBRARY" OR target_type STREQUAL "OBJECT_LIBRARY") + get_target_property(output_name ${target} OUTPUT_NAME) + if(NOT output_name) + set(output_name "${INSTALL_CMAKE_NAMESPACE}${target}") + endif() + set_target_properties(${target} PROPERTIES COMPILE_PDB_NAME "${output_name}") + set_target_properties(${target} PROPERTIES COMPILE_PDB_NAME_DEBUG "${output_name}d") + endif() + endif() +endfunction() + +# Installs pdb files for given target into the specified install dir. +# +# MSVC generates 2 types of pdb files: +# - compile-time generated pdb files (compile flag /Zi + /Fd) +# - link-time generated pdb files (link flag /debug + /PDB:) +# +# CMake allows changing the names of each of those pdb file types by setting +# the COMPILE_PDB_NAME_ and PDB_NAME_ properties. If they are +# left empty, CMake will compute the default names itself (or rather in certain cases +# leave it up to the compiler), without actually setting the property values. +# +# For installation purposes, CMake only provides a generator expression to the +# link time pdb file path, not the compile path one, which means we have to compute the +# path to the compile path pdb files ourselves. +# See https://gitlab.kitware.com/cmake/cmake/-/issues/18393 for details. +# +# For shared libraries and executables, we install the linker provided pdb file via the +# TARGET_PDB_FILE generator expression. +# +# For static libraries there is no linker invocation, so we need to install the compile +# time pdb file. We query the ARCHIVE_OUTPUT_DIRECTORY property of the target to get the +# path to the pdb file, and reconstruct the file name. We use a generator expression +# to append a possible debug suffix, in order to allow installation of all Release and +# Debug pdb files when using Ninja Multi-Config. +function(qt_internal_install_pdb_files target install_dir_path) + if(MSVC) + get_target_property(target_type ${target} TYPE) + + if(target_type STREQUAL "EXECUTABLE") + qt_get_cmake_configurations(cmake_configs) + list(LENGTH cmake_configs all_configs_count) + list(GET cmake_configs 0 first_config) + foreach(cmake_config ${cmake_configs}) + set(suffix "") + if(all_configs_count GREATER 1 AND NOT cmake_config STREQUAL first_config) + set(suffix "/${cmake_config}") + endif() + qt_install(FILES "$" + CONFIGURATIONS ${cmake_config} + DESTINATION "${install_dir_path}${suffix}" + OPTIONAL) + endforeach() + + elseif(target_type STREQUAL "SHARED_LIBRARY" + OR target_type STREQUAL "MODULE_LIBRARY") + qt_install(FILES "$" + DESTINATION "${install_dir_path}" + OPTIONAL) + + elseif(target_type STREQUAL "STATIC_LIBRARY") + get_target_property(lib_dir "${target}" ARCHIVE_OUTPUT_DIRECTORY) + if(NOT lib_dir) + message(FATAL_ERROR + "Can't install pdb file for static library ${target}. " + "The ARCHIVE_OUTPUT_DIRECTORY path is not known.") + endif() + get_target_property(pdb_name "${target}" COMPILE_PDB_NAME) + qt_path_join(compile_time_pdb_file_path + "${lib_dir}" "${pdb_name}$<$:d>.pdb") + + qt_install(FILES "${compile_time_pdb_file_path}" + DESTINATION "${install_dir_path}" OPTIONAL) + elseif(target_type STREQUAL "OBJECT_LIBRARY") + get_target_property(pdb_dir "${target}" COMPILE_PDB_OUTPUT_DIRECTORY) + if(NOT pdb_dir) + get_target_property(pdb_dir "${target}" BINARY_DIR) + if(QT_GENERATOR_IS_MULTI_CONFIG) + qt_path_join(pdb_dir "${pdb_dir}" "$") + endif() + endif() + get_target_property(pdb_name "${target}" COMPILE_PDB_NAME) + qt_path_join(compile_time_pdb_file_path + "${pdb_dir}" "${pdb_name}$<$:d>.pdb") + + qt_install(FILES "${compile_time_pdb_file_path}" + DESTINATION "${install_dir_path}" OPTIONAL) + endif() + endif() +endfunction() + +# Certain targets might have dependencies on libraries that don't have an Apple Silicon arm64 +# slice. When doing a universal macOS build, force those targets to be built only for the +# Intel x86_64 arch. +# This behavior can be disabled for all targets by setting the QT_FORCE_MACOS_ALL_ARCHES cache +# variable to TRUE or by setting the target specific cache variable +# QT_FORCE_MACOS_ALL_ARCHES_${target} to TRUE. +# +# TODO: Ideally we'd use something like _apple_resolve_supported_archs_for_sdk_from_system_lib +# from CMake's codebase to parse which architectures are available in a library, but it's +# not straightforward to extract the library absolute file path from a CMake target. Furthermore +# Apple started using a built-in dynamic linker cache of all system-provided libraries as per +# https://gitlab.kitware.com/cmake/cmake/-/issues/20863 +# so if the target is a library in the dynamic cache, that might further complicate how to get +# the list of arches in it. +function(qt_internal_force_macos_intel_arch target) + if(MACOS AND QT_IS_MACOS_UNIVERSAL AND NOT QT_FORCE_MACOS_ALL_ARCHES + AND NOT QT_FORCE_MACOS_ALL_ARCHES_${target}) + set(arches "x86_64") + set_target_properties(${target} PROPERTIES OSX_ARCHITECTURES "${arches}") + endif() +endfunction() + +function(qt_disable_apple_app_extension_api_only target) + set_target_properties("${target}" PROPERTIES QT_NO_APP_EXTENSION_ONLY_API TRUE) +endfunction() + +# Common function to add Qt prefixes to the target name +function(qt_internal_qtfy_target out_var target) + set(${out_var} "Qt${target}" PARENT_SCOPE) + set(${out_var}_versioned "Qt${PROJECT_VERSION_MAJOR}${target}" PARENT_SCOPE) +endfunction() + +function(qt_internal_get_main_cmake_configuration out_var) + if(CMAKE_BUILD_TYPE) + set(config "${CMAKE_BUILD_TYPE}") + elseif(QT_MULTI_CONFIG_FIRST_CONFIG) + set(config "${QT_MULTI_CONFIG_FIRST_CONFIG}") + endif() + set("${out_var}" "${config}" PARENT_SCOPE) +endfunction() + +function(qt_internal_get_upper_case_main_cmake_configuration out_var) + qt_internal_get_main_cmake_configuration("${out_var}") + string(TOUPPER "${${out_var}}" upper_config) + set("${out_var}" "${upper_config}" PARENT_SCOPE) +endfunction() + +function(qt_internal_adjust_main_config_runtime_output_dir target output_dir) + # When building Qt with multiple configurations, place the main configuration executable + # directly in ${output_dir}, rather than a ${output_dir}/ subdirectory. + qt_internal_get_upper_case_main_cmake_configuration(main_cmake_configuration) + set_target_properties("${target}" PROPERTIES + RUNTIME_OUTPUT_DIRECTORY_${main_cmake_configuration} "${output_dir}" + ) +endfunction() + +# Marks a target with a property that it is a library (shared or static) which was built using the +# internal Qt API (qt_internal_add_module, qt_internal_add_plugin, etc) as opposed to it being +# a user project library (qt_add_library, qt_add_plugin, etc). +# +# Needed to allow selectively applying certain flags via PlatformXInternal targets. +function(qt_internal_mark_as_internal_library target) + set_target_properties(${target} PROPERTIES _qt_is_internal_library TRUE) + set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES "_qt_is_internal_library") + qt_internal_mark_as_internal_target(${target}) +endfunction() + +# Marks a target with a property that it was built using the internal Qt API (qt_internal_*) as +# opposed to it being a user project library or executable(qt_add_*, etc). +# +# Needed to allow selectively applying certain flags via PlatformXInternal targets. +function(qt_internal_mark_as_internal_target target) + set_target_properties(${target} PROPERTIES _qt_is_internal_target TRUE) + set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES "_qt_is_internal_target") +endfunction() + +# Marks a target with a property to skip it adding it as a dependency when building examples as +# ExternalProjects. +# Needed to create a ${repo}_src global target that examples can depend on in multi-config builds +# due to a bug in AUTOUIC. +# +# See QTBUG-110369. +function(qt_internal_skip_dependency_for_examples target) + set_target_properties(${target} PROPERTIES _qt_skip_dependency_for_examples TRUE) +endfunction() + +function(qt_internal_is_target_skipped_for_examples target out_var) + get_property(is_skipped TARGET ${target} PROPERTY _qt_skip_dependency_for_examples) + if(NOT is_skipped) + set(is_skipped FALSE) + endif() + set(${out_var} "${is_skipped}" PARENT_SCOPE) +endfunction() + +function(qt_internal_link_internal_platform_for_object_library target) + # We need to apply iOS bitcode flags to object libraries that are associated with internal + # modules or plugins (e.g. object libraries added by qt_internal_add_resource, + # qt_internal_add_plugin, etc.) + # The flags are needed when building iOS apps because Xcode expects bitcode to be + # present by default. + # Achieve this by compiling the cpp files with the PlatformModuleInternal compile flags. + target_link_libraries("${target}" PRIVATE Qt::PlatformModuleInternal) +endfunction() + +# Use ${dep_target}'s include dirs when building ${target}. +# +# Assumes ${dep_target} is an INTERFACE_LIBRARY that only propagates include dirs and ${target} +# is a Qt module / plugin. +# +# Building ${target} requires ${dep_target}'s include dirs. +# Using ${target} does not require ${dep_target}'s include dirs. +# +# The main use case is adding the private header-only dependency PkgConfig::ATSPI2. +function(qt_internal_add_target_include_dirs target dep_target) + if(NOT TARGET "${target}") + message(FATAL_ERROR "${target} is not a valid target.") + endif() + if(NOT TARGET "${dep_target}") + message(FATAL_ERROR "${dep_target} is not a valid target.") + endif() + + target_include_directories("${target}" PRIVATE + "$") +endfunction() + +# Use ${dep_target}'s include dirs when building ${target} and optionally propagate the include +# dirs to consumers of ${target}. + +# Assumes ${dep_target} is an INTERFACE_LIBRARY that only propagates include dirs and ${target} +# is a Qt module / plugin. +# +# Building ${target} requires ${dep_target}'s include dirs. +# +# User projects that don't have ${dep_target}'s headers installed in their system should still +# configure successfully. +# +# To achieve that, consumers of ${target} will only get the include directories of ${dep_target} +# if the latter package and target exists. +# +# A find_package(dep_target) dependency is added to ${target}'s *Dependencies.cmake file. +# +# We use target_include_directories(PRIVATE) instead of target_link_libraries(PRIVATE) because the +# latter would propagate a mandatory LINK_ONLY dependency on the ${dep_target} in a static Qt build. +# +# The main use case is for propagating WrapVulkanHeaders::WrapVulkanHeaders. +function(qt_internal_add_target_include_dirs_and_optionally_propagate target dep_target) + qt_internal_add_target_include_dirs(${target} ${dep_target}) + + target_link_libraries("${target}" INTERFACE "$") + + qt_record_extra_third_party_dependency("${target}" "${dep_target}") +endfunction() + +# The function disables one or multiple internal global definitions that are defined by the +# qt_internal_add_global_definition function for a specific 'target'. +function(qt_internal_undefine_global_definition target) + if(NOT TARGET "${target}") + message(FATAL_ERROR "${target} is not a target.") + endif() + qt_internal_is_skipped_test(skipped ${target}) + if(skipped) + return() + endif() + qt_internal_is_in_test_batch(in_batch ${target}) + if(in_batch) + _qt_internal_test_batch_target_name(target) + endif() + + if("${ARGN}" STREQUAL "") + message(FATAL_ERROR "The function expects at least one definition as an argument.") + endif() + + foreach(definition IN LISTS ARGN) + set(undef_property_name "QT_INTERNAL_UNDEF_${definition}") + set_target_properties(${target} PROPERTIES "${undef_property_name}" TRUE) + endforeach() +endfunction() + +# This function adds any defines which are local to the current repository (e.g. qtbase, +# qtmultimedia). Those can be defined in the corresponding .cmake.conf file via +# QT_EXTRA_INTERNAL_TARGET_DEFINES. QT_EXTRA_INTERNAL_TARGET_DEFINES accepts a list of definitions. +# The definitions are passed to target_compile_definitions, which means that values can be provided +# via the FOO=Bar syntax +# This does nothing for interface targets +function(qt_internal_add_repo_local_defines target) + get_target_property(type "${target}" TYPE) + if (${type} STREQUAL "INTERFACE_LIBRARY") + return() + endif() + if(DEFINED QT_EXTRA_INTERNAL_TARGET_DEFINES) + target_compile_definitions("${target}" PRIVATE ${QT_EXTRA_INTERNAL_TARGET_DEFINES}) + endif() +endfunction() + +# The function returns the value of the target's SOURCES property. The function takes into account +# the limitation of the CMake version less than 3.19, that restricts to add non-interface sources +# to an interface target. +# Note: The function works correctly only if qt_internal_extend_target is used when adding source +# files. +function(qt_internal_get_target_sources out_var target) + qt_internal_get_target_sources_property(sources_property) + get_target_property(${out_var} ${target} ${sources_property}) + set(${out_var} "${${out_var}}" PARENT_SCOPE) +endfunction() + +# The function distinguishes what property supposed to store target sources, based on target TYPE +# and the CMake version. +function(qt_internal_get_target_sources_property out_var) + set(${out_var} "SOURCES") + get_target_property(target_type ${target} TYPE) + if(CMAKE_VERSION VERSION_LESS "3.19" AND target_type STREQUAL "INTERFACE_LIBRARY") + set(${out_var} "_qt_internal_target_sources") + endif() + set(${out_var} "${${out_var}}" PARENT_SCOPE) +endfunction() + +# This function collects target properties that contain generator expressions and needs to be +# exported. This function is needed since the CMake EXPORT_PROPERTIES property doesn't support +# properties that contain generator expressions. +# Usage: qt_internal_add_genex_properties_export(target properties...) +function(qt_internal_add_genex_properties_export target) + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + + set(config_check_begin "") + set(config_check_end "") + if(is_multi_config) + list(GET CMAKE_CONFIGURATION_TYPES 0 first_config_type) + + # The genex snippet is evaluated to '$>>' in the generated cmake file. + # The check is only applicable to the 'main' configuration. If user project doesn't use + # multi-config generator, then the check supposed to return true and the value from the + # 'main' configuration supposed to be used. + string(JOIN "" check_if_config_empty + "$<1:$>" + "$" + "$" + ) + + # The genex snippet is evaluated to '$' in the generated cmake + # file and checks if the config that user uses matches the generated cmake file config. + string(JOIN "" check_user_config + "$<1:$>$" + ) + + # The genex snippet is evaluated to '$<$>:'Property content'> + # for non-main Qt configs and to + # $<$,$>>>:'Property content'> for the + # main Qt config. This guard is required to choose the correct value of the property for the + # user project according to the user config type. + # All genexes need to be escaped properly to protect them from evaluation by the + # file(GENERATE call in the qt_internal_export_genex_properties function. + string(JOIN "" config_check_begin + "$<1:$><" + "$<1:$>:$${check_if_config_empty}>" + "$:" + ) + set(config_check_end "$") + endif() + set(target_name "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + foreach(property IN LISTS ARGN) + set(target_property_genex "$") + # All properties that contain lists need to be protected of processing by JOIN genex calls. + # So this escapes the semicolons for these list. + set(target_property_list_escape + "$,\;>") + set(property_value + "\"${config_check_begin}${target_property_list_escape}${config_check_end}\"") + set_property(TARGET ${target} APPEND PROPERTY _qt_export_genex_properties_content + "${property} ${property_value}") + endforeach() +endfunction() + +# This function executes generator expressions for the properties that are added by the +# qt_internal_add_genex_properties_export function and sets the calculated values to the +# corresponding properties in the generated ExtraProperties.cmake file. The file then needs to be +# included after the target creation routines in Config.cmake files. It also supports Multi-Config +# builds. +# Arguments: +# EXPORT_NAME_PREFIX: +# The portion of the file name before ExtraProperties.cmake +# CONFIG_INSTALL_DIR: +# Installation location for the file. +# TARGETS: +# The internal target names. +function(qt_internal_export_genex_properties) + set(option_args "") + set(single_args + EXPORT_NAME_PREFIX + CONFIG_INSTALL_DIR + ) + set(multi_args TARGETS) + cmake_parse_arguments(arg "${option_args}" "${single_args}" "${multi_args}" ${ARGN}) + + if(NOT arg_EXPORT_NAME_PREFIX) + message(FATAL_ERROR "qt_internal_export_genex_properties: " + "Missing EXPORT_NAME_PREFIX argument.") + endif() + + if(NOT arg_TARGETS) + message(FATAL_ERROR "qt_internal_export_genex_properties: " + "TARGETS argument must contain at least one target") + endif() + + foreach(target IN LISTS arg_TARGETS) + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + + set(output_file_base_name "${arg_EXPORT_NAME_PREFIX}ExtraProperties") + set(should_append "") + set(config_suffix "") + if(is_multi_config) + list(GET CMAKE_CONFIGURATION_TYPES 0 first_config_type) + set(config_suffix "$<$>:-$>") + # If the generated file belongs to the 'main' config type, we should set property + # but not append it. + string(JOIN "" should_append + "$<$>: APPEND>") + endif() + set(file_name "${output_file_base_name}${config_suffix}.cmake") + + qt_path_join(output_file "${arg_CONFIG_INSTALL_DIR}" + "${file_name}") + + if(NOT IS_ABSOLUTE "${output_file}") + qt_path_join(output_file "${QT_BUILD_DIR}" "${output_file}") + endif() + + set(target_name "${QT_CMAKE_EXPORT_NAMESPACE}::${target}") + + string(JOIN "" set_property_begin "set_property(TARGET " + "${target_name}${should_append} PROPERTY " + ) + set(set_property_end ")") + set(set_property_glue "${set_property_end}\n${set_property_begin}") + set(property_list + "$>") + string(JOIN "" set_property_content "${set_property_begin}" + "$" + "${set_property_end}") + + if(is_multi_config) + set(config_includes "") + foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES) + if(NOT first_config_type STREQUAL config) + set(include_file_name + "${output_file_base_name}-${config}.cmake") + list(APPEND config_includes + "include(\"\${CMAKE_CURRENT_LIST_DIR}/${include_file_name}\")") + endif() + endforeach() + list(JOIN config_includes "\n" config_includes_string) + set(config_includes_string + "\n$<$:${config_includes_string}>") + endif() + + file(GENERATE OUTPUT "${output_file}" + CONTENT "$<$:${set_property_content}${config_includes_string}>" + CONDITION "$" + ) + endforeach() + + qt_install(FILES "$<$:${output_file}>" + DESTINATION "${arg_CONFIG_INSTALL_DIR}" + COMPONENT Devel + ) +endfunction() + +# A small wrapper for adding the Platform target, and a building block for the PlatformXInternal +# and GlobalConfig INTERFACE targets to apply common options. +function(qt_internal_add_platform_target target) + _qt_internal_add_library("${target}" INTERFACE) + qt_internal_add_target_aliases("${target}") + + # The platform targets should never be promoted to global via the + # _qt_internal_promote_3rd_party_target_to_global command. + set_property(TARGET "${target}" PROPERTY _qt_should_skip_3rd_party_global_promotion TRUE) + set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES + "_qt_should_skip_3rd_party_global_promotion") +endfunction() + +# A small wrapper for adding the PlatformXInternal and GlobalConfig INTERFACE targets to apply +# common options. +# They can't be added via qt_internal_add_module, because it automatically links to the +# PlatformInternal targets creating a cyclic dependency. +function(qt_internal_add_platform_internal_target target) + qt_internal_add_platform_target("${target}") + qt_internal_mark_as_internal_library("${target}") + + qt_internal_add_sbom("${target}" + TYPE QT_MODULE + IMMEDIATE_FINALIZATION + ) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtTestHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtTestHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c31ce8f7ac0c19b7346b617d125ca9f67885e980 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtTestHelpers.cmake @@ -0,0 +1,1130 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Simple wrapper around qt_internal_add_executable for benchmarks which insure that +# the binary is built under ${CMAKE_CURRENT_BINARY_DIR} and never installed. +# See qt_internal_add_executable() for more details. +function(qt_internal_add_benchmark target) + if(QT_BUILD_TESTS_BATCHED) + message(WARNING "Benchmarks won't be batched - unsupported (yet)") + endif() + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${__qt_internal_add_executable_optional_args}" + "${__qt_internal_add_executable_single_args}" + "${__qt_internal_add_executable_multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + _qt_internal_validate_no_unity_build(arg) + + qt_remove_args(exec_args + ARGS_TO_REMOVE + ${target} + OUTPUT_DIRECTORY + INSTALL_DIRECTORY + ALL_ARGS + "${__qt_internal_add_executable_optional_args}" + "${__qt_internal_add_executable_single_args}" + "${__qt_internal_add_executable_multi_args}" + ARGS + ${ARGV} + ) + + if(NOT arg_OUTPUT_DIRECTORY) + if(CMAKE_RUNTIME_OUTPUT_DIRECTORY) + set(arg_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}") + else() + set(arg_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") + endif() + endif() + + qt_internal_add_executable(${target} + NO_INSTALL # we don't install benchmarks + NO_UNITY_BUILD # excluded by default + OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}" # avoid polluting bin directory + ${exec_args} + ) + qt_internal_extend_target(${target} + DEFINES + ${deprecation_define} + ) + + # Benchmarks on iOS must be app bundles. + if(IOS) + set_target_properties(${target} PROPERTIES MACOSX_BUNDLE TRUE) + endif() + + qt_internal_add_repo_local_defines(${target}) + + # Disable the QT_NO_NARROWING_CONVERSIONS_IN_CONNECT define for benchmarks + qt_internal_undefine_global_definition(${target} QT_NO_NARROWING_CONVERSIONS_IN_CONNECT) + + qt_internal_collect_command_environment(benchmark_env_path benchmark_env_plugin_path) + + # Add a ${target}_benchmark generator target, to run single benchmark more easily. + set(benchmark_wrapper_file "${arg_OUTPUT_DIRECTORY}/${target}Wrapper$.cmake") + _qt_internal_create_command_script(COMMAND "$" + OUTPUT_FILE "${benchmark_wrapper_file}" + ENVIRONMENT "PATH" "${benchmark_env_path}" + "QT_PLUGIN_PATH" "${benchmark_env_plugin_path}" + ) + + add_custom_target("${target}_benchmark" + VERBATIM + COMMENT "Running benchmark ${target}" + COMMAND "${CMAKE_COMMAND}" "-P" "${benchmark_wrapper_file}" + ) + + add_dependencies("${target}_benchmark" "${target}") + + # Add benchmark to meta target if it exists. + if (TARGET benchmark) + add_dependencies("benchmark" "${target}_benchmark") + endif() + + qt_internal_add_test_finalizers("${target}") +endfunction() + +function(qt_internal_add_test_dependencies target) + if(QT_BUILD_TESTS_BATCHED) + _qt_internal_test_batch_target_name(target) + endif() + add_dependencies(${target} ${ARGN}) +endfunction() + +# Simple wrapper around qt_internal_add_executable for manual tests which insure that +# the binary is built under ${CMAKE_CURRENT_BINARY_DIR} and never installed. +# See qt_internal_add_executable() for more details. +function(qt_internal_add_manual_test target) + qt_internal_add_test(${ARGV} MANUAL) +endfunction() + +# This function will configure the fixture for the network tests that require docker network services +# qmake counterpart: qtbase/mkspecs/features/unsupported/testserver.prf +function(qt_internal_setup_docker_test_fixture name) + # Only Linux is provisioned with docker at this time + if (NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux") + return() + endif() + + option(QT_SKIP_DOCKER_COMPOSE "Skip setting up docker on Linux." OFF) + if(QT_SKIP_DOCKER_COMPOSE) + return() + endif() + + set(QT_TEST_SERVER_LIST ${ARGN}) + set(DNSDOMAIN test-net.qt.local) + + find_program(QT_DOCKER_COMPOSE docker-compose) + if (NOT QT_DOCKER_COMPOSE) + message(WARNING "docker-compose was not found. Docker network tests will not be run.") + return() + endif() + if (NOT DEFINED QT_DOCKER_COMPOSE_VERSION) + execute_process(COMMAND "${QT_DOCKER_COMPOSE}" --version OUTPUT_VARIABLE QT_DOCKER_COMPOSE_VERSION) + string(REPLACE "\n" "" QT_DOCKER_COMPOSE_VERSION "${QT_DOCKER_COMPOSE_VERSION}") + set(QT_DOCKER_COMPOSE_VERSION "${QT_DOCKER_COMPOSE_VERSION}" CACHE STRING "docker compose version") + endif() + + find_program(QT_DOCKER docker) + if (NOT QT_DOCKER) + message(WARNING "docker was not found. Docker network tests will not be run.") + return() + endif() + if (NOT DEFINED QT_DOCKER_TEST_SERVER) + execute_process(COMMAND "${QT_DOCKER}" images -aq "qt-test-server-*" OUTPUT_VARIABLE QT_DOCKER_TEST_SERVER) + if (NOT QT_DOCKER_TEST_SERVER) + message(WARNING + "Docker image qt-test-server-* not found.\n" + "Run the provisioning script (coin/provisioning/.../testserver/docker_testserver.sh) in advance\n" + "Docker network tests will not be run.") + return() + endif() + set(QT_DOCKER_TEST_SERVER "ON" CACHE BOOL "docker qt-test-server-* present") + endif() + + target_compile_definitions("${name}" + PRIVATE + QT_TEST_SERVER QT_TEST_SERVER_NAME QT_TEST_SERVER_DOMAIN=\"${DNSDOMAIN}\" + ) + + if(DEFINED QT_TESTSERVER_COMPOSE_FILE) + set(TESTSERVER_COMPOSE_FILE ${QT_TESTSERVER_COMPOSE_FILE}) + elseif(QNX) + set(TESTSERVER_COMPOSE_FILE "${QT_SOURCE_TREE}/tests/testserver/docker-compose-qemu-bridge-network.yml") + else() + set(TESTSERVER_COMPOSE_FILE "${QT_SOURCE_TREE}/tests/testserver/docker-compose-bridge-network.yml") + endif() + + # Bring up test servers and make sure the services are ready. + add_test(NAME ${name}-setup COMMAND + "${QT_DOCKER_COMPOSE}" -f ${TESTSERVER_COMPOSE_FILE} up --build -d --force-recreate --timeout 1 ${QT_TEST_SERVER_LIST} + ) + # Stop and remove test servers after testing. + add_test(NAME ${name}-cleanup COMMAND + "${QT_DOCKER_COMPOSE}" -f ${TESTSERVER_COMPOSE_FILE} down --timeout 1 + ) + + set_tests_properties(${name}-setup PROPERTIES FIXTURES_SETUP ${name}-docker) + set_tests_properties(${name}-cleanup PROPERTIES FIXTURES_CLEANUP ${name}-docker) + set_tests_properties(${name} PROPERTIES FIXTURES_REQUIRED ${name}-docker) + + foreach(test_name ${name} ${name}-setup ${name}-cleanup) + set_property(TEST "${test_name}" APPEND PROPERTY ENVIRONMENT "testserver=${QT_DOCKER_COMPOSE_VERSION}") + set_property(TEST "${test_name}" APPEND PROPERTY ENVIRONMENT TEST_DOMAIN=${DNSDOMAIN}) + set_property(TEST "${test_name}" APPEND PROPERTY ENVIRONMENT "SHARED_DATA=${QT_MKSPECS_DIR}/features/data/testserver") + set_property(TEST "${test_name}" APPEND PROPERTY ENVIRONMENT SHARED_SERVICE=bridge-network) + endforeach() + +endfunction() + +function(qt_internal_get_test_batch out) + get_property(batched_list GLOBAL PROPERTY _qt_batched_test_list_property) + set(${out} ${batched_list} PARENT_SCOPE) +endfunction() + +function(qt_internal_prepare_test_target_flags version_arg exceptions_text gui_text) + cmake_parse_arguments(arg "EXCEPTIONS;NO_EXCEPTIONS;GUI" "VERSION" "" ${ARGN}) + + if (arg_VERSION) + set(${version_arg} VERSION "${arg_VERSION}" PARENT_SCOPE) + endif() + + # Qt modules get compiled without exceptions enabled by default. + # However, testcases should be still built with exceptions. + set(${exceptions_text} "EXCEPTIONS" PARENT_SCOPE) + if (${arg_NO_EXCEPTIONS} OR WASM) + set(${exceptions_text} "" PARENT_SCOPE) + endif() + + if (${arg_GUI}) + set(${gui_text} "GUI" PARENT_SCOPE) + endif() +endfunction() + +function(qt_internal_get_test_arg_definitions optional_args single_value_args multi_value_args) + set(${optional_args} + RUN_SERIAL + EXCEPTIONS + NO_EXCEPTIONS + GUI + QMLTEST + CATCH + LOWDPI + NO_WRAPPER + BUILTIN_TESTDATA + MANUAL + NO_BATCH + NO_INSTALL + BUNDLE_ANDROID_OPENSSL_LIBS + PARENT_SCOPE + ) + set(${single_value_args} + OUTPUT_DIRECTORY + WORKING_DIRECTORY + TIMEOUT + VERSION + PARENT_SCOPE + ) + set(${multi_value_args} + QML_IMPORTPATH + TESTDATA + QT_TEST_SERVER_LIST + ${__default_private_args} + ${__default_public_args} + PARENT_SCOPE + ) +endfunction() + +function(qt_internal_add_test_to_batch batch_name name) + qt_internal_get_test_arg_definitions(optional_args single_value_args multi_value_args) + + cmake_parse_arguments( + arg "${optional_args}" "${single_value_args}" "${multi_value_args}" ${ARGN}) + qt_internal_prepare_test_target_flags(version_arg exceptions_text gui_text ${ARGN}) + + _qt_internal_validate_no_unity_build(arg) + + _qt_internal_test_batch_target_name(target) + + # Lazy-init the test batch + if(NOT TARGET ${target}) + if(${arg_MANUAL}) + set(is_manual "QT_MANUAL_TEST") + else() + set(is_manual "") + endif() + + qt_internal_add_executable(${target} + ${exceptions_text} + ${gui_text} + ${version_arg} + NO_INSTALL + QT_TEST + ${is_manual} + OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/build_dir" + SOURCES "${QT_CMAKE_DIR}/qbatchedtestrunner.in.cpp" + DEFINES QTEST_BATCH_TESTS ${deprecation_define} + INCLUDE_DIRECTORIES ${private_includes} + LIBRARIES ${QT_CMAKE_EXPORT_NAMESPACE}::Core + ${QT_CMAKE_EXPORT_NAMESPACE}::Test + ${QT_CMAKE_EXPORT_NAMESPACE}::TestPrivate + # Add GUI by default so that the plugins link properly with non-standalone + # build of tests. Plugin handling is currently only done in + # qt_internal_add_executable if Gui is present. This should be reevaluated with + # multiple batches. + ${QT_CMAKE_EXPORT_NAMESPACE}::Gui + ) + + set_property(TARGET ${target} PROPERTY _qt_has_exceptions ${arg_EXCEPTIONS}) + set_property(TARGET ${target} PROPERTY _qt_has_gui ${arg_GUI}) + set_property(TARGET ${target} PROPERTY _qt_has_lowdpi ${arg_LOWDPI}) + set_property(TARGET ${target} PROPERTY _qt_version ${version_arg}) + else() + # Check whether the args match with the batch. Some differences between + # flags cannot be reconciled - one should not combine these tests into + # a single binary. + qt_internal_get_target_property( + batch_has_exceptions ${target} _qt_has_exceptions) + if(NOT ${batch_has_exceptions} STREQUAL ${arg_EXCEPTIONS}) + qt_internal_get_test_batch(test_batch_contents) + message(FATAL_ERROR "Conflicting exceptions declaration between test \ + batch (${test_batch_contents}) and ${name}") + endif() + qt_internal_get_target_property(batch_has_gui ${target} _qt_has_gui) + if(NOT ${batch_has_gui} STREQUAL ${arg_GUI}) + qt_internal_get_test_batch(test_batch_contents) + message(FATAL_ERROR "Conflicting gui declaration between test batch \ + (${test_batch_contents}) and ${name}") + endif() + qt_internal_get_target_property( + batch_has_lowdpi ${target} _qt_has_lowdpi) + if(NOT ${batch_has_lowdpi} STREQUAL ${arg_LOWDPI}) + qt_internal_get_test_batch(test_batch_contents) + message(FATAL_ERROR "Conflicting lowdpi declaration between test batch \ + (${test_batch_contents}) and ${name}") + endif() + qt_internal_get_target_property(batch_version ${target} _qt_version) + if(NOT "${batch_version} " STREQUAL " " AND + NOT "${version_arg} " STREQUAL " " AND + NOT "${batch_version} " STREQUAL "${version_arg} ") + qt_internal_get_test_batch(test_batch_contents) + message(FATAL_ERROR "Conflicting version declaration between test \ + batch ${test_batch_contents} (${batch_version}) and ${name} (${version_arg})") + endif() + endif() + + get_property(batched_test_list GLOBAL PROPERTY _qt_batched_test_list_property) + if(NOT batched_test_list) + set_property(GLOBAL PROPERTY _qt_batched_test_list_property "") + set(batched_test_list "") + endif() + list(PREPEND batched_test_list ${name}) + set_property(GLOBAL PROPERTY _qt_batched_test_list_property ${batched_test_list}) + + # Test batching produces single executable which can result in one source file being added + # multiple times (with different definitions) to one translation unit. This is not supported by + # CMake so instead we try to detect such situation and rename file every time it's added + # to the build more than once. This avoids filenames collisions in one translation unit. + get_property(batched_test_sources_list GLOBAL PROPERTY _qt_batched_test_sources_list_property) + if(NOT batched_test_sources_list) + set_property(GLOBAL PROPERTY _qt_batched_test_sources_list_property "") + set(batched_test_sources_list "") + endif() + foreach(source ${arg_SOURCES}) + set(source_path ${source}) + if(${source} IN_LIST batched_test_sources_list) + set(new_filename ${name}.cpp) + configure_file(${source} ${new_filename}) + set(source_path ${CMAKE_CURRENT_BINARY_DIR}/${new_filename}) + set(skip_automoc ON) + list(APPEND arg_SOURCES ${source_path}) + else() + set(skip_automoc OFF) + list(APPEND batched_test_sources_list ${source}) + endif() + set_source_files_properties(${source_path} + TARGET_DIRECTORY ${target} PROPERTIES + SKIP_AUTOMOC ${skip_automoc} + COMPILE_DEFINITIONS "BATCHED_TEST_NAME=\"${name}\";${arg_DEFINES}") + endforeach() + set_property(GLOBAL PROPERTY _qt_batched_test_sources_list_property ${batched_test_sources_list}) + + # Merge the current test with the rest of the batch + qt_internal_extend_target(${target} + INCLUDE_DIRECTORIES ${arg_INCLUDE_DIRECTORIES} + PUBLIC_LIBRARIES ${arg_PUBLIC_LIBRARIES} + LIBRARIES ${arg_LIBRARIES} + SOURCES ${arg_SOURCES} + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + COMPILE_FLAGS ${arg_COMPILE_FLAGS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS} + NO_UNITY_BUILD # Tests should not be built using UNITY_BUILD + ) + + set(${batch_name} ${target} PARENT_SCOPE) + + # Add a dummy target so that new tests don't have problems with a nonexistent + # target when calling cmake functions. + # The batch tests that include this target will compile, but may fail to work. + # Manual action is required then. + add_custom_target(${name}) + + # Add the dependency to the dummy target so that it is indirectly added to the test batch + # dependencies. + add_dependencies(${target} ${name}) +endfunction() + +# Checks whether the test 'name' is present in the test batch. See QT_BUILD_TESTS_BATCHED. +# The result of the check is placed in the 'out' variable. +function(qt_internal_is_in_test_batch out name) + set(${out} FALSE PARENT_SCOPE) + if(QT_BUILD_TESTS_BATCHED) + get_property(batched_test_list GLOBAL PROPERTY _qt_batched_test_list_property) + if("${name}" IN_LIST batched_test_list) + set(${out} TRUE PARENT_SCOPE) + endif() + endif() +endfunction() + +function(qt_internal_is_skipped_test out name) + get_target_property(is_skipped_test ${name} _qt_is_skipped_test) + set(${out} ${is_skipped_test} PARENT_SCOPE) +endfunction() + +function(qt_internal_set_skipped_test name) + set_target_properties(${name} PROPERTIES _qt_is_skipped_test TRUE) +endfunction() + +function(qt_internal_is_qtbase_test out) + get_filename_component(dir "${CMAKE_CURRENT_BINARY_DIR}" ABSOLUTE) + set(${out} FALSE PARENT_SCOPE) + + while(TRUE) + get_filename_component(filename "${dir}" NAME) + if("${filename}" STREQUAL "qtbase") + set(${out} TRUE PARENT_SCOPE) + break() + endif() + + set(prev_dir "${dir}") + get_filename_component(dir "${dir}" DIRECTORY) + if("${dir}" STREQUAL "${prev_dir}") + break() + endif() + endwhile() +endfunction() + +function(qt_internal_get_batched_test_arguments out testname) + if(WASM) + # Add a query string to the runner document, so that the script therein + # knows which test to run in response to launching the testcase by ctest. + list(APPEND args "qbatchedtest") + if(CMAKE_BUILD_TYPE STREQUAL "Debug") + list(APPEND args "qvisualoutput") + endif() + else() + # Simply add the test name in case of standard executables. + list(APPEND args "${testname}") + endif() + set(${out} ${args} PARENT_SCOPE) +endfunction() + +# This function creates a CMake test target with the specified name for use with CTest. +# +# All tests are wrapped with cmake script that supports TESTARGS and TESTRUNNER environment +# variables handling. Endpoint wrapper may be used standalone as cmake script to run tests e.g.: +# TESTARGS="-o result.xml,junitxml" TESTRUNNER="testrunner --arg" ./tst_simpleTestWrapper.cmake +# On non-UNIX machine you may need to use 'cmake -P' explicitly to execute wrapper. +# You may avoid test wrapping by either passing NO_WRAPPER option or switching QT_NO_TEST_WRAPPERS +# to ON. This is helpful if you want to use internal CMake tools within tests, like memory or +# sanitizer checks. See https://cmake.org/cmake/help/v3.19/manual/ctest.1.html#ctest-memcheck-step +# Arguments: +# BUILTIN_TESTDATA +# The option forces adding the provided TESTDATA to resources. +# MANUAL +# The option indicates that the test is a manual test. +function(qt_internal_add_test name) + qt_internal_get_test_arg_definitions(optional_args single_value_args multi_value_args) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${optional_args}" + "${single_value_args}" + "${multi_value_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + _qt_internal_validate_no_unity_build(arg) + + set(batch_current_test FALSE) + if(QT_BUILD_TESTS_BATCHED AND NOT arg_NO_BATCH AND NOT arg_QMLTEST AND NOT arg_MANUAL + AND ("${QT_STANDALONE_TEST_PATH}" STREQUAL "" + OR DEFINED ENV{QT_BATCH_STANDALONE_TESTS})) + set(batch_current_test TRUE) + endif() + + if(batch_current_test OR (QT_BUILD_TESTS_BATCHED AND arg_QMLTEST)) + if (QT_SUPERBUILD OR DEFINED ENV{TESTED_MODULE_COIN}) + set(is_qtbase_test FALSE) + if(QT_SUPERBUILD) + qt_internal_is_qtbase_test(is_qtbase_test) + elseif($ENV{TESTED_MODULE_COIN} STREQUAL "qtbase") + set(is_qtbase_test TRUE) + endif() + if(NOT is_qtbase_test) + file(GENERATE OUTPUT "dummy${name}.cpp" CONTENT "int main() { return 0; }") + # Add a dummy target to tackle some potential problems + qt_internal_add_executable(${name} SOURCES "dummy${name}.cpp") + # Batched tests outside of qtbase are unsupported and skipped + qt_internal_set_skipped_test(${name}) + return() + endif() + endif() + endif() + + if(NOT arg_OUTPUT_DIRECTORY) + if(CMAKE_RUNTIME_OUTPUT_DIRECTORY) + set(arg_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}") + else() + set(arg_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") + endif() + endif() + + set(private_includes + "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_BINARY_DIR}" + "$" + ) + + set(testname "${name}") + + if(arg_PUBLIC_LIBRARIES) + message(WARNING + "qt_internal_add_test's PUBLIC_LIBRARIES option is deprecated, and will be " + "removed in a future Qt version. Use the LIBRARIES option instead.") + endif() + + if(batch_current_test) + qt_internal_add_test_to_batch(name ${name} ${ARGN}) + elseif(arg_SOURCES) + if(QT_BUILD_TESTS_BATCHED AND arg_QMLTEST) + message(WARNING "QML tests won't be batched - unsupported (yet)") + endif() + # Handle cases where we have a qml test without source files + list(APPEND private_includes ${arg_INCLUDE_DIRECTORIES}) + + qt_internal_prepare_test_target_flags(version_arg exceptions_text gui_text ${ARGN}) + + if(${arg_MANUAL}) + set(is_manual "QT_MANUAL_TEST") + else() + set(is_manual "") + endif() + + qt_internal_add_executable("${name}" + ${exceptions_text} + ${gui_text} + ${version_arg} + NO_INSTALL + QT_TEST + ${is_manual} + OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}" + SOURCES "${arg_SOURCES}" + INCLUDE_DIRECTORIES + ${private_includes} + DEFINES + ${arg_DEFINES} + ${deprecation_define} + LIBRARIES + ${arg_LIBRARIES} + ${arg_PUBLIC_LIBRARIES} + ${QT_CMAKE_EXPORT_NAMESPACE}::Core + ${QT_CMAKE_EXPORT_NAMESPACE}::Test + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS} + DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS} + NO_UNITY_BUILD # Tests should not be built using UNITY_BUILD + ) + + qt_internal_add_repo_local_defines(${name}) + + # Disable the QT_NO_NARROWING_CONVERSIONS_IN_CONNECT define for tests + qt_internal_undefine_global_definition(${name} QT_NO_NARROWING_CONVERSIONS_IN_CONNECT) + + # Manual tests can be bundle apps + if(NOT arg_MANUAL) + # Tests should not be bundles on macOS even if arg_GUI is true, because some tests make + # assumptions about the location of helper processes, and those paths would be different + # if a test is built as a bundle. + set_property(TARGET "${name}" PROPERTY MACOSX_BUNDLE FALSE) + # The same goes for WIN32_EXECUTABLE, but because it will detach from the console window + # and not print anything. + set_property(TARGET "${name}" PROPERTY WIN32_EXECUTABLE FALSE) + endif() + + # Tests on iOS must be app bundles. + if(IOS) + set_target_properties(${name} PROPERTIES MACOSX_BUNDLE TRUE) + endif() + + # QMLTest specifics + qt_internal_extend_target("${name}" CONDITION arg_QMLTEST + LIBRARIES ${QT_CMAKE_EXPORT_NAMESPACE}::QuickTest + ) + + qt_internal_extend_target("${name}" + CONDITION arg_QMLTEST AND NOT ANDROID AND NOT QT_FORCE_BUILTIN_TESTDATA + DEFINES + QUICK_TEST_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}" + ) + + qt_internal_extend_target("${name}" + CONDITION arg_QMLTEST AND (ANDROID OR QT_FORCE_BUILTIN_TESTDATA) + DEFINES + QUICK_TEST_SOURCE_DIR=":/" + ) + + # Android requires Qt::Gui so add it by default for tests + qt_internal_extend_target("${name}" CONDITION ANDROID + LIBRARIES ${QT_CMAKE_EXPORT_NAMESPACE}::Gui + ) + + set(blacklist_file "${CMAKE_CURRENT_SOURCE_DIR}/BLACKLIST") + if(EXISTS ${blacklist_file}) + _qt_internal_expose_source_file_to_ide("${name}" ${blacklist_file}) + endif() + endif() + + foreach(path IN LISTS arg_QML_IMPORTPATH) + list(APPEND extra_test_args "-import" "${path}") + endforeach() + + # Generate a label in the form tests/auto/foo/bar/tst_baz + # and use it also for XML output + set(label_base_directory "${PROJECT_SOURCE_DIR}") + if (QT_SUPERBUILD) + # Prepend repository name for qt5 builds, so that tests can be run for + # individual repositories. + set(label_base_directory "${label_base_directory}/..") + endif() + file(RELATIVE_PATH label "${label_base_directory}" "${CMAKE_CURRENT_SOURCE_DIR}/${name}") + + if (arg_LOWDPI) + target_compile_definitions("${name}" PUBLIC TESTCASE_LOWDPI) + if (MACOS) + set_property(TARGET "${name}" PROPERTY MACOSX_BUNDLE_INFO_PLIST "${QT_MKSPECS_DIR}/macx-clang/Info.plist.disable_highdpi") + set_property(TARGET "${name}" PROPERTY PROPERTY MACOSX_BUNDLE TRUE) + endif() + endif() + + if (ANDROID) + # Pass 95% of the timeout to allow the test runner time to do any cleanup + # before being killed. + set(percentage "95") + qt_internal_get_android_test_timeout("${arg_TIMEOUT}" "${percentage}" android_timeout) + + if(arg_BUNDLE_ANDROID_OPENSSL_LIBS) + if(EXISTS "${OPENSSL_ROOT_DIR}/${CMAKE_ANDROID_ARCH_ABI}/libcrypto_3.so") + message(STATUS "Looking for OpenSSL in ${OPENSSL_ROOT_DIR}") + set_property(TARGET ${name} APPEND PROPERTY QT_ANDROID_EXTRA_LIBS + "${OPENSSL_ROOT_DIR}/${CMAKE_ANDROID_ARCH_ABI}/libcrypto_3.so" + "${OPENSSL_ROOT_DIR}/${CMAKE_ANDROID_ARCH_ABI}/libssl_3.so") + elseif(QT_USE_VCPKG AND DEFINED ENV{VCPKG_ROOT}) + message(STATUS "Looking for OpenSSL in $ENV{VCPKG_ROOT}") + if (CMAKE_ANDROID_ARCH_ABI MATCHES "arm64-v8a") + set(coin_vcpkg_target_triplet "arm64-android-dynamic") + elseif(CMAKE_ANDROID_ARCH_ABI MATCHES "armeabi-v7a") + set(coin_vcpkg_target_triplet "arm-neon-android-dynamic") + elseif(CMAKE_ANDROID_ARCH_ABI MATCHES "x86_64") + set(coin_vcpkg_target_triplet "x64-android-dynamic") + elseif(CMAKE_ANDROID_ARCH_ABI MATCHES "x86") + set(coin_vcpkg_target_triplet "x86-android-dynamic") + endif() + if(EXISTS "$ENV{VCPKG_ROOT}/installed/${coin_vcpkg_target_triplet}/lib/libcrypto.so") + message(STATUS "Found OpenSSL in $ENV{VCPKG_ROOT}/installed/${coin_vcpkg_target_triplet}/lib") + set_property(TARGET ${name} APPEND PROPERTY QT_ANDROID_EXTRA_LIBS + "$ENV{VCPKG_ROOT}/installed/${coin_vcpkg_target_triplet}/lib/libcrypto.so" + "$ENV{VCPKG_ROOT}/installed/${coin_vcpkg_target_triplet}/lib/libssl.so") + endif() + else() + message(STATUS "The argument BUNDLE_ANDROID_OPENSSL_LIBS is set " + "but OPENSSL_ROOT_DIR parameter is not set. " + "Test should bundle OpenSSL libraries but they are not found. " + "This is fine if OpenSSL was built statically.") + endif() + endif() + qt_internal_android_test_runner_arguments("${name}" test_executable extra_test_args) + list(APPEND extra_test_args "--timeout" "${android_timeout}" "--verbose") + set(test_working_dir "${CMAKE_CURRENT_BINARY_DIR}") + elseif(QNX) + set(test_working_dir "") + set(test_executable "${name}") + elseif(WASM) + # The test script expects an html file. In case of batched tests, the + # version specialized for running batches has to be supplied. + if(batch_current_test) + get_target_property(batch_output_dir ${name} RUNTIME_OUTPUT_DIRECTORY) + set(test_executable "${batch_output_dir}/${name}.html") + else() + set(test_executable "${name}.html") + endif() + + list(APPEND extra_test_args "quseemrun") + list(APPEND extra_test_args "qtestname=${testname}") + list(APPEND extra_test_args "--silence_timeout=60") + # TODO: Add functionality to specify browser + list(APPEND extra_test_args "--browser=chrome") + list(APPEND extra_test_args "--browser_args=\"--password-store=basic\"") + list(APPEND extra_test_args "--kill_exit") + + # Tests may require asyncify if they use exec(). Enable asyncify for + # batched tests since this is the configuration used on the CI system. + # Optimize for size (-Os), since asyncify tends to make the resulting + # binary very large + if(batch_current_test) + target_link_options("${name}" PRIVATE "SHELL:-s ASYNCIFY" "-Os") + endif() + + # This tells cmake to run the tests with this script, since wasm files can't be + # executed directly + if (CMAKE_HOST_WIN32) + set_property(TARGET "${name}" PROPERTY CROSSCOMPILING_EMULATOR "emrun.bat") + else() + set_property(TARGET "${name}" PROPERTY CROSSCOMPILING_EMULATOR "emrun") + endif() + else() + if(arg_QMLTEST AND NOT arg_SOURCES) + set(test_working_dir "${CMAKE_CURRENT_SOURCE_DIR}") + set(test_executable ${QT_CMAKE_EXPORT_NAMESPACE}::qmltestrunner) + else() + if (arg_WORKING_DIRECTORY) + set(test_working_dir "${arg_WORKING_DIRECTORY}") + elseif(arg_OUTPUT_DIRECTORY) + set(test_working_dir "${arg_OUTPUT_DIRECTORY}") + else() + set(test_working_dir "${CMAKE_CURRENT_BINARY_DIR}") + endif() + set(test_executable "${name}") + endif() + endif() + + if(NOT arg_MANUAL) + if(batch_current_test) + qt_internal_get_batched_test_arguments(batched_test_args ${testname}) + list(PREPEND extra_test_args ${batched_test_args}) + elseif(WASM AND CMAKE_BUILD_TYPE STREQUAL "Debug") + list(PREPEND extra_test_args "qvisualoutput") + endif() + + qt_internal_collect_command_environment(test_env_path test_env_plugin_path) + + if(arg_NO_WRAPPER OR QT_NO_TEST_WRAPPERS) + if(QT_BUILD_TESTS_BATCHED) + message(FATAL_ERROR "Wrapperless tests are unspupported with test batching") + endif() + + add_test(NAME "${testname}" COMMAND ${test_executable} ${extra_test_args} + WORKING_DIRECTORY "${test_working_dir}") + set_property(TEST "${testname}" APPEND PROPERTY + ENVIRONMENT "PATH=${test_env_path}" + "QT_TEST_RUNNING_IN_CTEST=1" + "QT_PLUGIN_PATH=${test_env_plugin_path}" + ) + else() + set(test_wrapper_file "${CMAKE_CURRENT_BINARY_DIR}/${testname}Wrapper$.cmake") + qt_internal_create_test_script(NAME "${testname}" + COMMAND "${test_executable}" + ARGS "${extra_test_args}" + WORKING_DIRECTORY "${test_working_dir}" + OUTPUT_FILE "${test_wrapper_file}" + ENVIRONMENT "QT_TEST_RUNNING_IN_CTEST" 1 + "PATH" "${test_env_path}" + "QT_PLUGIN_PATH" "${test_env_plugin_path}" + ) + endif() + + if(arg_QT_TEST_SERVER_LIST AND NOT ANDROID) + qt_internal_setup_docker_test_fixture(${testname} ${arg_QT_TEST_SERVER_LIST}) + endif() + + set_tests_properties("${testname}" PROPERTIES RUN_SERIAL "${arg_RUN_SERIAL}" LABELS "${label}") + if(arg_TIMEOUT) + set_tests_properties(${testname} PROPERTIES TIMEOUT ${arg_TIMEOUT}) + endif() + + if(ANDROID AND NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") + # Set timeout signal and some time for androidtestrunner to do cleanup + set_tests_properties(${testname} PROPERTIES + TIMEOUT_SIGNAL_NAME "SIGINT" + TIMEOUT_SIGNAL_GRACE_PERIOD 10.0 + ) + endif() + + # Add a ${target}/check makefile target, to more easily test one test. + + set(test_config_options "") + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(test_config_options -C $) + endif() + add_custom_target("${testname}_check" + VERBATIM + COMMENT "Running ${CMAKE_CTEST_COMMAND} -V -R \"^${name}$\" ${test_config_options}" + COMMAND "${CMAKE_CTEST_COMMAND}" -V -R "^${name}$" ${test_config_options} + ) + if(TARGET "${name}") + add_dependencies("${testname}_check" "${name}") + if(ANDROID) + add_dependencies("${testname}_check" "${name}_make_apk") + endif() + endif() + endif() + + if(ANDROID OR IOS OR WASM OR INTEGRITY OR arg_BUILTIN_TESTDATA OR QT_FORCE_BUILTIN_TESTDATA) + set(builtin_testdata TRUE) + endif() + + if(builtin_testdata) + # Safe guard against qml only tests, no source files == no target + if (TARGET "${name}") + target_compile_definitions("${name}" PRIVATE BUILTIN_TESTDATA) + + foreach(testdata IN LISTS arg_TESTDATA) + list(APPEND builtin_files ${testdata}) + endforeach() + foreach(file IN LISTS builtin_files) + set_source_files_properties(${file} + PROPERTIES QT_SKIP_QUICKCOMPILER TRUE + ) + endforeach() + + if(batch_current_test) + set(blacklist_path "BLACKLIST") + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${blacklist_path}") + get_target_property(blacklist_files ${name} _qt_blacklist_files) + if(NOT blacklist_files) + set_target_properties(${name} PROPERTIES _qt_blacklist_files "") + set(blacklist_files "") + endif() + list(PREPEND blacklist_files "${CMAKE_CURRENT_SOURCE_DIR}/${blacklist_path}") + set_target_properties(${name} PROPERTIES + _qt_blacklist_files "${blacklist_files}") + endif() + else() + set(blacklist_path "BLACKLIST") + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${blacklist_path}") + list(APPEND builtin_files ${blacklist_path}) + endif() + endif() + + list(REMOVE_DUPLICATES builtin_files) + + # Skip Qt quick compiler when embedding test resources + foreach(file IN LISTS builtin_files) + set_source_files_properties(${file} + PROPERTIES QT_SKIP_QUICKCOMPILER TRUE + ) + endforeach() + + if(builtin_files) + qt_internal_add_resource(${name} "${testname}_testdata_builtin" + PREFIX "/" + FILES ${builtin_files} + BASE ${CMAKE_CURRENT_SOURCE_DIR}) + endif() + endif() + else() + # Install test data, when tests are built in-tree or as standalone tests, but not as a + # single standalone test, which is checked by the existence of the QT_TOP_LEVEL_SOURCE_DIR + # variable. + # TODO: Shouldn't we also handle the single standalone test case? + # TODO: Does installing even makes sense, given where QFINDTESTDATA looks for installed + # test data, and where we end up installing it? See QTBUG-117098. + if(QT_TOP_LEVEL_SOURCE_DIR) + foreach(testdata IN LISTS arg_TESTDATA) + set(testdata "${CMAKE_CURRENT_SOURCE_DIR}/${testdata}") + + # Get the relative source dir for each test data entry, because it might contain a + # subdirectory. + file(RELATIVE_PATH relative_path_to_test_project + "${QT_TOP_LEVEL_SOURCE_DIR}" + "${testdata}") + get_filename_component(relative_path_to_test_project + "${relative_path_to_test_project}" DIRECTORY) + + qt_path_join(testdata_install_dir ${QT_INSTALL_DIR} + "${relative_path_to_test_project}") + + if (IS_DIRECTORY "${testdata}") + qt_install( + DIRECTORY "${testdata}" + DESTINATION "${testdata_install_dir}") + else() + qt_install( + FILES "${testdata}" + DESTINATION "${testdata_install_dir}") + endif() + endforeach() + endif() + endif() + + qt_internal_add_test_finalizers("${name}") +endfunction() + +# Generates a blacklist file for the global batched test target. +function(qt_internal_finalize_test_batch_blacklist) + _qt_internal_test_batch_target_name(batch_target_name) + if(NOT TARGET "${batch_target_name}") + return() + endif() + + set(generated_blacklist_file "${CMAKE_CURRENT_BINARY_DIR}/BLACKLIST") + + set(final_contents "") + + get_target_property(blacklist_files "${batch_target_name}" _qt_blacklist_files) + if(blacklist_files) + foreach(blacklist_file ${blacklist_files}) + file(READ "${blacklist_file}" file_contents) + if(file_contents) + string(APPEND final_contents "${file_contents}\n") + endif() + endforeach() + endif() + + qt_configure_file(OUTPUT "${generated_blacklist_file}" CONTENT "${final_contents}") + + qt_internal_add_resource(${batch_target_name} "batch_blacklist" + PREFIX "/" + FILES "${generated_blacklist_file}" + BASE ${CMAKE_CURRENT_BINARY_DIR}) +endfunction() + +# Given an optional test timeout value (specified via qt_internal_add_test's TIMEOUT option) +# returns a percentage of the final timeout to be passed to the androidtestrunner executable. +# +# When the optional timeout is empty, default to cmake's defaults for getting the timeout. +function(qt_internal_get_android_test_timeout input_timeout percentage output_timeout_var) + set(actual_timeout "${input_timeout}") + if(NOT actual_timeout) + # we have coin ci timeout set use that to avoid having the emulator killed + # so we can at least get some logs from the android test runner. + set(coin_timeout $ENV{COIN_COMMAND_OUTPUT_TIMEOUT}) + if(coin_timeout) + set(actual_timeout "${coin_timeout}") + elseif(DART_TESTING_TIMEOUT) + # Related: https://gitlab.kitware.com/cmake/cmake/-/issues/20450 + set(actual_timeout "${DART_TESTING_TIMEOUT}") + elseif(CTEST_TEST_TIMEOUT) + set(actual_timeout "${CTEST_TEST_TIMEOUT}") + else() + # Default DART_TESTING_TIMEOUT is 25 minutes, specified in seconds + # https://github.com/Kitware/CMake/blob/master/Modules/CTest.cmake#L167C16-L167C16 + set(actual_timeout "1500") + endif() + endif() + + math(EXPR calculated_timeout "${actual_timeout} * ${percentage} / 100") + + set(${output_timeout_var} "${calculated_timeout}" PARENT_SCOPE) +endfunction() + +# This function adds test with specified NAME and wraps given test COMMAND with standalone cmake +# script. +# +# NAME must be compatible with add_test function, since it's propagated as is. +# COMMAND might be either target or path to executable. When test is called either by ctest or +# directly by 'cmake -P path/to/scriptWrapper.cmake', COMMAND will be executed in specified +# WORKING_DIRECTORY with arguments specified in ARGS. +# +# See also _qt_internal_create_command_script for details. +function(qt_internal_create_test_script) + #This style of parsing keeps ';' in ENVIRONMENT variables + cmake_parse_arguments(PARSE_ARGV 0 arg + "" + "NAME;COMMAND;OUTPUT_FILE;WORKING_DIRECTORY" + "ARGS;ENVIRONMENT;PRE_RUN;POST_RUN" + ) + + if(NOT arg_COMMAND) + message(FATAL_ERROR "qt_internal_create_test_script: Test COMMAND is not specified") + endif() + + if(NOT arg_NAME) + message(FATAL_ERROR "qt_internal_create_test_script: Test NAME is not specified") + endif() + + if(NOT arg_OUTPUT_FILE) + message(FATAL_ERROR "qt_internal_create_test_script: Test Wrapper OUTPUT_FILE\ +is not specified") + endif() + + if(arg_PRE_RUN) + message(WARNING "qt_internal_create_test_script: PRE_RUN is not acceptable argument\ +for this function. Will be ignored") + endif() + + if(arg_POST_RUN) + message(WARNING "qt_internal_create_test_script: POST_RUN is not acceptable argument\ +for this function. Will be ignored") + endif() + + if(arg_ARGS) + set(command_args ${arg_ARGS})# Avoid "${arg_ARGS}" usage and let cmake expand string to + # semicolon-separated list + qt_internal_wrap_command_arguments(command_args) + endif() + + if(TARGET ${arg_COMMAND}) + set(executable_file "$") + else() + set(executable_file "${arg_COMMAND}") + endif() + + set(executable_name ${arg_NAME}) + qt_internal_is_in_test_batch(is_in_batch ${executable_name}) + if(is_in_batch) + _qt_internal_test_batch_target_name(executable_name) + endif() + add_test(NAME "${arg_NAME}" COMMAND "${CMAKE_COMMAND}" "-P" "${arg_OUTPUT_FILE}" + WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}") + + # If crosscompiling is enabled, we should avoid run cmake in emulator environment. + # Prepend emulator to test command in generated cmake script instead. Keep in mind that + # CROSSCOMPILING_EMULATOR don't check if actual cross compilation is configured, + # emulator is prepended independently. + set(crosscompiling_emulator "") + if(CMAKE_CROSSCOMPILING AND TARGET ${executable_name}) + get_target_property(crosscompiling_emulator ${executable_name} CROSSCOMPILING_EMULATOR) + if(NOT crosscompiling_emulator) + set(crosscompiling_emulator "") + else() + qt_internal_wrap_command_arguments(crosscompiling_emulator) + endif() + endif() + + _qt_internal_create_command_script(COMMAND "${crosscompiling_emulator} \${env_test_runner} \ +\"${executable_file}\" \${env_test_args} ${command_args}" + OUTPUT_FILE "${arg_OUTPUT_FILE}" + WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}" + ENVIRONMENT ${arg_ENVIRONMENT} + PRE_RUN "separate_arguments(env_test_args NATIVE_COMMAND \ +\"\$ENV{TESTARGS}\")" + "separate_arguments(env_test_runner NATIVE_COMMAND \ +\"\$ENV{TESTRUNNER}\")" + ) +endfunction() + + + +# This function creates an executable for use as a helper program with tests. Some +# tests launch separate programs to test certain input/output behavior. +# Specify OVERRIDE_OUTPUT_DIRECTORY if you don't want to place the helper in the parent directory, +# in which case you should specify OUTPUT_DIRECTORY "/foo/bar" manually. +function(qt_internal_add_test_helper name) + + set(qt_add_test_helper_optional_args + "OVERRIDE_OUTPUT_DIRECTORY" + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${qt_add_test_helper_optional_args};${__qt_internal_add_executable_optional_args}" + "${__qt_internal_add_executable_single_args}" + "${__qt_internal_add_executable_multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + qt_remove_args(forward_args + ARGS_TO_REMOVE + "${name}" + ${qt_add_test_helper_optional_args} + ALL_ARGS + ${qt_add_test_helper_optional_args} + ${__qt_internal_add_executable_optional_args} + ${__qt_internal_add_executable_single_args} + ${__qt_internal_add_executable_multi_args} + ARGS + ${ARGV} + ) + + set(extra_args_to_pass) + if(NOT arg_OVERRIDE_OUTPUT_DIRECTORY) + _qt_internal_test_batch_target_name(test_batch_target_name) + if(QT_BUILD_TESTS_BATCHED AND TARGET ${test_batch_target_name}) + get_target_property( + test_batch_output_dir ${test_batch_target_name} RUNTIME_OUTPUT_DIRECTORY) + set(extra_args_to_pass OUTPUT_DIRECTORY "${test_batch_output_dir}") + else() + set(extra_args_to_pass OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/..") + endif() + endif() + + qt_internal_add_executable("${name}" NO_INSTALL + NO_UNITY_BUILD # excluded by default + ${extra_args_to_pass} ${forward_args}) + + # Disable the QT_NO_NARROWING_CONVERSIONS_IN_CONNECT define for test helpers + qt_internal_undefine_global_definition(${name} QT_NO_NARROWING_CONVERSIONS_IN_CONNECT) + +endfunction() + +function(qt_internal_wrap_command_arguments argument_list) + list(TRANSFORM ${argument_list} REPLACE "^(.+)$" "[=[\\1]=]") + list(JOIN ${argument_list} " " ${argument_list}) + set(${argument_list} "${${argument_list}}" PARENT_SCOPE) +endfunction() + +function(qt_internal_collect_command_environment out_path out_plugin_path) + # Get path to /bin, as well as CMAKE_INSTALL_PREFIX/bin, and + # combine them with the PATH environment variable. + # It's needed on Windows to find the shared libraries and plugins. + # qt_relocatable_install_prefix is dynamically computed from the location of where the Qt CMake + # package is found. + # The regular CMAKE_INSTALL_PREFIX can be different for example when building standalone tests. + # Any given CMAKE_INSTALL_PREFIX takes priority over qt_relocatable_install_prefix for the + # PATH environment variable. + set(install_prefixes "${CMAKE_INSTALL_PREFIX}") + if(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX) + list(APPEND install_prefixes "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}") + endif() + + file(TO_NATIVE_PATH "${CMAKE_CURRENT_BINARY_DIR}" test_env_path) + foreach(install_prefix ${install_prefixes}) + file(TO_NATIVE_PATH "${install_prefix}/${INSTALL_BINDIR}" install_prefix) + set(test_env_path "${test_env_path}${QT_PATH_SEPARATOR}${install_prefix}") + endforeach() + set(test_env_path "${test_env_path}${QT_PATH_SEPARATOR}$ENV{PATH}") + string(REPLACE ";" "\;" test_env_path "${test_env_path}") + set(${out_path} "${test_env_path}" PARENT_SCOPE) + + # Add the install prefix to list of plugin paths when doing a prefix build + if(NOT QT_INSTALL_DIR) + foreach(install_prefix ${install_prefixes}) + file(TO_NATIVE_PATH "${install_prefix}/${INSTALL_BINDIR}" install_prefix) + list(APPEND plugin_paths "${install_prefix}") + endforeach() + endif() + + #TODO: Collect all paths from known repositories when performing a super + # build. + file(TO_NATIVE_PATH "${PROJECT_BINARY_DIR}/${INSTALL_PLUGINSDIR}" install_pluginsdir) + list(APPEND plugin_paths "${install_pluginsdir}") + list(JOIN plugin_paths "${QT_PATH_SEPARATOR}" plugin_paths_joined) + string(REPLACE ";" "\;" plugin_paths_joined "${plugin_paths_joined}") + set(${out_plugin_path} "${plugin_paths_joined}" PARENT_SCOPE) +endfunction() + +function(qt_internal_add_test_finalizers target) + # It might not be safe to run all the finalizers of _qt_internal_finalize_executable + # within the context of a Qt build (not a user project) when targeting a host build. + # At least one issue is missing qmlimportscanner at configure time. + # For now, we limit it to iOS, where it was tested to work, an we know that host tools + # should already be built and available. + if(IOS) + qt_add_list_file_finalizer(_qt_internal_finalize_executable "${target}") + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtToolHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtToolHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c9d2f199772d0e64751b416ac8cd2697408d880c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtToolHelpers.cmake @@ -0,0 +1,834 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This function is used to define a "Qt tool", such as moc, uic or rcc. +# +# USER_FACING can be passed to mark the tool as a program that is supposed to be +# started directly by users. +# +# We must pass this function a target name obtained from +# qt_get_tool_target_name like this: +# qt_get_tool_target_name(target_name my_tool) +# qt_internal_add_tool(${target_name}) +# +# Option Arguments: +# INSTALL_VERSIONED_LINK +# Prefix build only. On installation, create a versioned hard-link of the installed file. +# E.g. create a link of "bin/qmake6" to "bin/qmake". +# TRY_RUN +# On Windows, it creates a helper batch script that tests whether the tool can be executed +# successfully or not. If not, build halts and an error will be show, with tips on what +# might be cause, and how to fix it. TRY_RUN is disabled when cross-compiling. +# TRY_RUN_FLAGS +# Command line flags that are going to be passed to the tool for testing its correctness. +# If no flags were given, we default to `-v`. +# REQUIRED_FOR_DOCS +# Specifies that the built tool is required to generate documentation. Examples are qdoc, +# and qvkgen (because they participate in header file generation, which are needed for +# documentation generation). +# +# One-value Arguments: +# EXTRA_CMAKE_FILES +# List of additional CMake files that will be installed alongside the tool's exported CMake +# files. +# EXTRA_CMAKE_INCLUDES +# List of files that will be included in the Qt6${module}Tools.cmake file. +# Also see TOOLS_TARGET. +# INSTALL_DIR +# Takes a path, relative to the install prefix, like INSTALL_LIBEXECDIR. +# If this argument is omitted, the default is INSTALL_BINDIR. +# TOOLS_TARGET +# Specifies the module this tool belongs to. The module's Qt6${module}Tools.cmake file +# will then contain targets for this tool. +# CORE_LIBRARY +# The argument accepts 'Bootstrap' or 'None' values. If the argument value is set to +# 'Bootstrap' the Qt::Bootstrap library is linked to the executable instead of Qt::Core. +# The 'None' value points that core library is not necessary and avoids linking neither +# Qt::Core or Qt::Bootstrap libraries. Otherwise the Qt::Core library will be publicly +# linked to the executable target by default. +function(qt_internal_add_tool target_name) + qt_tool_target_to_name(name ${target_name}) + set(option_keywords + NO_INSTALL + USER_FACING + INSTALL_VERSIONED_LINK + EXCEPTIONS + NO_UNITY_BUILD + TRY_RUN + REQUIRED_FOR_DOCS + ${__qt_internal_sbom_optional_args} + ) + set(one_value_keywords + TOOLS_TARGET + INSTALL_DIR + CORE_LIBRARY + TRY_RUN_FLAGS + ${__default_target_info_args} + ${__qt_internal_sbom_single_args} + ) + set(multi_value_keywords + EXTRA_CMAKE_FILES + EXTRA_CMAKE_INCLUDES + PUBLIC_LIBRARIES + ${__default_private_args} + ${__qt_internal_sbom_multi_args} + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_keywords}" + "${one_value_keywords}" + "${multi_value_keywords}") + _qt_internal_validate_all_args_are_parsed(arg) + + qt_internal_find_tool(will_build_tools ${target_name} "${arg_TOOLS_TARGET}") + + if(NOT will_build_tools) + return() + endif() + + set(disable_autogen_tools "${arg_DISABLE_AUTOGEN_TOOLS}") + set(corelib "") + if(arg_CORE_LIBRARY STREQUAL "Bootstrap" OR arg_CORE_LIBRARY STREQUAL "None") + set(corelib CORE_LIBRARY ${arg_CORE_LIBRARY}) + list(APPEND disable_autogen_tools "uic" "moc" "rcc") + endif() + + set(exceptions "") + if(arg_EXCEPTIONS) + set(exceptions EXCEPTIONS) + endif() + + set(install_dir "${INSTALL_BINDIR}") + if(arg_INSTALL_DIR) + set(install_dir "${arg_INSTALL_DIR}") + endif() + + set(output_dir "${QT_BUILD_DIR}/${install_dir}") + + if(arg_PUBLIC_LIBRARIES) + message(WARNING + "qt_internal_add_tool's PUBLIC_LIBRARIES option is deprecated, and will be " + "removed in a future Qt version. Use the LIBRARIES option instead.") + endif() + + if(arg_NO_UNITY_BUILD) + set(arg_NO_UNITY_BUILD "NO_UNITY_BUILD") + else() + set(arg_NO_UNITY_BUILD "") + endif() + + _qt_internal_forward_function_args( + FORWARD_PREFIX arg + FORWARD_OUT_VAR add_executable_args + FORWARD_SINGLE + TARGET_COMPANY + TARGET_COPYRIGHT + TARGET_DESCRIPTION + TARGET_PRODUCT + TARGET_VERSION + ) + + qt_internal_add_executable("${target_name}" + OUTPUT_DIRECTORY "${output_dir}" + ${exceptions} + NO_INSTALL + ${arg_NO_UNITY_BUILD} + SOURCES ${arg_SOURCES} + NO_PCH_SOURCES ${arg_NO_PCH_SOURCES} + NO_UNITY_BUILD_SOURCES ${arg_NO_UNITY_BUILD_SOURCES} + INCLUDE_DIRECTORIES + ${arg_INCLUDE_DIRECTORIES} + DEFINES + ${arg_DEFINES} + ${deprecation_define} + ${corelib} + LIBRARIES + ${arg_LIBRARIES} + ${arg_PUBLIC_LIBRARIES} + Qt::PlatformToolInternal + COMPILE_OPTIONS ${arg_COMPILE_OPTIONS} + LINK_OPTIONS ${arg_LINK_OPTIONS} + MOC_OPTIONS ${arg_MOC_OPTIONS} + DISABLE_AUTOGEN_TOOLS ${disable_autogen_tools} + ${add_executable_args} + # If you are putting anything after these, make sure that + # qt_set_target_info_properties knows how to process them + ) + qt_internal_add_target_aliases("${target_name}") + qt_internal_adjust_main_config_runtime_output_dir("${target_name}" "${output_dir}") + + if (WIN32) + _qt_internal_generate_longpath_win32_rc_file_and_manifest("${target_name}") + endif() + + set_target_properties(${target_name} PROPERTIES + _qt_package_version "${PROJECT_VERSION}" + ) + set_property(TARGET ${target_name} + APPEND PROPERTY + EXPORT_PROPERTIES "_qt_package_version") + + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.19.0" AND QT_FEATURE_debug_and_release) + set_property(TARGET "${target_name}" + PROPERTY EXCLUDE_FROM_ALL "$>") + endif() + + if (NOT target_name STREQUAL name) + set_target_properties(${target_name} PROPERTIES + OUTPUT_NAME ${name} + EXPORT_NAME ${name} + ) + endif() + + if(TARGET host_tools) + add_dependencies(host_tools "${target_name}") + if(arg_REQUIRED_FOR_DOCS) + add_dependencies(doc_tools "${target_name}") + endif() + if(arg_CORE_LIBRARY STREQUAL "Bootstrap") + add_dependencies(bootstrap_tools "${target_name}") + endif() + endif() + + if(arg_EXTRA_CMAKE_FILES) + set_target_properties(${target_name} PROPERTIES + EXTRA_CMAKE_FILES "${arg_EXTRA_CMAKE_FILES}" + ) + endif() + + if(arg_EXTRA_CMAKE_INCLUDES) + set_target_properties(${target_name} PROPERTIES + EXTRA_CMAKE_INCLUDES "${arg_EXTRA_CMAKE_INCLUDES}" + ) + endif() + + if(arg_USER_FACING) + set_property(GLOBAL APPEND PROPERTY QT_USER_FACING_TOOL_TARGETS ${target_name}) + endif() + + if(QT_GENERATE_SBOM) + set(sbom_args "") + list(APPEND sbom_args TYPE QT_TOOL) + endif() + + if(NOT arg_NO_INSTALL AND arg_TOOLS_TARGET) + set(will_install TRUE) + else() + set(will_install FALSE) + if(QT_GENERATE_SBOM) + list(APPEND sbom_args NO_INSTALL) + endif() + endif() + + if(will_install) + # Assign a tool to an export set, and mark the module to which the tool belongs. + qt_internal_append_known_modules_with_tools("${arg_TOOLS_TARGET}") + + # Also append the tool to the module list. + qt_internal_append_known_module_tool("${arg_TOOLS_TARGET}" "${target_name}") + + qt_get_cmake_configurations(cmake_configs) + + set(install_initial_call_args + EXPORT "${INSTALL_CMAKE_NAMESPACE}${arg_TOOLS_TARGET}ToolsTargets" + COMPONENT host_tools + ) + + foreach(cmake_config ${cmake_configs}) + qt_get_install_target_default_args( + OUT_VAR install_targets_default_args + OUT_VAR_RUNTIME runtime_install_destination + RUNTIME "${install_dir}" + CMAKE_CONFIG "${cmake_config}" + ALL_CMAKE_CONFIGS ${cmake_configs}) + + # Make installation optional for targets that are not built by default in this config + if(QT_FEATURE_debug_and_release + AND NOT (cmake_config STREQUAL QT_MULTI_CONFIG_FIRST_CONFIG)) + set(install_optional_arg OPTIONAL) + else() + unset(install_optional_arg) + endif() + + if(QT_GENERATE_SBOM) + _qt_internal_sbom_append_multi_config_aware_single_arg_option( + RUNTIME_PATH + "${runtime_install_destination}" + "${cmake_config}" + sbom_args + ) + endif() + + qt_install(TARGETS "${target_name}" + ${install_initial_call_args} + ${install_optional_arg} + CONFIGURATIONS ${cmake_config} + ${install_targets_default_args}) + unset(install_initial_call_args) + endforeach() + + if(arg_INSTALL_VERSIONED_LINK) + qt_internal_install_versioned_link(WORKING_DIRECTORY "${install_dir}" + TARGETS "${target_name}") + endif() + + qt_apply_rpaths(TARGET "${target_name}" INSTALL_PATH "${install_dir}" RELATIVE_RPATH) + qt_internal_apply_staging_prefix_build_rpath_workaround() + endif() + + if(arg_TRY_RUN AND WIN32 AND NOT CMAKE_CROSSCOMPILING) + if(NOT arg_TRY_RUN_FLAGS) + set(arg_TRY_RUN_FLAGS "-v") + endif() + _qt_internal_add_try_run_post_build("${target_name}" "${arg_TRY_RUN_FLAGS}") + endif() + + qt_enable_separate_debug_info(${target_name} "${install_dir}" QT_EXECUTABLE) + qt_internal_install_pdb_files(${target_name} "${install_dir}") + + if(QT_GENERATE_SBOM) + _qt_internal_forward_function_args( + FORWARD_APPEND + FORWARD_PREFIX arg + FORWARD_OUT_VAR sbom_args + FORWARD_OPTIONS + ${__qt_internal_sbom_optional_args} + FORWARD_SINGLE + ${__qt_internal_sbom_single_args} + FORWARD_MULTI + ${__qt_internal_sbom_multi_args} + ) + + _qt_internal_extend_sbom(${target_name} ${sbom_args}) + endif() + + qt_add_list_file_finalizer(qt_internal_finalize_tool ${target_name}) +endfunction() + +function(qt_internal_finalize_tool target) + _qt_internal_finalize_sbom(${target}) +endfunction() + +function(_qt_internal_add_try_run_post_build target try_run_flags) + qt_internal_get_upper_case_main_cmake_configuration(main_cmake_configuration) + get_target_property(target_out_dir ${target} + RUNTIME_OUTPUT_DIRECTORY_${main_cmake_configuration}) + get_target_property(target_bin_dir ${target} + BINARY_DIR) + + set(try_run_scripts_path "${target_bin_dir}/${target}_try_run.bat") + # The only reason -h is passed is because some of the tools, e.g., moc + # wait for an input without any arguments. + + qt_configure_file(OUTPUT "${try_run_scripts_path}" + CONTENT "@echo off + +${target_out_dir}/${target}.exe ${try_run_flags} > nul 2>&1 + +if \"%errorlevel%\" == \"-1073741515\" ( +echo +echo '${target}' is built successfully, but some of the libraries +echo necessary for running it are missing. If you are building Qt with +echo 3rdparty libraries, make sure that you add their directory to the +echo PATH environment variable. +echo +exit /b %errorlevel% +) +echo. > ${target_bin_dir}/${target}_try_run_passed" + ) + + add_custom_command( + OUTPUT + ${target_bin_dir}/${target}_try_run_passed + DEPENDS + ${target} + COMMAND + ${CMAKE_COMMAND} -E env QT_COMMAND_LINE_PARSER_NO_GUI_MESSAGE_BOXES=1 + ${try_run_scripts_path} + COMMENT + "Testing ${target} by trying to run it." + VERBATIM + ) + + add_custom_target(${target}_try_run ALL + DEPENDS ${target_bin_dir}/${target}_try_run_passed) +endfunction() + +function(qt_export_tools module_name) + # Bail out when not building tools. + if(NOT QT_WILL_BUILD_TOOLS) + return() + endif() + + # If no tools were defined belonging to this module, don't create a config and targets file. + if(NOT "${module_name}" IN_LIST QT_KNOWN_MODULES_WITH_TOOLS) + return() + endif() + + # The tools target name. For example: CoreTools + set(target "${module_name}Tools") + + set(path_suffix "${INSTALL_CMAKE_NAMESPACE}${target}") + qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${path_suffix}) + qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${path_suffix}) + + # Add the extra cmake statements to make the tool targets global, so it doesn't matter where + # find_package is called. + # Also assemble a list of tool targets to expose in the config file for informational purposes. + set(extra_cmake_statements "") + set(tool_targets "") + set(tool_targets_non_prefixed "") + + # List of package dependencies that need be find_package'd when using the Tools package. + set(package_deps "") + + # Additional cmake files to install + set(extra_cmake_files "") + set(extra_cmake_includes "") + + set(first_tool_package_version "") + + foreach(tool_name ${QT_KNOWN_MODULE_${module_name}_TOOLS}) + # Specific tools can have package dependencies. + # e.g. qtwaylandscanner depends on WaylandScanner (non-qt package). + get_target_property(extra_packages "${tool_name}" QT_EXTRA_PACKAGE_DEPENDENCIES) + if(extra_packages) + list(APPEND package_deps "${extra_packages}") + endif() + + get_target_property(_extra_cmake_files "${tool_name}" EXTRA_CMAKE_FILES) + if (_extra_cmake_files) + foreach(cmake_file ${_extra_cmake_files}) + file(COPY "${cmake_file}" DESTINATION "${config_build_dir}") + list(APPEND extra_cmake_files "${cmake_file}") + endforeach() + endif() + + get_target_property(_extra_cmake_includes "${tool_name}" EXTRA_CMAKE_INCLUDES) + if(_extra_cmake_includes) + list(APPEND extra_cmake_includes "${_extra_cmake_includes}") + endif() + + if (QT_WILL_RENAME_TOOL_TARGETS) + string(REGEX REPLACE "_native$" "" tool_name ${tool_name}) + endif() + set(extra_cmake_statements "${extra_cmake_statements} +if(NOT QT_NO_CREATE_TARGETS AND ${INSTALL_CMAKE_NAMESPACE}${target}_FOUND) + __qt_internal_promote_target_to_global(${INSTALL_CMAKE_NAMESPACE}::${tool_name}) +endif() +") + list(APPEND tool_targets "${QT_CMAKE_EXPORT_NAMESPACE}::${tool_name}") + list(APPEND tool_targets_non_prefixed "${tool_name}") + + if(NOT first_tool_package_version) + qt_internal_get_package_version_of_target("${tool_name}" tool_package_version) + if(tool_package_version) + set(first_tool_package_version "${tool_package_version}") + endif() + endif() + endforeach() + + string(APPEND extra_cmake_statements +"set(${QT_CMAKE_EXPORT_NAMESPACE}${module_name}Tools_TARGETS \"${tool_targets}\")") + + # Extract package dependencies that were determined in QtPostProcess, but only if ${module_name} + # is an actual target. + # module_name can be a non-existent target, if the tool doesn't have an existing associated + # module, e.g. qtwaylandscanner. + if(TARGET "${module_name}") + get_target_property(module_package_deps "${module_name}" _qt_tools_package_deps) + if(module_package_deps) + list(APPEND package_deps "${module_package_deps}") + endif() + endif() + + # Configure and install dependencies file for the ${module_name}Tools package. + configure_file( + "${QT_CMAKE_DIR}/QtModuleToolsDependencies.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Dependencies.cmake" + @ONLY + ) + + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Dependencies.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + + if(extra_cmake_files) + qt_install(FILES + ${extra_cmake_files} + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + endif() + + # Configure and install the ${module_name}Tools package Config file. + qt_internal_get_min_new_policy_cmake_version(min_new_policy_version) + qt_internal_get_max_new_policy_cmake_version(max_new_policy_version) + configure_package_config_file( + "${QT_CMAKE_DIR}/QtModuleToolsConfig.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake" + INSTALL_DESTINATION "${config_install_dir}" + ) + + # There might be Tools packages which don't have a corresponding real module_name target, like + # WaylandScannerTools. + # In that case we'll use the package version of the first tool that belongs to that package. + if(TARGET "${module_name}") + qt_internal_get_package_version_of_target("${module_name}" tools_package_version) + elseif(first_tool_package_version) + set(tools_package_version "${first_tool_package_version}") + else() + # This should never happen, because tools_package_version should always have at least some + # value. Issue an assertion message just in case the pre-condition ever changes. + set(tools_package_version "${PROJECT_VERSION}") + if(FEATURE_developer_build) + message(WARNING + "Could not determine package version of tools package ${module_name}. " + "Defaulting to project version ${PROJECT_VERSION}.") + endif() + endif() + message(TRACE + "Exporting tools package ${module_name}Tools with package version ${tools_package_version}" + "\n included targets: ${tool_targets_non_prefixed}") + write_basic_package_version_file( + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake" + VERSION "${tools_package_version}" + COMPATIBILITY AnyNewerVersion + ARCH_INDEPENDENT + ) + qt_internal_write_qt_package_version_file( + "${INSTALL_CMAKE_NAMESPACE}${target}" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersion.cmake" + ) + + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersion.cmake" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) + + set(export_name "${INSTALL_CMAKE_NAMESPACE}${target}Targets") + qt_install(EXPORT "${export_name}" + NAMESPACE "${QT_CMAKE_EXPORT_NAMESPACE}::" + DESTINATION "${config_install_dir}") + + qt_internal_export_additional_targets_file( + TARGETS ${QT_KNOWN_MODULE_${module_name}_TOOLS} + TARGET_EXPORT_NAMES ${tool_targets} + EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target} + CONFIG_INSTALL_DIR "${config_install_dir}") + + # Create versionless targets file. + configure_file( + "${QT_CMAKE_DIR}/QtModuleToolsVersionlessTargets.cmake.in" + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}VersionlessTargets.cmake" + @ONLY + ) + + qt_install(FILES + "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}VersionlessTargets.cmake" + DESTINATION "${config_install_dir}" + COMPONENT Devel + ) +endfunction() + +# Returns the target name for the tool with the given name. +# +# In most cases, the target name is the same as the tool name. +# If the user specifies to build tools when cross-compiling, then the +# suffix "_native" is appended. +function(qt_get_tool_target_name out_var name) + if (QT_WILL_RENAME_TOOL_TARGETS) + set(${out_var} ${name}_native PARENT_SCOPE) + else() + set(${out_var} ${name} PARENT_SCOPE) + endif() +endfunction() + +# Returns the tool name for a given tool target. +# This is the inverse of qt_get_tool_target_name. +function(qt_tool_target_to_name out_var target) + set(name ${target}) + if (QT_WILL_RENAME_TOOL_TARGETS) + string(REGEX REPLACE "_native$" "" name ${target}) + endif() + set(${out_var} ${name} PARENT_SCOPE) +endfunction() + +# Sets QT_WILL_BUILD_TOOLS if tools will be built and QT_WILL_RENAME_TOOL_TARGETS +# if those tools have replaced naming. +function(qt_check_if_tools_will_be_built) + # By default, we build our own tools unless we're cross-building or QT_HOST_PATH is set. + set(need_target_rename FALSE) + set(require_find_tools FALSE) + if(CMAKE_CROSSCOMPILING) + set(will_build_tools FALSE) + if(QT_FORCE_BUILD_TOOLS) + set(will_build_tools TRUE) + set(need_target_rename TRUE) + endif() + set(require_find_tools TRUE) + else() + if(QT_HOST_PATH) + set(will_build_tools FALSE) + else() + set(will_build_tools TRUE) + endif() + if(QT_FORCE_FIND_TOOLS) + set(will_build_tools FALSE) + set(require_find_tools TRUE) + endif() + if(QT_FORCE_BUILD_TOOLS) + set(will_build_tools TRUE) + set(need_target_rename TRUE) + endif() + endif() + + set_property(GLOBAL PROPERTY qt_require_find_tools "${require_find_tools}") + + set(QT_WILL_BUILD_TOOLS ${will_build_tools} CACHE INTERNAL "Are tools going to be built" FORCE) + set(QT_WILL_RENAME_TOOL_TARGETS ${need_target_rename} CACHE INTERNAL + "Do tool targets need to be renamed" FORCE) +endfunction() + +# Use this macro to exit a file or function scope unless we're building tools. This is supposed to +# be called after qt_internal_add_tools() to avoid special-casing operations on imported targets. +macro(qt_internal_return_unless_building_tools) + if(NOT QT_WILL_BUILD_TOOLS) + return() + endif() +endmacro() + +# Equivalent of qmake's qtNomakeTools(directory1 directory2). +# If QT_BUILD_TOOLS_BY_DEFAULT is true, then targets within the given directories will be excluded +# from the default 'all' target, as well as from install phase. The private variable is checked by +# qt_internal_add_executable. +function(qt_exclude_tool_directories_from_default_target) + if(NOT QT_BUILD_TOOLS_BY_DEFAULT) + set(absolute_path_directories "") + foreach(directory ${ARGV}) + list(APPEND absolute_path_directories "${CMAKE_CURRENT_SOURCE_DIR}/${directory}") + endforeach() + set(__qt_exclude_tool_directories "${absolute_path_directories}" PARENT_SCOPE) + endif() +endfunction() + +function(qt_internal_find_tool out_var target_name tools_target) + qt_tool_target_to_name(name ${target_name}) + + # Handle case when a tool does not belong to a module and it can't be built either (like + # during a cross-compile). + if(NOT tools_target AND NOT QT_WILL_BUILD_TOOLS) + message(FATAL_ERROR "The tool \"${name}\" has not been assigned to a module via" + " TOOLS_TARGET (so it can't be found) and it can't be built" + " (QT_WILL_BUILD_TOOLS is ${QT_WILL_BUILD_TOOLS}).") + endif() + + if(NOT CMAKE_CROSSCOMPILING) + if(QT_INTERNAL_FORCE_FIND_HOST_TOOLS_MODULE_LIST AND + NOT "${tools_target}" IN_LIST QT_INTERNAL_FORCE_FIND_HOST_TOOLS_MODULE_LIST) + message(STATUS "Tool '${full_name}' will be built from source.") + set(${out_var} "TRUE" PARENT_SCOPE) + return() + endif() + endif() + + if(QT_WILL_RENAME_TOOL_TARGETS AND (name STREQUAL target_name)) + message(FATAL_ERROR + "qt_internal_add_tool must be passed a target obtained from qt_get_tool_target_name.") + endif() + + set(full_name "${QT_CMAKE_EXPORT_NAMESPACE}::${name}") + set(imported_tool_target_already_found FALSE) + + # This condition can only be TRUE if a previous find_package(Qt6${tools_target}Tools) + # was already done. That can happen if QT_FORCE_FIND_TOOLS was ON or we're cross-compiling. + # In such a case, we need to exit early if we're not going to also build the tools. + if(TARGET ${full_name}) + get_property(path TARGET ${full_name} PROPERTY LOCATION) + message(STATUS "Tool '${full_name}' was found at ${path}.") + set(imported_tool_target_already_found TRUE) + if(NOT QT_WILL_BUILD_TOOLS) + set(${out_var} "FALSE" PARENT_SCOPE) + return() + endif() + endif() + + # We need to search for the host Tools package when doing a cross-build + # or when QT_FORCE_FIND_TOOLS is ON. + # As an optimiziation, we don't search for the package one more time if the target + # was already brought into scope from a previous find_package. + set(search_for_host_package FALSE) + if(NOT QT_WILL_BUILD_TOOLS OR QT_WILL_RENAME_TOOL_TARGETS) + set(search_for_host_package TRUE) + endif() + if(search_for_host_package AND NOT imported_tool_target_already_found) + set(tools_package_name "${INSTALL_CMAKE_NAMESPACE}${tools_target}Tools") + message(STATUS "Searching for tool '${full_name}' in package ${tools_package_name}.") + + # Create the tool targets, even if QT_NO_CREATE_TARGETS is set. + # Otherwise targets like Qt6::moc are not available in a top-level cross-build. + set(BACKUP_QT_NO_CREATE_TARGETS ${QT_NO_CREATE_TARGETS}) + set(QT_NO_CREATE_TARGETS OFF) + + # When cross-compiling, we want to search for Tools packages in QT_HOST_PATH. + # To do that, we override CMAKE_PREFIX_PATH and CMAKE_FIND_ROOT_PATH. + # + # We don't use find_package + PATHS option because any recursive find_dependency call + # inside a Tools package would not inherit the initial PATHS value given. + # TODO: Potentially we could set a global __qt_cmake_host_dir var like we currently + # do with _qt_cmake_dir in Qt6Config and change all our host tool find_package calls + # everywhere to specify that var in PATHS. + # + # Note though that due to path rerooting issue in + # https://gitlab.kitware.com/cmake/cmake/-/issues/21937 + # we have to append a lib/cmake suffix to CMAKE_PREFIX_PATH so the value does not get + # rerooted on top of CMAKE_FIND_ROOT_PATH. + # Use QT_HOST_PATH_CMAKE_DIR for the suffix when available (it would be set by + # the qt.toolchain.cmake file when building other repos or given by the user when + # configuring qtbase) or derive it from from the Qt6HostInfo package which is + # found in QtSetup. + set(${tools_package_name}_BACKUP_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH}) + set(${tools_package_name}_BACKUP_CMAKE_FIND_ROOT_PATH "${CMAKE_FIND_ROOT_PATH}") + if(QT_HOST_PATH_CMAKE_DIR) + set(qt_host_path_cmake_dir_absolute "${QT_HOST_PATH_CMAKE_DIR}") + elseif(Qt${PROJECT_VERSION_MAJOR}HostInfo_DIR) + get_filename_component(qt_host_path_cmake_dir_absolute + "${Qt${PROJECT_VERSION_MAJOR}HostInfo_DIR}/.." ABSOLUTE) + else() + # This should never happen, serves as an assert. + message(FATAL_ERROR + "Neither QT_HOST_PATH_CMAKE_DIR nor " + "Qt${PROJECT_VERSION_MAJOR}HostInfo_DIR available.") + endif() + set(CMAKE_PREFIX_PATH "${qt_host_path_cmake_dir_absolute}") + + # Look for tools in additional host Qt installations. This is done for conan support where + # we have separate installation prefixes per package. For simplicity, we assume here that + # all host Qt installations use the same value of INSTALL_LIBDIR. + if(DEFINED QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH) + file(RELATIVE_PATH rel_host_cmake_dir "${QT_HOST_PATH}" + "${qt_host_path_cmake_dir_absolute}") + foreach(host_path IN LISTS QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH) + set(host_cmake_dir "${host_path}/${rel_host_cmake_dir}") + list(PREPEND CMAKE_PREFIX_PATH "${host_cmake_dir}") + endforeach() + + list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH}") + endif() + list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_HOST_PATH}") + + find_package( + ${tools_package_name} + ${PROJECT_VERSION} + NO_PACKAGE_ROOT_PATH + NO_CMAKE_ENVIRONMENT_PATH + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_PACKAGE_REGISTRY + NO_CMAKE_SYSTEM_PATH + NO_CMAKE_SYSTEM_PACKAGE_REGISTRY) + + # Restore backups. + set(CMAKE_FIND_ROOT_PATH "${${tools_package_name}_BACKUP_CMAKE_FIND_ROOT_PATH}") + set(CMAKE_PREFIX_PATH "${${tools_package_name}_BACKUP_CMAKE_PREFIX_PATH}") + set(QT_NO_CREATE_TARGETS ${BACKUP_QT_NO_CREATE_TARGETS}) + + if(${${tools_package_name}_FOUND} AND TARGET ${full_name}) + # Even if the tool is already visible, make sure that our modules remain associated + # with the tools. + qt_internal_append_known_modules_with_tools("${tools_target}") + get_property(path TARGET ${full_name} PROPERTY LOCATION) + message(STATUS "${full_name} was found at ${path} using package ${tools_package_name}.") + if (NOT QT_FORCE_BUILD_TOOLS) + set(${out_var} "FALSE" PARENT_SCOPE) + return() + endif() + endif() + endif() + + get_property(require_find_tools GLOBAL PROPERTY qt_require_find_tools) + if(require_find_tools AND NOT TARGET ${full_name}) + if(${${tools_package_name}_FOUND}) + set(pkg_found_msg "") + string(APPEND pkg_found_msg + "the ${tools_package_name} package, but the package did not contain the tool. " + "Make sure that the host module ${tools_target} was built with all features " + "enabled (no explicitly disabled tools).") + else() + set(pkg_found_msg "") + string(APPEND pkg_found_msg + "the ${tools_package_name} package, but the package could not be found. " + "Make sure you have built and installed the host ${tools_target} module, " + "which will ensure the creation of the ${tools_package_name} package.") + endif() + message(FATAL_ERROR + "Failed to find the host tool \"${full_name}\". It is part of " + ${pkg_found_msg}) + endif() + + if(QT_WILL_BUILD_TOOLS) + message(STATUS "Tool '${full_name}' will be built from source.") + endif() + set(${out_var} "TRUE" PARENT_SCOPE) +endfunction() + +# This function adds an internal tool that should be compiled at configure time. +# TOOLS_TARGET +# Specifies the module this tool belongs to. The Qt6${TOOLS_TARGET}Tools module +# will then expose targets for this tool. Ignored if NO_INSTALL is set. +function(qt_internal_add_configure_time_tool target_name) + set(one_value_args INSTALL_DIRECTORY TOOLS_TARGET CONFIG) + set(multi_value_args) + set(option_args NO_INSTALL) + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" "${one_value_args}" "${multi_value_args}") + + qt_internal_find_tool(will_build_tools ${target_name} "${arg_TOOLS_TARGET}") + if(NOT will_build_tools) + return() + endif() + + qt_tool_target_to_name(name ${target_name}) + set(extra_args "") + if(arg_NO_INSTALL OR NOT arg_TOOLS_TARGET) + list(APPEND extra_args "NO_INSTALL") + else() + set(install_dir "${INSTALL_BINDIR}") + if(arg_INSTALL_DIRECTORY) + set(install_dir "${arg_INSTALL_DIRECTORY}") + endif() + set(extra_args "INSTALL_DIRECTORY" "${install_dir}") + endif() + + if(arg_CONFIG) + set(tool_config "${arg_CONFIG}") + elseif(QT_MULTI_CONFIG_FIRST_CONFIG) + set(tool_config "${arg_QT_MULTI_CONFIG_FIRST_CONFIG}") + else() + set(tool_config "${CMAKE_BUILD_TYPE}") + endif() + + string(REPLACE "\\\;" "\\\\\\\;" unparsed_arguments "${arg_UNPARSED_ARGUMENTS}") + qt_internal_add_configure_time_executable(${target_name} + OUTPUT_NAME ${name} + CONFIG ${tool_config} + ${extra_args} + ${unparsed_arguments} + ) + + if(TARGET host_tools) + add_dependencies(host_tools "${target_name}_build") + endif() + + if(NOT arg_NO_INSTALL AND arg_TOOLS_TARGET) + qt_internal_add_targets_to_additional_targets_export_file( + TARGETS ${target_name} + TARGET_EXPORT_NAMES ${QT_CMAKE_EXPORT_NAMESPACE}::${name} + EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${arg_TOOLS_TARGET}Tools + ) + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtToolchainHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtToolchainHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b9410266e6ef13dca1876feb222d3c6f6c6cea5b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtToolchainHelpers.cmake @@ -0,0 +1,324 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Create a CMake toolchain file for convenient configuration of both internal Qt builds +# as well as CMake application projects. +# Expects various global variables to be set. +function(qt_internal_create_toolchain_file) + if(CMAKE_TOOLCHAIN_FILE) + file(TO_CMAKE_PATH "${CMAKE_TOOLCHAIN_FILE}" __qt_chainload_toolchain_file) + set(init_original_toolchain_file + " +set(__qt_initially_configured_toolchain_file \"${__qt_chainload_toolchain_file}\") +set(__qt_chainload_toolchain_file \"\${__qt_initially_configured_toolchain_file}\") +") + endif() + + if(VCPKG_CHAINLOAD_TOOLCHAIN_FILE) + file(TO_CMAKE_PATH "${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}" VCPKG_CHAINLOAD_TOOLCHAIN_FILE) + list(APPEND init_vcpkg + "set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE \"${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}\")") + endif() + + if(VCPKG_TARGET_TRIPLET) + list(APPEND init_vcpkg + "set(VCPKG_TARGET_TRIPLET \"${VCPKG_TARGET_TRIPLET}\" CACHE STRING \"\")") + endif() + + if(CMAKE_SYSTEM_NAME STREQUAL "Windows" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64" AND CMAKE_SYSTEM_VERSION STREQUAL "10") + list(APPEND init_platform "set(CMAKE_SYSTEM_NAME Windows CACHE STRING \"\")") + list(APPEND init_platform "set(CMAKE_SYSTEM_VERSION 10 CACHE STRING \"\")") + list(APPEND init_platform "set(CMAKE_SYSTEM_PROCESSOR arm64 CACHE STRING \"\")") + endif() + + if(QT_QMAKE_TARGET_MKSPEC) + list(APPEND init_platform + "if(NOT QT_QMAKE_TARGET_MKSPEC)" + " set(QT_QMAKE_TARGET_MKSPEC ${QT_QMAKE_TARGET_MKSPEC} CACHE STRING \"\")" + "endif()" + ) + endif() + + if("${QT_QMAKE_TARGET_MKSPEC}" STREQUAL "linux-g++-32" AND NOT QT_NO_AUTO_DETECT_LINUX_X86) + set(__qt_toolchain_common_flags_init "-m32") + + if(NOT QT_NO_OVERRIDE_LANG_FLAGS_INIT) + list(APPEND init_platform + "if(NOT QT_NO_OVERRIDE_LANG_FLAGS_INIT)") + + list(APPEND init_platform + " set(__qt_toolchain_common_flags_init \"-m32\")") + list(APPEND init_platform + " set(CMAKE_C_FLAGS_INIT \"\${__qt_toolchain_common_flags_init}\")") + list(APPEND init_platform + " set(CMAKE_CXX_FLAGS_INIT \"\${__qt_toolchain_common_flags_init}\")") + list(APPEND init_platform + " set(CMAKE_ASM_FLAGS_INIT \"\${__qt_toolchain_common_flags_init}\")") + + list(APPEND init_platform "endif()") + endif() + + # Ubuntu-specific paths are used below. + # See comments of qt_auto_detect_linux_x86() for details. + if(NOT QT_NO_OVERRIDE_CMAKE_IGNORE_PATH) + list(APPEND init_platform + "if(NOT QT_NO_OVERRIDE_CMAKE_IGNORE_PATH)") + + get_property(linux_x86_ignore_path GLOBAL PROPERTY _qt_internal_linux_x86_ignore_path) + + string(REPLACE ";" "LITERAL_SEMICOLON" + linux_x86_ignore_path "${linux_x86_ignore_path}") + + list(APPEND init_platform + " set(CMAKE_IGNORE_PATH \"${linux_x86_ignore_path}\")") + + list(APPEND init_platform "endif()") + endif() + + if(NOT QT_NO_OVERRIDE_PKG_CONFIG_LIBDIR) + list(APPEND init_platform + "if(NOT QT_NO_OVERRIDE_PKG_CONFIG_LIBDIR)") + + get_property(pc_config_libdir GLOBAL PROPERTY _qt_internal_linux_x86_pc_config_libdir) + + list(APPEND init_platform + " set(ENV{PKG_CONFIG_LIBDIR} \"${pc_config_libdir}\")") + list(APPEND init_platform + " set(ENV{PKG_CONFIG_DIR} \"\")") + + list(APPEND init_platform "endif()") + endif() + endif() + + # By default we don't want to allow mixing compilers for building different repositories, so we + # embed the initially chosen compilers into the toolchain. + # This is because on Windows compilers aren't easily mixed. + # We want to avoid that qtbase is built using cl.exe for example, and then for another repo + # gcc is picked up from %PATH%. + # The same goes when using a custom compiler on other platforms, such as ICC. + # + # There are a few exceptions though. + # + # When crosscompiling using Boot2Qt, the environment setup shell script sets up the CXX env var, + # which is used by CMake to determine the initial compiler that should be used. + # Unfortunately, the CXX env var contains not only the compiler name, but also a few required + # arch-specific compiler flags. This means that when building qtsvg, if the Qt created toolchain + # file sets the CMAKE_CXX_COMPILER variable, the CXX env var is ignored and thus the extra + # arch specific compiler flags are not picked up anymore, leading to a configuration failure. + # + # To avoid this issue, disable automatic embedding of the compilers into the qt toolchain when + # cross compiling. This is merely a heuristic, becacuse we don't have enough data to decide + # when to do it or not. + # For example on Linux one might want to allow mixing of clang and gcc (maybe). + # + # To allow such use cases when the default is wrong, one can provide a flag to explicitly opt-in + # or opt-out of the compiler embedding into the Qt toolchain. + # + # Passing -DQT_EMBED_TOOLCHAIN_COMPILER=ON will force embedding of the compilers. + # Passing -DQT_EMBED_TOOLCHAIN_COMPILER=OFF will disable embedding of the compilers. + set(__qt_embed_toolchain_compilers TRUE) + if(CMAKE_CROSSCOMPILING) + set(__qt_embed_toolchain_compilers FALSE) + endif() + if(DEFINED QT_EMBED_TOOLCHAIN_COMPILER) + if(QT_EMBED_TOOLCHAIN_COMPILER) + set(__qt_embed_toolchain_compilers TRUE) + else() + set(__qt_embed_toolchain_compilers FALSE) + endif() + endif() + if(__qt_embed_toolchain_compilers) + list(APPEND init_platform " +set(__qt_initial_c_compiler \"${CMAKE_C_COMPILER}\") +set(__qt_initial_cxx_compiler \"${CMAKE_CXX_COMPILER}\") +if(QT_USE_ORIGINAL_COMPILER AND NOT DEFINED CMAKE_C_COMPILER + AND EXISTS \"\${__qt_initial_c_compiler}\") + set(CMAKE_C_COMPILER \"\${__qt_initial_c_compiler}\" CACHE STRING \"\") +endif() +if(QT_USE_ORIGINAL_COMPILER AND NOT DEFINED CMAKE_CXX_COMPILER + AND EXISTS \"\${__qt_initial_cxx_compiler}\") + set(CMAKE_CXX_COMPILER \"\${__qt_initial_cxx_compiler}\" CACHE STRING \"\") +endif()") + endif() + + unset(init_additional_used_variables) + if(APPLE) + + # For an iOS simulator_and_device build, we should not explicitly set the sysroot, + # but let CMake do it's universal build magic to use one sysroot / sdk per-arch. + # For a single arch / sysroot build, try to use the initially configured sysroot + # by name. + # + # Also allow to opt out just in case. + # + # TODO: Figure out if the same should apply to universal macOS builds. + + # We want to preserve the sysroot as an SDK name, instead of the path + # that CMake transforms it into in Darwin-initialize.cmake, so we pick + # it out from the cache, where it hasn't been touched by CMake. + set(cmake_sysroot_name "$CACHE{CMAKE_OSX_SYSROOT}") + + list(LENGTH CMAKE_OSX_ARCHITECTURES _qt_osx_architectures_count) + if(cmake_sysroot_name AND NOT _qt_osx_architectures_count GREATER 1 AND UIKIT) + list(APPEND init_platform " +if(NOT DEFINED CMAKE_OSX_SYSROOT) + set(CMAKE_OSX_SYSROOT \"${cmake_sysroot_name}\" CACHE STRING \"\") +endif()") + endif() + + if(CMAKE_OSX_DEPLOYMENT_TARGET) + list(APPEND init_platform + "set(CMAKE_OSX_DEPLOYMENT_TARGET \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" CACHE STRING \"\")") + endif() + + # Save list of initial architectures Qt was configured with. + set(_qt_osx_architectures_escaped "${CMAKE_OSX_ARCHITECTURES}") + string(REPLACE ";" "LITERAL_SEMICOLON" + _qt_osx_architectures_escaped "${_qt_osx_architectures_escaped}") + set(docstring "List of architectures Qt was built with") + list(APPEND init_platform + "set(QT_OSX_ARCHITECTURES \"${_qt_osx_architectures_escaped}\" CACHE STRING \"${docstring}\")") + list(APPEND init_platform "") + + # When building another qt repo, ensure the same list of architectures is used by default. + # Detection of a qt repo is done by checking for QT_REPO_MODULE_VERSION which is set in + # the repo's .cmake.conf file. + # Most standalone tests will also be built with multiple architectures. + # Certain tests will be built with a single arch only (like tests/auto/cmake) to avoid + # issues in the CI when trying to build them on VMs that do not have a universal macOS + # SDK. + list(APPEND init_platform + "# Only build multiple architectures when building Qt itself. Can be explicitly enabled or disabled.") + list(APPEND init_platform "if((QT_REPO_MODULE_VERSION AND NOT QT_FORCE_SINGLE_QT_OSX_ARCHITECTURE) OR QT_FORCE_ALL_QT_OSX_ARCHITECTURES)") + list(APPEND init_platform " set(__qt_toolchain_building_qt_repo TRUE)") + list(APPEND init_platform " set(CMAKE_OSX_ARCHITECTURES \"\${QT_OSX_ARCHITECTURES}\" CACHE STRING \"\")") + list(APPEND init_platform "endif()") + list(APPEND init_platform "") + + # For macOS user projects, the common case is to default to not specifying any architecture. + # This means CMake will not pass an -arch flag to the compiler and the compiler will + # choose the default architecture to build for. + # On Apple Silicon, CMake will introspect whether it's running under Rosetta and will + # pass the detected architecture (x86_64 under Rosetta or arm64 natively) to the compiler. + # This is line with default CMake behavior for user projects. + # If Qt was cross-compiled to arm64 from an x86_64 host machine, or vice versa, we need + # to continue using the same architecture for the user project, otherwise the CMake default + # might be incorrect depending on which host arch the user project is built on. + if(NOT UIKIT) + list(LENGTH CMAKE_OSX_ARCHITECTURES arch_count) + if(arch_count EQUAL 1 AND CMAKE_CROSSCOMPILING AND CMAKE_SYSTEM_NAME STREQUAL "Darwin") + list(APPEND init_platform +"if(NOT __qt_toolchain_building_qt_repo AND NOT QT_NO_SET_OSX_ARCHITECTURES)" +" set(CMAKE_OSX_ARCHITECTURES \"${CMAKE_OSX_ARCHITECTURES}\" CACHE STRING \"\")" +" set(CMAKE_SYSTEM_NAME \"${CMAKE_SYSTEM_NAME}\" CACHE STRING \"\")" +"endif()" + ) + endif() + endif() + + # For iOS, we provide a bit more convenience. + # When the user project is built using the Xcode generator, we only specify the architecture + # if this is a single architecture Qt for iOS build. If we wouldn't, invoking just + # xcodebuild from the command line would try to build with the wrong architecture. Also + # provide an opt-out option just in case. + # + # For a multi-architecture build (so simulator_and_device) we set an explicit + # architecture for simulator only, via _qt_internal_set_ios_simulator_arch. + # + # When using the Ninja generator, specify the first architecture from QT_OSX_ARCHITECTURES + # (even with a simulator_and_device Qt build). This ensures that the default configuration + # at least tries to build something. + if(UIKIT) + qt_internal_get_first_osx_arch(osx_first_arch) + list(APPEND init_platform +"if((NOT CMAKE_GENERATOR STREQUAL \"Xcode\" AND NOT __qt_toolchain_building_qt_repo) + OR (CMAKE_GENERATOR STREQUAL \"Xcode\" AND __qt_apple_sdk AND NOT QT_NO_SET_OSX_ARCHITECTURES))") + list(APPEND init_platform + " set(CMAKE_OSX_ARCHITECTURES \"${osx_first_arch}\" CACHE STRING \"\")") + list(APPEND init_platform "endif()") + list(APPEND init_platform "") + endif() + + if(UIKIT) + list(APPEND init_platform + "set(CMAKE_SYSTEM_NAME \"${CMAKE_SYSTEM_NAME}\" CACHE STRING \"\")") + endif() + elseif(ANDROID) + list(APPEND init_platform +"# Detect Android SDK/NDK from environment before loading the Android platform toolchain file." +"if(\"$\{ANDROID_SDK_ROOT}\" STREQUAL \"\" AND NOT \"\$ENV{ANDROID_SDK_ROOT}\" STREQUAL \"\")" +" set(ANDROID_SDK_ROOT \"\$ENV{ANDROID_SDK_ROOT}\" CACHE STRING \"Path to the Android SDK\")" +"endif()" +"if(\"$\{ANDROID_NDK_ROOT}\" STREQUAL \"\" AND NOT \"\$ENV{ANDROID_NDK_ROOT}\" STREQUAL \"\")" +" set(ANDROID_NDK_ROOT \"\$ENV{ANDROID_NDK_ROOT}\" CACHE STRING \"Path to the Android NDK\")" +"endif()" + ) + + foreach(var ANDROID_PLATFORM ANDROID_NATIVE_API_LEVEL ANDROID_STL + ANDROID_ABI ANDROID_SDK_ROOT ANDROID_NDK_ROOT) + list(APPEND init_additional_used_variables + "list(APPEND __qt_toolchain_used_variables ${var})") + endforeach() + + list(APPEND init_platform + "if(NOT DEFINED ANDROID_PLATFORM AND NOT DEFINED ANDROID_NATIVE_API_LEVEL)") + list(APPEND init_platform + " set(ANDROID_PLATFORM \"${ANDROID_PLATFORM}\" CACHE STRING \"\")") + list(APPEND init_platform "endif()") + list(APPEND init_platform "set(ANDROID_STL \"${ANDROID_STL}\" CACHE STRING \"\")") + list(APPEND init_platform "set(ANDROID_ABI \"${ANDROID_ABI}\" CACHE STRING \"\")") + list(APPEND init_platform "if (NOT DEFINED ANDROID_SDK_ROOT)") + file(TO_CMAKE_PATH "${ANDROID_SDK_ROOT}" __qt_android_sdk_root) + list(APPEND init_platform + " set(ANDROID_SDK_ROOT \"${__qt_android_sdk_root}\" CACHE STRING \"\")") + list(APPEND init_platform "endif()") + + list(APPEND init_platform "if(NOT \"$\{ANDROID_NDK_ROOT\}\" STREQUAL \"\")") + list(APPEND init_platform + " set(__qt_toolchain_file_candidate \"$\{ANDROID_NDK_ROOT\}/build/cmake/android.toolchain.cmake\")") + list(APPEND init_platform " if(EXISTS \"$\{__qt_toolchain_file_candidate\}\")") + list(APPEND init_platform + " message(STATUS \"Android toolchain file within NDK detected: $\{__qt_toolchain_file_candidate\}\")") + list(APPEND init_platform " set(__qt_chainload_toolchain_file \"$\{__qt_toolchain_file_candidate\}\")") + list(APPEND init_platform " else()") + list(APPEND init_platform + " message(FATAL_ERROR \"Cannot find the toolchain file '$\{__qt_toolchain_file_candidate\}'. \"") + list(APPEND init_platform + " \"Please specify the toolchain file with -DQT_CHAINLOAD_TOOLCHAIN_FILE=.\")") + list(APPEND init_platform " endif()") + list(APPEND init_platform "endif()") + elseif(EMSCRIPTEN) + list(APPEND init_platform +"include(\${CMAKE_CURRENT_LIST_DIR}/QtPublicWasmToolchainHelpers.cmake) +if(DEFINED ENV{EMSDK} AND NOT \"\$ENV{EMSDK}\" STREQUAL \"\") + __qt_internal_get_emroot_path_suffix_from_emsdk_env(__qt_toolchain_emroot_path) + __qt_internal_get_emscripten_cmake_toolchain_file_path_from_emsdk_env( + \"\${__qt_toolchain_emroot_path}\" _qt_candidate_emscripten_toolchain_path) + set(__qt_chainload_toolchain_file \"\${_qt_candidate_emscripten_toolchain_path}\") +endif() +") + list(APPEND init_post_chainload_toolchain " +if(NOT __qt_chainload_toolchain_file_included) + __qt_internal_show_error_no_emscripten_toolchain_file_found_when_using_qt() +endif() +") + endif() + + string(REPLACE ";" "\n" init_additional_used_variables + "${init_additional_used_variables}") + string(REPLACE ";" "\n" init_vcpkg "${init_vcpkg}") + + string(REPLACE ";" "\n" init_platform "${init_platform}") + string(REPLACE "LITERAL_SEMICOLON" ";" init_platform "${init_platform}") + + string(REPLACE ";" "\n" init_post_chainload_toolchain "${init_post_chainload_toolchain}") + string(REPLACE "LITERAL_SEMICOLON" ";" init_post_chainload_toolchain + "${init_post_chainload_toolchain}") + + qt_compute_relative_path_from_cmake_config_dir_to_prefix() + configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/cmake/qt.toolchain.cmake.in" + "${__GlobalConfig_build_dir}/qt.toolchain.cmake" @ONLY) + qt_install(FILES "${__GlobalConfig_build_dir}/qt.toolchain.cmake" + DESTINATION "${__GlobalConfig_install_dir}" COMPONENT Devel) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtUnityBuildHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtUnityBuildHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1cfdaced57cd2e949f990ef283b050abbc039329 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtUnityBuildHelpers.cmake @@ -0,0 +1,24 @@ +# Copyright (C) 2023 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Check whether no unity build is requested where it is disabled by default. +function(_qt_internal_validate_no_unity_build prefix) + if(${prefix}_NO_UNITY_BUILD OR ${prefix}_NO_UNITY_BUILD_SOURCES) + message(WARNING + "Unity build is disabled by default for this target, and its sources. " + "You may remove the NO_UNITY_BUILD and/or NO_UNITY_BUILD_SOURCES arguments.") + endif() +endfunction() + +function(qt_update_ignore_unity_build_sources target sources) + if(sources) + # We need to add the TARGET_DIRECTORY scope for targets that have qt_internal_extend_target + # calls in different subdirectories, like in qtgraphs. + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${target}) + endif() + set_source_files_properties(${sources} ${scope_args} + PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON) + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtVersionlessAliasTargets.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtVersionlessAliasTargets.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..5d68f6e7b3eb18e3e1cf17915d24e5c1f022ff07 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtVersionlessAliasTargets.cmake.in @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "@versionless_targets@") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" @INSTALL_CMAKE_NAMESPACE@) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtVersionlessTargets.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtVersionlessTargets.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..61fe15f0d0df657f78381946fd544eb12727a215 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtVersionlessTargets.cmake.in @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "@versionless_targets@") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" @INSTALL_CMAKE_NAMESPACE@) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWasmHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWasmHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..51e4065ca17b12470625fbbcf2768b95a417dc11 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWasmHelpers.cmake @@ -0,0 +1,117 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +# WARNING must keep in sync with wasm-emscripten/qmake.conf! +function (qt_internal_setup_wasm_target_properties wasmTarget) + + target_link_options("${wasmTarget}" INTERFACE + "SHELL:-s MAX_WEBGL_VERSION=2" + "SHELL:-s FETCH=1" + "SHELL:-s WASM_BIGINT=1" + "SHELL:-s STACK_SIZE=5MB") + + ## wasm64 + if (WASM64) + target_compile_options("${wasmTarget}" INTERFACE "SHELL:-s MEMORY64=1" ) + target_link_options("${wasmTarget}" INTERFACE "SHELL:-s MEMORY64=1" -mwasm64) + endif() + + #simd + if (QT_FEATURE_wasm_simd128) + target_compile_options("${wasmTarget}" INTERFACE -msimd128) + endif() + if (QT_FEATURE_sse2) + target_compile_options("${wasmTarget}" INTERFACE -O2 -msimd128 -msse -msse2) + endif() + + # wasm exceptions + if (QT_FEATURE_wasm_exceptions) + target_compile_options("${wasmTarget}" INTERFACE -fwasm-exceptions) + target_link_options("${wasmTarget}" INTERFACE -fwasm-exceptions) + endif() + + if (QT_FEATURE_thread) + target_compile_options("${wasmTarget}" INTERFACE "SHELL:-pthread") + target_link_options("${wasmTarget}" INTERFACE "SHELL:-pthread") + endif() + + target_link_options("${wasmTarget}" INTERFACE "SHELL:-s ALLOW_MEMORY_GROWTH") + + # debug add_compile_options + if ("QT_WASM_SOURCE_MAP=1" IN_LIST QT_QMAKE_DEVICE_OPTIONS) + set(WASM_SOURCE_MAP_BASE "http://localhost:8000/") + + if(DEFINED QT_WASM_SOURCE_MAP_BASE) + set(WASM_SOURCE_MAP_BASE "${QT_WASM_SOURCE_MAP_BASE}") + endif() + + # Pass --source-map-base on the linker line. This informs the + # browser where to find the source files when debugging. + # -g4 to make source maps for debugging + target_link_options("${wasmTarget}" INTERFACE "-gsource-map" "--source-map-base" "${WASM_SOURCE_MAP_BASE}") + + endif() + + # a few good defaults to make console more verbose while debugging + target_link_options("${wasmTarget}" INTERFACE $<$: + --profiling-funcs>) + + # target_link_options("${wasmTarget}" INTERFACE "SHELL:-s LIBRARY_DEBUG=1") # print out library calls, verbose + # target_link_options("${wasmTarget}" INTERFACE "SHELL:-s SYSCALL_DEBUG=1") # print out sys calls, verbose + # target_link_options("${wasmTarget}" INTERFACE "SHELL:-s FS_LOG=1") # print out filesystem ops, verbose + # target_link_options("${wasmTarget}" INTERFACE "SHELL:-s SOCKET_DEBUG") # print out socket,network data transfer + + if ("QT_EMSCRIPTEN_ASYNCIFY=1" IN_LIST QT_QMAKE_DEVICE_OPTIONS) + # Emscripten recommends building with optimizations when using asyncify + # in order to reduce wasm file size, and may also generate broken wasm + # (with "wasm validation error: too many locals" type errors) if optimizations + # are omitted. Enable optimizations also for debug builds. + set(QT_CFLAGS_OPTIMIZE_DEBUG "-Os" CACHE STRING INTERNAL FORCE) + set(QT_FEATURE_optimize_debug ON CACHE BOOL INTERNAL FORCE) + + target_link_options("${wasmTarget}" INTERFACE "SHELL:-s ASYNCIFY" "-Os") + target_compile_definitions("${wasmTarget}" INTERFACE QT_HAVE_EMSCRIPTEN_ASYNCIFY) + endif() + + # Set ASYNCIFY_IMPORTS unconditionally in order to support enabling asyncify at link time. + target_link_options("${wasmTarget}" INTERFACE "SHELL:-sASYNCIFY_IMPORTS=qt_asyncify_suspend_js,qt_asyncify_resume_js") + + if(QT_FEATURE_shared) + + set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS TRUE) + + set(side_modules + MODULE_LIBRARY SHARED_LIBRARY) + set(enable_side_module_if_needed + "$<$,${side_modules}>:SHELL:-s SIDE_MODULE=1>") + set(enable_main_module_if_needed + "$<$,EXECUTABLE>:SHELL:-s MAIN_MODULE=1>") + set(set_shared_module_type_if_needed + "${enable_side_module_if_needed}" + "${enable_main_module_if_needed}" + ) + + # Add Qt libdir to linker library paths + set(qt_lib_location + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_LIBDIR}") + target_link_options("${wasmTarget}" INTERFACE + "$<$,EXECUTABLE>:SHELL:" -L${qt_lib_location}/>) + + target_compile_options("${wasmTarget}" INTERFACE "${set_shared_module_type_if_needed}") + target_link_options("${wasmTarget}" INTERFACE "${set_shared_module_type_if_needed}") + + else() + target_link_options("${wasmTarget}" INTERFACE "SHELL:-s ERROR_ON_UNDEFINED_SYMBOLS=1") + endif() + + # Suppress warnings for known issues for developer builds + if(FEATURE_developer_build) + target_link_options("${wasmTarget}" INTERFACE "SHELL:-Wno-pthreads-mem-growth") + endif() + +endfunction() + +function(qt_internal_wasm_add_finalizers target) + qt_add_list_file_finalizer(_qt_internal_finalize_wasm_app ${target}) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWrapperScriptHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWrapperScriptHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..21e57c592d8f2bf6375b9c99633e107bb444a638 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWrapperScriptHelpers.cmake @@ -0,0 +1,343 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Creates and installs the following wrapper CMake scripts: +# qt-make +# qt-cmake-private +# qt-configure-module +# qt-cmake-private-install +# And other helper scripts. +function(qt_internal_create_wrapper_scripts) + # Provide a convenience cmake wrapper. + + if(QT_GENERATE_WRAPPER_SCRIPTS_FOR_ALL_HOSTS) + set(generate_unix TRUE) + set(generate_non_unix TRUE) + elseif(CMAKE_HOST_UNIX) + set(generate_unix TRUE) + else() + set(generate_non_unix TRUE) + endif() + + set(extra_qt_cmake_code "") + if(generate_unix) + + if(UIKIT) + set(extra_qt_cmake_code [=[ +# Specify Xcode as the default generator by assigning it to the CMAKE_GENERATOR env var. +# An explicit -G or -D CMAKE_GENERATOR given on the command line will still take precedence. +export CMAKE_GENERATOR=Xcode +]=]) + endif() + + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake.in" + "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake" @ONLY + NEWLINE_STYLE LF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake" + DESTINATION "${INSTALL_BINDIR}") + endif() + if(generate_non_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake.bat.in" + "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake.bat" @ONLY + NEWLINE_STYLE CRLF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake.bat" + DESTINATION "${INSTALL_BINDIR}") + endif() + + if(generate_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-create.in" + "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create" @ONLY + NEWLINE_STYLE LF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create" + DESTINATION "${INSTALL_BINDIR}") + endif() + if(generate_non_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-create.bat.in" + "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create.bat" @ONLY + NEWLINE_STYLE CRLF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create.bat" + DESTINATION "${INSTALL_BINDIR}") + endif() + + # Reset the contents for the next script. + set(extra_qt_cmake_code "") + + # Provide a private convenience wrapper with options that should not be propagated via the + # public qt-cmake wrapper e.g. CMAKE_GENERATOR. + # These options can not be set in a toolchain file, but only on the command line. + # These options should not be in the public wrapper, because a consumer of Qt might want to + # build their CMake app with the Unix Makefiles generator, while Qt should be built with the + # Ninja generator. In a similar vein, we do want to use the same compiler for all Qt modules, + # but not for user applications. + # The private wrapper is more convenient for building Qt itself, because a developer doesn't + # need to specify the same options for each qt module built. + set(__qt_cmake_extra "-G\"${CMAKE_GENERATOR}\" -DQT_USE_ORIGINAL_COMPILER=ON") + if(generate_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake.in" + "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/qt-cmake-private" @ONLY + NEWLINE_STYLE LF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/qt-cmake-private" + DESTINATION "${INSTALL_LIBEXECDIR}") + endif() + if(generate_non_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake.bat.in" + "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-private.bat" @ONLY + NEWLINE_STYLE CRLF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-private.bat" + DESTINATION "${INSTALL_BINDIR}") + endif() + unset(__qt_cmake_extra) + + # Provide a script to configure Qt modules. + if(QT_WILL_INSTALL) + set(__relative_path_to_cmake_scripts_dir + "${__GlobalConfig_relative_path_from_bin_dir_to_cmake_config_dir}") + else() + file(RELATIVE_PATH __relative_path_to_cmake_scripts_dir + "${__qt_bin_dir_absolute}" "${CMAKE_CURRENT_LIST_DIR}") + endif() + file(TO_NATIVE_PATH "${__relative_path_to_cmake_scripts_dir}" + __relative_path_to_cmake_scripts_dir) + if(generate_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-configure-module.in" + "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-configure-module" @ONLY + NEWLINE_STYLE LF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-configure-module" + DESTINATION "${INSTALL_BINDIR}") + endif() + if(generate_non_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-configure-module.bat.in" + "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-configure-module.bat" @ONLY + NEWLINE_STYLE CRLF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-configure-module.bat" + DESTINATION "${INSTALL_BINDIR}") + endif() + unset(__relative_path_to_cmake_scripts_dir) + + # Provide a private convenience wrapper to configure and build one or more standalone tests. + # Calling CMake directly on a Qt test project won't work because the project does not call + # find_package(Qt...) to get all dependencies like examples do. + # Instead a template CMakeLists.txt project is used which sets up all the necessary private bits + # and then calls add_subdirectory on the provided project path. + set(__qt_cmake_standalone_test_name "qt-cmake-standalone-test") + if(generate_unix) + set(__qt_cmake_standalone_test_libexec_path + "${INSTALL_LIBEXECDIR}/${__qt_cmake_standalone_test_name}") + endif() + if(generate_non_unix) + set(__qt_cmake_standalone_test_bin_path + "${INSTALL_BINDIR}/${__qt_cmake_standalone_test_name}") + endif() + + # Configuring a standalone test on iOS should use the Xcode generator, but qt-cmake-private uses + # the generator that was used to build Qt itself (e.g. Ninja). + # Use qt-cmake instead, which does use the Xcode generator since Qt 6.2.5, 6.3.1, 6.4. + if(IOS) + set(__qt_cmake_private_path + "${QT_STAGING_PREFIX}/${INSTALL_BINDIR}/qt-cmake") + else() + if(generate_unix) + set(__qt_cmake_private_path + "${QT_STAGING_PREFIX}/${INSTALL_LIBEXECDIR}/qt-cmake-private") + endif() + if(generate_non_unix) + set(__qt_cmake_private_path + "${QT_STAGING_PREFIX}/${INSTALL_BINDIR}/qt-cmake-private") + endif() + endif() + + set(__qt_cmake_standalone_test_path + "${__build_internals_install_dir}/${__build_internals_standalone_test_template_dir}") + + if(QT_WILL_INSTALL) + # Need to prepend the staging prefix when doing prefix builds, because the build internals + # install dir is relative in that case.. + qt_path_join(__qt_cmake_standalone_test_path + "${QT_STAGING_PREFIX}" + "${__qt_cmake_standalone_test_path}") + endif() + + if(generate_unix) + get_filename_component(rel_base_path + "${QT_STAGING_PREFIX}/${__qt_cmake_standalone_test_libexec_path}" + DIRECTORY) + + file(RELATIVE_PATH __qt_cmake_private_relpath "${rel_base_path}" + "${__qt_cmake_private_path}") + file(RELATIVE_PATH __qt_cmake_standalone_test_relpath "${rel_base_path}" + "${__qt_cmake_standalone_test_path}") + + set(__qt_cmake_standalone_test_os_prelude "#!/bin/sh") + set(__qt_cmake_standalone_test_script_relpath "SCRIPT_DIR=`dirname $0`") + string(PREPEND __qt_cmake_private_relpath "exec $SCRIPT_DIR/") + string(PREPEND __qt_cmake_standalone_test_relpath "$SCRIPT_DIR/") + set(__qt_cmake_standalone_passed_args "\"$@\" -DPWD=\"$PWD\"") + + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-standalone-test.in" + "${QT_BUILD_DIR}/${__qt_cmake_standalone_test_libexec_path}" + NEWLINE_STYLE LF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${__qt_cmake_standalone_test_libexec_path}" + DESTINATION "${INSTALL_LIBEXECDIR}") + endif() + if(generate_non_unix) + get_filename_component(rel_base_path + "${QT_STAGING_PREFIX}/${__qt_cmake_standalone_test_bin_path}" + DIRECTORY) + + file(RELATIVE_PATH __qt_cmake_private_relpath "${rel_base_path}" + "${__qt_cmake_private_path}") + file(RELATIVE_PATH __qt_cmake_standalone_test_relpath "${rel_base_path}" + "${__qt_cmake_standalone_test_path}") + + set(__qt_cmake_standalone_test_os_prelude "@echo off") + set(__qt_cmake_standalone_test_script_relpath "set SCRIPT_DIR=%~dp0") + string(APPEND __qt_cmake_standalone_test_bin_path ".bat") + string(APPEND __qt_cmake_private_relpath ".bat") + string(PREPEND __qt_cmake_private_relpath "%SCRIPT_DIR%") + string(PREPEND __qt_cmake_standalone_test_relpath "%SCRIPT_DIR%") + set(__qt_cmake_standalone_passed_args "%* -DPWD=\"%CD%\"") + + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-standalone-test.in" + "${QT_BUILD_DIR}/${__qt_cmake_standalone_test_bin_path}" + NEWLINE_STYLE CRLF) + qt_install(PROGRAMS "${QT_BUILD_DIR}/${__qt_cmake_standalone_test_bin_path}" + DESTINATION "${INSTALL_BINDIR}") + endif() + + # Create an installation script that the CI can use to handle installation for both + # single and multiple configurations. + set(__qt_cmake_install_script_name "qt-cmake-private-install.cmake") + if(CMAKE_CONFIGURATION_TYPES) + set(__qt_configured_configs "${CMAKE_CONFIGURATION_TYPES}") + elseif(CMAKE_BUILD_TYPE) + set(__qt_configured_configs "${CMAKE_BUILD_TYPE}") + endif() + + if( + # Skip stripping pure debug builds so it's easier to debug issues in CI VMs. + (NOT QT_FEATURE_debug_and_release + AND QT_FEATURE_debug + AND NOT QT_FEATURE_separate_debug_info) + + # Skip stripping on MSVC because ${CMAKE_STRIP} might contain a MinGW strip binary + # and the breaks the linker version flag embedded in the binary and causes Qt Creator + # to mis-identify the Kit ABI. + OR MSVC + ) + set(__qt_skip_strip_installed_artifacts TRUE) + else() + set(__qt_skip_strip_installed_artifacts FALSE) + endif() + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/${__qt_cmake_install_script_name}.in" + "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${__qt_cmake_install_script_name}" @ONLY) + qt_install(FILES "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${__qt_cmake_install_script_name}" + DESTINATION "${INSTALL_LIBEXECDIR}") + + qt_internal_create_qt_configure_part_wrapper_script("STANDALONE_TESTS") + qt_internal_create_qt_configure_part_wrapper_script("STANDALONE_EXAMPLES") + qt_internal_create_qt_configure_redo_script() + + if(NOT CMAKE_CROSSCOMPILING) + qt_internal_create_qt_android_runner_wrapper_script() + endif() +endfunction() + +function(qt_internal_create_qt_configure_part_wrapper_script component) + if(QT_GENERATE_WRAPPER_SCRIPTS_FOR_ALL_HOSTS) + set(generate_unix TRUE) + set(generate_non_unix TRUE) + elseif(CMAKE_HOST_UNIX) + set(generate_unix TRUE) + else() + set(generate_non_unix TRUE) + endif() + + # Create a private wrapper script to configure and build all standalone tests / examples. + # + # The script uses qt-cmake instead of qt-cmake-private on purpose. That's to ensure we build + # only one configuration of tests (e.g RelWithDebInfo only) when Qt is configured with more + # than one configuration (RelWithDebInfo;Debug). + # Meant to be used by our CI instructions. + # + # The script takes a path to the repo for which the standalone tests / examples will be + # configured. + + if(component STREQUAL "STANDALONE_TESTS") + set(script_name "qt-internal-configure-tests") + set(script_passed_args "-DQT_BUILD_STANDALONE_TESTS=ON -DQT_BUILD_EXAMPLES=OFF") + elseif(component STREQUAL "STANDALONE_EXAMPLES") + set(script_name "qt-internal-configure-examples") + set(script_passed_args "-DQT_BUILD_STANDALONE_EXAMPLES=ON -DQT_BUILD_TESTS=OFF") + else() + message(FATAL_ERROR "Invalid component type: ${component}") + endif() + + string(APPEND script_passed_args " -DQT_USE_ORIGINAL_COMPILER=ON") + + file(RELATIVE_PATH relative_path_from_libexec_dir_to_bin_dir + ${__qt_libexec_dir_absolute} + ${__qt_bin_dir_absolute}) + file(TO_NATIVE_PATH "${relative_path_from_libexec_dir_to_bin_dir}" + relative_path_from_libexec_dir_to_bin_dir) + + if(generate_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/libexec/${script_name}.in" + "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${script_name}" @ONLY + NEWLINE_STYLE LF) + + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/${script_name}" + DESTINATION "${INSTALL_LIBEXECDIR}") + endif() + if(generate_non_unix) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/libexec/${script_name}.bat.in" + "${QT_BUILD_DIR}/${INSTALL_BINDIR}/${script_name}.bat" @ONLY + NEWLINE_STYLE CRLF) + + qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/${script_name}.bat" + DESTINATION "${INSTALL_BINDIR}") + endif() +endfunction() + +# Create a shell wrapper script to reconfigure Qt with the original configure arguments and +# any additional ones passed. +# +# Removes CMakeCache.txt and friends, either manually, or using CMake's --fresh. +# +# The script is created in the root of the build dir and is called config.redo +# It has the same contents as the 'config.status' script we created in qt 5. +function(qt_internal_create_qt_configure_redo_script) + set(input_script_name "qt-internal-config.redo") + set(input_script_path "${CMAKE_CURRENT_SOURCE_DIR}/libexec/${input_script_name}") + + # We don't use QT_BUILD_DIR because we want the file in the root of the build dir in a top-level + # build. + set(output_script_name "config.redo") + set(output_path "${CMAKE_BINARY_DIR}/${output_script_name}") + + if(QT_SUPERBUILD) + set(configure_script_path "${Qt_SOURCE_DIR}") + else() + set(configure_script_path "${QtBase_SOURCE_DIR}") + endif() + string(APPEND configure_script_path "/configure") + + # Used in the file contents. + file(TO_NATIVE_PATH "${configure_script_path}" configure_path) + + if(CMAKE_HOST_UNIX) + string(APPEND input_script_path ".in") + set(newline_style "LF") + else() + string(APPEND input_script_path ".bat.in") + string(APPEND output_path ".bat") + set(newline_style "CRLF") + endif() + + configure_file("${input_script_path}" "${output_path}" @ONLY NEWLINE_STYLE ${newline_style}) +endfunction() + +function(qt_internal_create_qt_android_runner_wrapper_script) + qt_path_join(android_runner_destination "${QT_INSTALL_DIR}" "${INSTALL_LIBEXECDIR}") + qt_path_join(android_runner "${CMAKE_CURRENT_SOURCE_DIR}" "libexec" "qt-android-runner.py") + qt_copy_or_install(PROGRAMS "${android_runner}" DESTINATION "${android_runner_destination}") +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWriteArgsFile.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWriteArgsFile.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3876277e777c4f61d2f1497433a8675e3431f8c3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/QtWriteArgsFile.cmake @@ -0,0 +1,92 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# This script writes its arguments to the file determined by OUT_FILE. +# Each argument appears on a separate line. +# This is used for writing the config.opt file. +# +# This script takes the following arguments: +# IN_FILE: The input file. The whole command line as one string, or one argument per line. +# REDO_FILE: A file containing extra commands to be joined with IN_FILE. +# OUT_FILE: The output file. One argument per line. +# SKIP_ARGS: Number of arguments to skip from the front of the arguments list. +# IGNORE_ARGS: List of arguments to be ignored, i.e. that are not written. +# +# If the REDO_FILE is given, its parameters will be merged with IN_FILE parameters +# and be written into the OUT_FILE. + +cmake_minimum_required(VERSION 3.16) + +# Read arguments from IN_FILE and separate them. +file(READ "${IN_FILE}" raw_args) +# To catch cases where the path ends with an `\`, e.g., `-prefix "C:\Path\"` +string(REPLACE "\\\"" "\"" raw_args "${raw_args}") +string(REPLACE ";" "[[;]]" raw_args "${raw_args}") + +separate_arguments(args NATIVE_COMMAND "${raw_args}") + +string(REPLACE "\;" ";" args "${args}") +string(REPLACE "[[;]]" "\;" args "${args}") + +if(DEFINED REDO_FILE) + file(READ "${REDO_FILE}" raw_redo_args) + separate_arguments(redo_args NATIVE_COMMAND "${raw_redo_args}") + + if(args) + list(FIND args "--" args_ddash_loc) + list(FIND redo_args "--" redo_ddash_loc) + if("${redo_ddash_loc}" STREQUAL "-1") + if("${args_ddash_loc}" STREQUAL "-1") + list(LENGTH args args_ddash_loc) + endif() + # Avoid adding an empty line for an empty -redo + if(NOT "${redo_args}" STREQUAL "") + list(INSERT args ${args_ddash_loc} "${redo_args}") + endif() + else() + # Handling redo's configure options + list(SUBLIST redo_args 0 ${redo_ddash_loc} redo_config_args) + if(redo_config_args) + if("${args_ddash_loc}" STREQUAL "-1") + list(APPEND args "${redo_config_args}") + else() + list(INSERT args ${args_ddash_loc} "${redo_config_args}") + endif() + endif() + + # Handling redo's CMake options + list(LENGTH redo_args redo_args_len) + math(EXPR redo_ddash_loc "${redo_ddash_loc} + 1") + # Catch an unlikely case of -redo being called with an empty --, ie., `-redo --` + if(NOT ${redo_ddash_loc} STREQUAL ${redo_args_len}) + list(SUBLIST redo_args ${redo_ddash_loc} -1 redo_cmake_args) + endif() + + if(DEFINED redo_cmake_args) + if("${args_ddash_loc}" STREQUAL "-1") + list(APPEND args "--") + endif() + list(APPEND args "${redo_cmake_args}") + endif() + endif() + else() + list(APPEND args "${redo_args}") + endif() +endif() + +# Skip arguments if requested +if(DEFINED SKIP_ARGS) + foreach(i RANGE 1 ${SKIP_ARGS}) + list(POP_FRONT args) + endforeach() +endif() + +# Write config.opt +set(content "") +foreach(arg IN LISTS args) + if(NOT arg IN_LIST IGNORE_ARGS) + string(APPEND content "${arg}\n") + endif() +endforeach() + +file(WRITE "${OUT_FILE}" "${content}") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/modulecppexports.h.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/modulecppexports.h.in new file mode 100644 index 0000000000000000000000000000000000000000..d6f1984fdcdad6f07abbfc9f924d70350604521d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/modulecppexports.h.in @@ -0,0 +1,50 @@ +// Copyright (C) 2022 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef @header_base_name_upper@_H +#define @header_base_name_upper@_H + +#include +#include // Q_@module_define_infix@_EXPORT +#include // QT_IF_DEPRECATED_SINCE + +#if defined(QT_SHARED) || !defined(QT_STATIC) +# if defined(QT_BUILD_@module_define_infix@_LIB) +# define Q_@module_define_infix@_EXPORT Q_DECL_EXPORT +# else +# define Q_@module_define_infix@_EXPORT Q_DECL_IMPORT +# endif +#else +# define Q_@module_define_infix@_EXPORT +#endif + +#if !defined(QT_BUILD_@module_define_infix@_LIB) && !defined(QT_STATIC) +/* outside library -> inline decl + defi */ +/* static builds treat everything as part of the library, so they never inline */ +# define QT_@module_define_infix@_INLINE_SINCE(major, minor) inline +# define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) 1 +#elif defined(QT_@module_define_infix@_BUILD_REMOVED_API) +/* inside library, inside removed_api.cpp: + * keep deprecated API -> non-inline decl; + * remove deprecated API -> inline decl; + * definition is always available */ +# define QT_@module_define_infix@_INLINE_SINCE(major, minor) \ + QT_IF_DEPRECATED_SINCE(major, minor, inline, /* not inline */) +# define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) 1 +#else +/* inside library, outside removed_api.cpp: + * keep deprecated API -> non-inline decl, no defi; + * remove deprecated API -> inline decl, defi */ +# define QT_@module_define_infix@_INLINE_SINCE(major, minor) \ + QT_IF_DEPRECATED_SINCE(major, minor, inline, /* not inline */) +# define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) \ + QT_IF_DEPRECATED_SINCE(major, minor, 1, 0) +#endif + +#ifdef QT_@module_define_infix@_BUILD_REMOVED_API +# define QT_@module_define_infix@_REMOVED_SINCE(major, minor) QT_DEPRECATED_SINCE(major, minor) +#else +# define QT_@module_define_infix@_REMOVED_SINCE(major, minor) 0 +#endif + +#endif // @header_base_name_upper@_H diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/qbatchedtestrunner.in.cpp b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/qbatchedtestrunner.in.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4f69f3b4ae299b917d7f18423345dae25cfa71ac --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/qbatchedtestrunner.in.cpp @@ -0,0 +1,18 @@ +// Copyright (C) 2022 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include +#include +#include + +int main(int argc, char **argv) +{ + if (argc == 1) { + printf("%s\n", QTest::qGetTestCaseNames().join( + QStringLiteral(" ")).toStdString().c_str()); + return 0; + } + + const auto entryFunction = QTest::qGetTestCaseEntryFunction(QString::fromUtf8(argv[1])); + return entryFunction ? entryFunction(argc - 1, argv + 1) : -1; +} diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/qt.toolchain.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/qt.toolchain.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7f9e34c0387b6c09cf6442d00a5b3a725b0d8fbc --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6/qt.toolchain.cmake @@ -0,0 +1,180 @@ +set(__qt_toolchain_used_variables + QT_CHAINLOAD_TOOLCHAIN_FILE + QT_TOOLCHAIN_INCLUDE_FILE + QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR + QT_TOOLCHAIN_RELOCATABLE_PREFIX + QT_ADDITIONAL_PACKAGES_PREFIX_PATH +) + + +# Make cache variables used by this toolchain file available to the +# try_compile command that operates on sources files. +list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES ${__qt_toolchain_used_variables}) +list(REMOVE_DUPLICATES CMAKE_TRY_COMPILE_PLATFORM_VARIABLES) + +# Turn the environment variables that are created at the end of this +# file into proper variables. This is needed for try_compile calls +# that operate on whole projects. +if($ENV{_QT_TOOLCHAIN_VARS_INITIALIZED}) + foreach(var ${__qt_toolchain_used_variables}) + set(${var} "$ENV{_QT_TOOLCHAIN_${var}}") + endforeach() +endif() + + + + +if(NOT QT_QMAKE_TARGET_MKSPEC) + set(QT_QMAKE_TARGET_MKSPEC win32-msvc CACHE STRING "") +endif() + +set(__qt_initial_c_compiler "C:/Program Files/Microsoft Visual Studio/2022/Professional/VC/Tools/MSVC/14.39.33519/bin/Hostx64/x64/cl.exe") +set(__qt_initial_cxx_compiler "C:/Program Files/Microsoft Visual Studio/2022/Professional/VC/Tools/MSVC/14.39.33519/bin/Hostx64/x64/cl.exe") +if(QT_USE_ORIGINAL_COMPILER AND NOT DEFINED CMAKE_C_COMPILER + AND EXISTS "${__qt_initial_c_compiler}") + set(CMAKE_C_COMPILER "${__qt_initial_c_compiler}" CACHE STRING "") +endif() +if(QT_USE_ORIGINAL_COMPILER AND NOT DEFINED CMAKE_CXX_COMPILER + AND EXISTS "${__qt_initial_cxx_compiler}") + set(CMAKE_CXX_COMPILER "${__qt_initial_cxx_compiler}" CACHE STRING "") +endif() + +if(NOT "${QT_CHAINLOAD_TOOLCHAIN_FILE}" STREQUAL "") + set(__qt_chainload_toolchain_file "${QT_CHAINLOAD_TOOLCHAIN_FILE}") +endif() +if(__qt_chainload_toolchain_file) + get_filename_component(__qt_chainload_toolchain_file_real_path + "${__qt_chainload_toolchain_file}" REALPATH) + if(__qt_chainload_toolchain_file_real_path STREQUAL CMAKE_CURRENT_LIST_FILE) + message(FATAL_ERROR + "Woah, the Qt toolchain file tried to include itself recursively! '${__qt_chainload_toolchain_file}' " + "Make sure to remove qtbase/CMakeCache.txt and reconfigure qtbase with 'cmake' " + "rather than 'qt-cmake', and then you can reconfigure your own project." + ) + elseif(NOT EXISTS "${__qt_chainload_toolchain_file_real_path}") + message(WARNING "The toolchain file to be chainloaded " + "'${__qt_chainload_toolchain_file}' does not exist.") + else() + include("${__qt_chainload_toolchain_file}") + set(__qt_chainload_toolchain_file_included TRUE) + endif() + unset(__qt_chainload_toolchain_file) +endif() + + + +# Compute dynamically the Qt installation prefix from the location of this file. This allows +# the usage of the toolchain file when the Qt installation is relocated. +get_filename_component(QT_TOOLCHAIN_RELOCATABLE_INSTALL_PREFIX + ${CMAKE_CURRENT_LIST_DIR}/../../../ + ABSOLUTE) + +# Compute the path to the installed Qt lib/cmake folder. +# We assume that the Qt toolchain location is inside the CMake Qt6 package, and thus the directory +# one level higher is what we're looking for. +get_filename_component(QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE) + +# REROOT_PATH_ISSUE_MARKER +# There's a subdirectory check in cmake's cmFindCommon::RerootPaths() function, that doesn't handle +# the case of CMAKE_PREFIX_PATH == CMAKE_FIND_ROOT_PATH for a particular pair of entries. +# Instead of collapsing the search prefix (which is the case when one is a subdir of the other), +# it concatenates them creating an invalid path. Workaround it by setting the root path to the +# Qt install prefix, and the prefix path to the lib/cmake subdir. +list(PREPEND CMAKE_PREFIX_PATH "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_TOOLCHAIN_RELOCATABLE_INSTALL_PREFIX}") + +# Let CMake load our custom platform modules. +# CMake-provided platform modules take precedence. +if(NOT QT_AVOID_CUSTOM_PLATFORM_MODULES) + list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/platforms") +endif() + +# Handle packages located in QT_ADDITIONAL_PACKAGES_PREFIX_PATH when cross-compiling. Needed for +# Conan. +# We prepend to CMAKE_PREFIX_PATH so that a find_package(Qt6Foo) call works, without having to go +# through the Qt6 umbrella package. The paths must end in lib/cmake to ensure the package is found. +# See REROOT_PATH_ISSUE_MARKER. +# We prepend to CMAKE_FIND_ROOT_PATH, due to the bug mentioned at REROOT_PATH_ISSUE_MARKER. +# +# Note that we don't handle QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH here, because we would thwart +# our efforts to not accidentally pick up host packages. For now, we say that +# find_package(Qt6FooTools) is not supported, and people must use find_package(Qt6 COMPONENTS +# FooTools) instead. +set(__qt_toolchain_additional_packages_prefixes "") +if(QT_ADDITIONAL_PACKAGES_PREFIX_PATH) + list(APPEND __qt_toolchain_additional_packages_prefixes + ${QT_ADDITIONAL_PACKAGES_PREFIX_PATH}) +endif() +if(DEFINED ENV{QT_ADDITIONAL_PACKAGES_PREFIX_PATH} + AND NOT "$ENV{QT_ADDITIONAL_PACKAGES_PREFIX_PATH}" STREQUAL "") + set(__qt_env_additional_packages_prefixes $ENV{QT_ADDITIONAL_PACKAGES_PREFIX_PATH}) + if(NOT CMAKE_HOST_WIN32) + string(REPLACE ":" ";" __qt_env_additional_packages_prefixes + "${__qt_env_additional_packages_prefixes}") + endif() + list(APPEND __qt_toolchain_additional_packages_prefixes + ${__qt_env_additional_packages_prefixes}) + unset(__qt_env_additional_packages_prefixes) +endif() + +if(__qt_toolchain_additional_packages_prefixes) + set(__qt_toolchain_additional_packages_root_paths "") + set(__qt_toolchain_additional_packages_prefix_paths "") + + foreach(__qt_additional_path IN LISTS __qt_toolchain_additional_packages_prefixes) + file(TO_CMAKE_PATH "${__qt_additional_path}" __qt_additional_path) + get_filename_component(__qt_additional_path "${__qt_additional_path}" ABSOLUTE) + set(__qt_additional_path_lib_cmake "${__qt_additional_path}") + if(NOT __qt_additional_path_lib_cmake MATCHES "/lib/cmake$") + string(APPEND __qt_additional_path_lib_cmake "/lib/cmake") + endif() + + list(APPEND __qt_toolchain_additional_packages_root_paths + "${__qt_additional_path}") + list(APPEND __qt_toolchain_additional_packages_prefix_paths + "${__qt_additional_path_lib_cmake}") + endforeach() + list(PREPEND CMAKE_PREFIX_PATH ${__qt_toolchain_additional_packages_prefix_paths}) + list(PREPEND CMAKE_FIND_ROOT_PATH ${__qt_toolchain_additional_packages_root_paths}) + + unset(__qt_additional_path) + unset(__qt_additional_path_lib_cmake) + unset(__qt_toolchain_additional_packages_root_paths) + unset(__qt_toolchain_additional_packages_prefix_paths) +endif() +unset(__qt_toolchain_additional_packages_prefixes) + +# Allow customization of the toolchain file by placing an additional file next to it. +set(__qt_toolchain_extra_file "${CMAKE_CURRENT_LIST_DIR}/qt.toolchain.extra.cmake") +if(EXISTS "${__qt_toolchain_extra_file}") + include("${__qt_toolchain_extra_file}") +endif() + +# Allow customization of the toolchain file by passing a path to an additional CMake file to be +# included. +if(QT_TOOLCHAIN_INCLUDE_FILE) + get_filename_component(__qt_toolchain_include_file_real_path + "${QT_TOOLCHAIN_INCLUDE_FILE}" REALPATH) + if(EXISTS "${__qt_toolchain_include_file_real_path}") + include("${__qt_toolchain_include_file_real_path}") + else() + message(WARNING "The passed extra toolchain file to be included does not exist: " + "${__qt_toolchain_include_file_real_path}") + endif() +endif() + +# Store initial build type (if any is specified) to be read by QtBuildInternals.cmake when building +# a Qt repo, standalone tests or a single test. +if(DEFINED CACHE{CMAKE_BUILD_TYPE}) + set(__qt_toolchain_cmake_build_type_before_project_call "${CMAKE_BUILD_TYPE}") +endif() + +# Compile tests only see a restricted set of variables. +# All cache variables, this toolchain file uses, must be made available to project-based +# try_compile tests because this toolchain file will be included there too. +if(NOT "$ENV{_QT_TOOLCHAIN_VARS_INITIALIZED}") + set(ENV{_QT_TOOLCHAIN_VARS_INITIALIZED} ON) + foreach(var ${__qt_toolchain_used_variables}) + set(ENV{_QT_TOOLCHAIN_${var}} "${${var}}") + endforeach() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c3c638251dbc0e135e0b89771cb7d85c581dc5b4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfig.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# These values should be kept in sync with those in qtbase/.cmake.conf +cmake_minimum_required(VERSION 3.16...3.21) + +set(QT_BACKUP_CMAKE_INSTALL_PREFIX_BEFORE_EXTRA_INCLUDE "${CMAKE_INSTALL_PREFIX}") + +# This depends on qt_internal_read_repo_dependencies existing. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake") + include(${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake) +endif() + +macro(qt_internal_setup_cmake_and_export_namespace) + # The variables might have already been set in QtBuildInternalsExtra.cmake if the file is + # included while building a new module and not QtBase. In that case, stop overriding the value. + if(NOT INSTALL_CMAKE_NAMESPACE) + set(INSTALL_CMAKE_NAMESPACE "Qt${PROJECT_VERSION_MAJOR}" + CACHE STRING "CMake namespace [Qt${PROJECT_VERSION_MAJOR}]") + endif() + if(NOT QT_CMAKE_EXPORT_NAMESPACE) + set(QT_CMAKE_EXPORT_NAMESPACE "Qt${PROJECT_VERSION_MAJOR}" + CACHE STRING "CMake namespace used when exporting targets [Qt${PROJECT_VERSION_MAJOR}]") + endif() +endmacro() + +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}") + + # 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. + # TODO: Clean this up, together with qt_internal_try_compile_binary_for_strip to only use the + # the qtbase sources when building qtbase. And perhaps also when doing a non-prefix + # developer-build. + if(EXISTS "${QT_SOURCE_TREE}/cmake") + 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() + +qt_internal_setup_cmake_and_export_namespace() + +# Set up the build internal paths unless explicitly requested not to. +if(NOT QT_BUILD_INTERNALS_SKIP_CMAKE_MODULE_PATH_ADDITION) + # Depends on qt_internal_setup_cmake_and_export_namespace + qt_set_up_build_internals_paths() +endif() + +include(QtBuildHelpers) + +qt_internal_include_all_helpers() +qt_internal_setup_build_internals() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..093019a65ccd82fe3d0375a8818a548daf857100 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6BuildInternalsConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/Qt6BuildInternalsConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/QtBuildInternalsExtra.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/QtBuildInternalsExtra.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7880f616dfad143c5dccda8a70127a8de7978b99 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BuildInternals/QtBuildInternalsExtra.cmake @@ -0,0 +1,247 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Propagate common variables via BuildInternals package. +set(QT_BUILD_SHARED_LIBS ON) +option(BUILD_SHARED_LIBS "Build Qt statically or dynamically" ON) +set(QT_CMAKE_EXPORT_NAMESPACE Qt6) +set(INSTALL_CMAKE_NAMESPACE Qt6) +set(QT_BUILD_INTERNALS_PATH "${CMAKE_CURRENT_LIST_DIR}") + +# The relocatable install prefix is meant to be used to find things like host binaries (syncqt), +# when the CMAKE_INSTALL_PREFIX is overridden to point to a different path (like when building a +# a Qt repo using Conan, which will set a random install prefix instead of installing into the +# original Qt install prefix). +get_filename_component(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX + ${CMAKE_CURRENT_LIST_DIR}/../../../ + ABSOLUTE) + +# Stores in out_var the new install/staging prefix for this build. +# +# new_prefix: the new prefix for this repository +# orig_prefix: the prefix that was used when qtbase was configured +# +# On Windows hosts: if the original prefix does not start with a drive letter, this function removes +# the drive letter from the new prefix. This is needed for installation with DESTDIR set. +function(qt_internal_new_prefix out_var new_prefix orig_prefix) + if(CMAKE_HOST_WIN32) + set(drive_letter_regexp "^[a-zA-Z]:") + if(new_prefix MATCHES "${drive_letter_regexp}" + AND NOT orig_prefix MATCHES "${drive_letter_regexp}") + string(SUBSTRING "${new_prefix}" 2 -1 new_prefix) + endif() + endif() + set(${out_var} "${new_prefix}" PARENT_SCOPE) +endfunction() + +# If no explicit CMAKE_INSTALL_PREFIX is provided, force set the original Qt installation prefix, +# so that further modules / repositories are installed into same original location. +# This means by default when configuring qtsvg / qtdeclarative, they will be installed the regular +# Qt installation prefix. +# If an explicit installation prefix is specified, honor it. +# This is an attempt to support Conan, aka handle installation of modules into a +# different installation prefix than the original one. Also allow to opt out via a special variable. +# In a top-level build, QtSetup.cmake takes care of setting CMAKE_INSTALL_PREFIX. +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND + NOT QT_BUILD_INTERNALS_NO_FORCE_SET_INSTALL_PREFIX + AND NOT QT_SUPERBUILD) + set(qtbi_orig_prefix "/Users/qt/work/install") + set(qtbi_orig_staging_prefix "") + qt_internal_new_prefix(qtbi_new_prefix + "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}" + "${qtbi_orig_prefix}") + if(NOT qtbi_orig_staging_prefix STREQUAL "" + AND "${CMAKE_STAGING_PREFIX}" STREQUAL "" + AND NOT QT_BUILD_INTERNALS_NO_FORCE_SET_STAGING_PREFIX) + qt_internal_new_prefix(qtbi_new_staging_prefix + "${qtbi_new_prefix}" + "${qtbi_orig_staging_prefix}") + set(CMAKE_STAGING_PREFIX "${qtbi_new_staging_prefix}" CACHE PATH + "Staging path prefix, prepended onto install directories on the host machine." FORCE) + set(qtbi_new_prefix "${qtbi_orig_prefix}") + endif() + set(CMAKE_INSTALL_PREFIX "${qtbi_new_prefix}" CACHE PATH + "Install path prefix, prepended onto install directories." FORCE) + unset(qtbi_orig_prefix) + unset(qtbi_new_prefix) + unset(qtbi_orig_staging_prefix) + unset(qtbi_new_staging_prefix) +endif() + +# Propagate developer builds to other modules via BuildInternals package. +if(OFF) + set(FEATURE_developer_build ON CACHE BOOL "Developer build." FORCE) +endif() + +# Propagate non-prefix builds. +set(QT_WILL_INSTALL ON CACHE BOOL + "Boolean indicating if doing a Qt prefix build (vs non-prefix build)." FORCE) + +set(QT_SOURCE_TREE "C:/Users/qt/work/qt/qtbase" CACHE PATH +"A path to the source tree of the previously configured QtBase project." FORCE) + +# Propagate decision of building tests and examples to other repositories. +set(QT_BUILD_TESTS OFF CACHE BOOL "Build the testing tree.") +set(QT_BUILD_EXAMPLES FALSE CACHE BOOL "Build Qt examples") +set(QT_BUILD_BENCHMARKS OFF CACHE BOOL "Build Qt Benchmarks") +set(QT_BUILD_MANUAL_TESTS OFF CACHE BOOL "Build Qt manual tests") +set(QT_BUILD_MINIMAL_STATIC_TESTS OFF CACHE BOOL + "Build minimal subset of tests for static Qt builds") +set(QT_BUILD_MINIMAL_ANDROID_MULTI_ABI_TESTS OFF CACHE BOOL + "Build minimal subset of tests for Android multi-ABI Qt builds") + +set(QT_BUILD_TESTS_BATCHED OFF CACHE BOOL + "Should all tests be batched into a single binary.") + +set(QT_BUILD_TESTS_BY_DEFAULT ON CACHE BOOL + "Should tests be built as part of the default 'all' target.") +set(QT_BUILD_EXAMPLES_BY_DEFAULT ON CACHE BOOL + "Should examples be built as part of the default 'all' target.") +set(QT_BUILD_TOOLS_BY_DEFAULT ON CACHE BOOL + "Should tools be built as part of the default 'all' target.") + +set(QT_BUILD_EXAMPLES_AS_EXTERNAL "OFF" CACHE BOOL + "Should examples be built as ExternalProjects.") + +# Propagate usage of ccache. +set(QT_USE_CCACHE OFF CACHE BOOL "Enable the use of ccache") + +# Propagate usage of vcpkg, ON by default. +set(QT_USE_VCPKG OFF CACHE BOOL "Enable the use of vcpkg") + +# Propagate usage of unity build. +set(QT_UNITY_BUILD OFF CACHE BOOL "Enable unity (jumbo) build") +set(QT_UNITY_BUILD_BATCH_SIZE "32" CACHE STRING "Unity build batch size") + +# Propragate the value of WARNINGS_ARE_ERRORS. +set(WARNINGS_ARE_ERRORS "OFF" CACHE BOOL "Build Qt with warnings as errors") + +# Propagate usage of versioned hard link. +set(QT_CREATE_VERSIONED_HARD_LINK "ON" CACHE BOOL + "Enable the use of versioned hard link") + +# The minimum version required to build Qt. +set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT "3.16") +set(QT_COMPUTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT "3.16") + +# The lower and upper CMake version policy range as computed by qtbase. +# These values are inherited when building other Qt repositories, unless overridden +# in the respective repository .cmake.conf file. +# These are not cache variables, so that they can be overridden in each repo directory scope. +if(NOT DEFINED QT_MIN_NEW_POLICY_CMAKE_VERSION) + set(QT_MIN_NEW_POLICY_CMAKE_VERSION "3.16") +endif() +if(NOT DEFINED QT_MAX_NEW_POLICY_CMAKE_VERSION) + set(QT_MAX_NEW_POLICY_CMAKE_VERSION "3.21") +endif() + +# Extra set of exported variables +set(TEST_architecture_arch "x86_64" CACHE INTERNAL "") +set(TEST_subarch_result "" CACHE INTERNAL "") +set(TEST_buildAbi "x86_64-little_endian-lp64" CACHE INTERNAL "") +set(TEST_ld_version_script "OFF" CACHE INTERNAL "") +set(TEST_ld_version_script "OFF" CACHE INTERNAL "") + +get_property(__qt_is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +if(__qt_is_multi_config) + set(CMAKE_CONFIGURATION_TYPES "RelWithDebInfo;Debug" CACHE STRING "" FORCE) + set(CMAKE_TRY_COMPILE_CONFIGURATION "RelWithDebInfo") +endif() +unset(__qt_is_multi_config) + +set(QT_MULTI_CONFIG_FIRST_CONFIG "RelWithDebInfo") +if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config") + set(CMAKE_CROSS_CONFIGS "all" CACHE STRING "") + set(CMAKE_DEFAULT_BUILD_TYPE "RelWithDebInfo" CACHE STRING "") + set(CMAKE_DEFAULT_CONFIGS "all" CACHE STRING "") +endif() +set(BUILD_WITH_PCH "ON" CACHE STRING "") +set(QT_QPA_DEFAULT_PLATFORM "windows" CACHE STRING "") +set(QT_QPA_PLATFORMS "windows" CACHE STRING "") +set(CMAKE_INSTALL_RPATH "" CACHE STRING "") + +if(NOT QT_SKIP_BUILD_INTERNALS_PKG_CONFIG_FEATURE) + set(FEATURE_pkg_config "OFF" CACHE BOOL "Using pkg-config" FORCE) +endif() +set(OPENSSL_ROOT_DIR "C:/openssl/include/.." CACHE STRING "") + +set(INSTALL_BINDIR "bin" CACHE STRING "Executables [PREFIX/bin]" FORCE) +set(INSTALL_INCLUDEDIR "include" CACHE STRING "Header files [PREFIX/include]" FORCE) +set(INSTALL_LIBDIR "lib" CACHE STRING "Libraries [PREFIX/lib]" FORCE) +set(INSTALL_MKSPECSDIR "mkspecs" CACHE STRING "Mkspecs files [PREFIX/mkspecs]" FORCE) +set(INSTALL_ARCHDATADIR "." CACHE STRING "Arch-dependent data [PREFIX]" FORCE) +set(INSTALL_PLUGINSDIR "plugins" CACHE STRING "Plugins [ARCHDATADIR/plugins]" FORCE) +set(INSTALL_LIBEXECDIR "bin" CACHE STRING "Helper programs [ARCHDATADIR/bin on Windows, ARCHDATADIR/libexec otherwise]" FORCE) +set(INSTALL_QMLDIR "qml" CACHE STRING "QML imports [ARCHDATADIR/qml]" FORCE) +set(INSTALL_DATADIR "." CACHE STRING "Arch-independent data [PREFIX]" FORCE) +set(INSTALL_DOCDIR "doc" CACHE STRING "Documentation [DATADIR/doc]" FORCE) +set(INSTALL_TRANSLATIONSDIR "translations" CACHE STRING "Translations [DATADIR/translations]" FORCE) +set(INSTALL_SYSCONFDIR "etc/xdg" CACHE STRING "Settings used by Qt programs [PREFIX/etc/xdg]/[/Library/Preferences/Qt]" FORCE) +set(INSTALL_EXAMPLESDIR "examples" CACHE STRING "Examples [PREFIX/examples]" FORCE) +set(INSTALL_TESTSDIR "tests" CACHE STRING "Tests [PREFIX/tests]" FORCE) +set(INSTALL_DESCRIPTIONSDIR "modules" CACHE STRING "Module description files directory" FORCE) +set(INSTALL_SBOMDIR "sbom" CACHE STRING "SBOM [PREFIX/sbom]" FORCE) + +set(QT_COPYRIGHT "Copyright (C) The Qt Company Ltd. and other contributors." CACHE STRING "") + + +if(NOT QT_SUPPORTED_MIN_IOS_SDK_VERSION) + set(QT_SUPPORTED_MIN_IOS_SDK_VERSION "17") +endif() + +if(NOT QT_SUPPORTED_MAX_IOS_SDK_VERSION) + set(QT_SUPPORTED_MAX_IOS_SDK_VERSION "18") +endif() + +if(NOT QT_SUPPORTED_MIN_IOS_XCODE_VERSION) + set(QT_SUPPORTED_MIN_IOS_XCODE_VERSION "15") +endif() + +if(NOT QT_SUPPORTED_MIN_IOS_VERSION) + set(QT_SUPPORTED_MIN_IOS_VERSION "16") +endif() + +if(NOT QT_SUPPORTED_MAX_IOS_VERSION_TESTED) + set(QT_SUPPORTED_MAX_IOS_VERSION_TESTED "18") +endif() + +if(NOT QT_SUPPORTED_MIN_VISIONOS_SDK_VERSION) + set(QT_SUPPORTED_MIN_VISIONOS_SDK_VERSION "1") +endif() + +if(NOT QT_SUPPORTED_MAX_VISIONOS_SDK_VERSION) + set(QT_SUPPORTED_MAX_VISIONOS_SDK_VERSION "2") +endif() + +if(NOT QT_SUPPORTED_MIN_VISIONOS_XCODE_VERSION) + set(QT_SUPPORTED_MIN_VISIONOS_XCODE_VERSION "15") +endif() + +if(NOT QT_SUPPORTED_MIN_VISIONOS_VERSION) + set(QT_SUPPORTED_MIN_VISIONOS_VERSION "1") +endif() + +if(NOT QT_SUPPORTED_MAX_VISIONOS_VERSION_TESTED) + set(QT_SUPPORTED_MAX_VISIONOS_VERSION_TESTED "2") +endif() + +if(NOT QT_SUPPORTED_MIN_MACOS_SDK_VERSION) + set(QT_SUPPORTED_MIN_MACOS_SDK_VERSION "14") +endif() + +if(NOT QT_SUPPORTED_MAX_MACOS_SDK_VERSION) + set(QT_SUPPORTED_MAX_MACOS_SDK_VERSION "15") +endif() + +if(NOT QT_SUPPORTED_MIN_MACOS_XCODE_VERSION) + set(QT_SUPPORTED_MIN_MACOS_XCODE_VERSION "15") +endif() + +if(NOT QT_SUPPORTED_MIN_MACOS_VERSION) + set(QT_SUPPORTED_MIN_MACOS_VERSION "12") +endif() + +if(NOT QT_SUPPORTED_MAX_MACOS_VERSION_TESTED) + set(QT_SUPPORTED_MAX_MACOS_VERSION_TESTED "15") +endif() + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1c2e4958488792d56a2db6af8528f5d86e7c378a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6BundledFreetype +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::BundledFreetype) +get_target_property(_qt_imported_location Qt6::BundledFreetype IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::BundledFreetype IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::BundledFreetype" for configuration "Release" +set_property(TARGET Qt6::BundledFreetype APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::BundledFreetype PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::BundledFreetype" for configuration "MinSizeRel" +set_property(TARGET Qt6::BundledFreetype APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::BundledFreetype PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::BundledFreetype PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..35748ffab66fbdac9c8ec8a210137f71a6db9442 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfig.cmake @@ -0,0 +1,60 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was Qt3rdPartyLibraryConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6BundledFreetypeDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledFreetypeDependencies.cmake") +endif() + +if (NOT QT_NO_CREATE_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledFreetypeTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledFreetypeAdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledFreetypeVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledFreetypeVersionlessAliasTargets.cmake") + endif() + endif() +endif() + +foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..72a142e10bfdce5f35c288ff9664e6bacee43c5e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledFreetypeConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cd38a963c9d68ff61878e520e263e143c522667b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeDependencies.cmake @@ -0,0 +1,48 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6BundledFreetype_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_BundledFreetype_third_party_deps "WrapPNG\;FALSE\;\;\;") +set(__qt_BundledFreetype_third_party_package_WrapPNG_provided_targets "WrapPNG::WrapPNG") + +_qt_internal_find_third_party_dependencies("BundledFreetype" __qt_BundledFreetype_third_party_deps) + +# Find Qt tool package. +set(__qt_BundledFreetype_tool_deps "") +_qt_internal_find_tool_dependencies("BundledFreetype" __qt_BundledFreetype_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_BundledFreetype_target_deps "Qt6Core\;6.8.1") +set(__qt_BundledFreetype_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("BundledFreetype" __qt_BundledFreetype_target_deps + __qt_BundledFreetype_find_dependency_paths) + +set(_Qt6BundledFreetype_MODULE_DEPENDENCIES "Core") +set(Qt6BundledFreetype_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cdfa3b84492ec1697582b45a2af991003377bcf6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::BundledFreetype" for configuration "Debug" +set_property(TARGET Qt6::BundledFreetype APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::BundledFreetype PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6BundledFreetyped.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::BundledFreetype ) +list(APPEND _cmake_import_check_files_for_Qt6::BundledFreetype "${_IMPORT_PREFIX}/lib/Qt6BundledFreetyped.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..254fa17b30f3f753d26cc988f775dd31d578c20f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::BundledFreetype" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::BundledFreetype APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::BundledFreetype PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "C" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6BundledFreetype.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::BundledFreetype ) +list(APPEND _cmake_import_check_files_for_Qt6::BundledFreetype "${_IMPORT_PREFIX}/lib/Qt6BundledFreetype.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..898e8ba2aaa0837a6d00858dfd6c1df3a6fbe841 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeTargets.cmake @@ -0,0 +1,133 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "2.8.12") + message(FATAL_ERROR "CMake >= 2.8.12 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.8.12...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::BundledFreetype) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::BundledFreetype +add_library(Qt6::BundledFreetype STATIC IMPORTED) + +set_target_properties(Qt6::BundledFreetype PROPERTIES + INTERFACE_LINK_LIBRARIES "\$;\$;\$" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_interface_name "BundledFreetype" + _qt_module_is_3rdparty_library "TRUE" + _qt_module_skip_depends_include "TRUE" + _qt_package_name "Qt6BundledFreetype" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-bundled-3rdparty-module-BundledFreetype" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6BundledFreetypeTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::PlatformModuleInternal" "Qt6::Core" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..18e39eeefe222b48ff1d4a58ab2fae17f86738e9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "BundledFreetype") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..45a28d24fb3569f1e122f477f4a33d216d6c727e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledFreetype/Qt6BundledFreetypeVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "BundledFreetype") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..061a7a542b61004a7eb0dd1b3babc1036248619b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6BundledLibjpeg +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::BundledLibjpeg) +get_target_property(_qt_imported_location Qt6::BundledLibjpeg IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::BundledLibjpeg IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::BundledLibjpeg" for configuration "Release" +set_property(TARGET Qt6::BundledLibjpeg APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::BundledLibjpeg PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::BundledLibjpeg" for configuration "MinSizeRel" +set_property(TARGET Qt6::BundledLibjpeg APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::BundledLibjpeg PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::BundledLibjpeg PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f69c7d9878505a0a77faa3ad1c5946912ff52b71 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfig.cmake @@ -0,0 +1,60 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was Qt3rdPartyLibraryConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibjpegDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibjpegDependencies.cmake") +endif() + +if (NOT QT_NO_CREATE_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibjpegTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibjpegAdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibjpegVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibjpegVersionlessAliasTargets.cmake") + endif() + endif() +endif() + +foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dd95c1f6bf33392177629c3ce9cf6d4e60f92324 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibjpegConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6685f6d4e5245be924d47faad73c177fb23188ff --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::BundledLibjpeg" for configuration "Debug" +set_property(TARGET Qt6::BundledLibjpeg APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::BundledLibjpeg PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6BundledLibjpegd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::BundledLibjpeg ) +list(APPEND _cmake_import_check_files_for_Qt6::BundledLibjpeg "${_IMPORT_PREFIX}/lib/Qt6BundledLibjpegd.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..05da9f70f1fec90fd0cdda52d2ddaeee885f54af --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::BundledLibjpeg" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::BundledLibjpeg APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::BundledLibjpeg PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "C" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6BundledLibjpeg.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::BundledLibjpeg ) +list(APPEND _cmake_import_check_files_for_Qt6::BundledLibjpeg "${_IMPORT_PREFIX}/lib/Qt6BundledLibjpeg.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9833c6055c1c2617c54b5e60f93fd7d0703ec9f7 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegTargets.cmake @@ -0,0 +1,133 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "2.8.12") + message(FATAL_ERROR "CMake >= 2.8.12 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.8.12...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::BundledLibjpeg) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::BundledLibjpeg +add_library(Qt6::BundledLibjpeg STATIC IMPORTED) + +set_target_properties(Qt6::BundledLibjpeg PROPERTIES + INTERFACE_LINK_LIBRARIES "\$" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_interface_name "BundledLibjpeg" + _qt_module_is_3rdparty_library "TRUE" + _qt_module_skip_depends_include "TRUE" + _qt_package_name "Qt6BundledLibjpeg" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-bundled-3rdparty-module-BundledLibjpeg" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibjpegTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::PlatformModuleInternal" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9e39a7dbb481efdeaadf9c9f2e1428f6030f3886 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "BundledLibjpeg") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d8ae3e1fc7f833b91bbfa1193df153e8a0cab605 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibjpeg/Qt6BundledLibjpegVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "BundledLibjpeg") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3e85af2541775479b7c96ce7ff55f54b4623a889 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6BundledLibpng +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::BundledLibpng) +get_target_property(_qt_imported_location Qt6::BundledLibpng IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::BundledLibpng IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::BundledLibpng" for configuration "Release" +set_property(TARGET Qt6::BundledLibpng APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::BundledLibpng PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::BundledLibpng" for configuration "MinSizeRel" +set_property(TARGET Qt6::BundledLibpng APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::BundledLibpng PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::BundledLibpng PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..af368d3cfaa9332c4ee98a89ac51816e2b8aa80d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfig.cmake @@ -0,0 +1,60 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was Qt3rdPartyLibraryConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibpngDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibpngDependencies.cmake") +endif() + +if (NOT QT_NO_CREATE_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibpngTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibpngAdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibpngVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibpngVersionlessAliasTargets.cmake") + endif() + endif() +endif() + +foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..db83d58b2ea8568b26dccd5fc5988251813012ab --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibpngConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ce53286a6b1cbb5d9b4efdcdb931f8423af70b2b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6BundledLibpng_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_BundledLibpng_third_party_deps "") + +_qt_internal_find_third_party_dependencies("BundledLibpng" __qt_BundledLibpng_third_party_deps) + +# Find Qt tool package. +set(__qt_BundledLibpng_tool_deps "") +_qt_internal_find_tool_dependencies("BundledLibpng" __qt_BundledLibpng_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_BundledLibpng_target_deps "Qt6Core\;6.8.1") +set(__qt_BundledLibpng_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("BundledLibpng" __qt_BundledLibpng_target_deps + __qt_BundledLibpng_find_dependency_paths) + +set(_Qt6BundledLibpng_MODULE_DEPENDENCIES "Core") +set(Qt6BundledLibpng_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..020058dcb9a8503c7a1092ee14f7349009c94853 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::BundledLibpng" for configuration "Debug" +set_property(TARGET Qt6::BundledLibpng APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::BundledLibpng PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6BundledLibpngd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::BundledLibpng ) +list(APPEND _cmake_import_check_files_for_Qt6::BundledLibpng "${_IMPORT_PREFIX}/lib/Qt6BundledLibpngd.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f7d5837972b93f30eed9d768d829abeb38b9a9ff --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::BundledLibpng" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::BundledLibpng APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::BundledLibpng PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "C" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6BundledLibpng.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::BundledLibpng ) +list(APPEND _cmake_import_check_files_for_Qt6::BundledLibpng "${_IMPORT_PREFIX}/lib/Qt6BundledLibpng.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a9a36c096dc4e123736976b876cde9a448aaa575 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngTargets.cmake @@ -0,0 +1,133 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "2.8.12") + message(FATAL_ERROR "CMake >= 2.8.12 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.8.12...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::BundledLibpng) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::BundledLibpng +add_library(Qt6::BundledLibpng STATIC IMPORTED) + +set_target_properties(Qt6::BundledLibpng PROPERTIES + INTERFACE_LINK_LIBRARIES "\$;\$" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_interface_name "BundledLibpng" + _qt_module_is_3rdparty_library "TRUE" + _qt_module_skip_depends_include "TRUE" + _qt_package_name "Qt6BundledLibpng" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-bundled-3rdparty-module-BundledLibpng" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6BundledLibpngTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::PlatformModuleInternal" "Qt6::Core" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1aef4b9bcf3549717f6d708cef3b2623cba4feda --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "BundledLibpng") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b2cd23adf05cb108d63866cd6c7edb71772b8626 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6BundledLibpng/Qt6BundledLibpngVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "BundledLibpng") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ddeb7f677e999a00da9285aa4028e1060595f792 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6Concurrent +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::Concurrent) +get_target_property(_qt_imported_location Qt6::Concurrent IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::Concurrent IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::Concurrent IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::Concurrent IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::Concurrent IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::Concurrent IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::Concurrent" for configuration "Release" +set_property(TARGET Qt6::Concurrent APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::Concurrent" for configuration "MinSizeRel" +set_property(TARGET Qt6::Concurrent APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::Concurrent PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::ConcurrentPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e80c8f21c03bc01173f7f9f7983314d1918bafba --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentDependencies.cmake") + _qt_internal_suggest_dependency_debugging(Concurrent + __qt_Concurrent_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6Concurrent_FOUND") + set("Qt6Concurrent_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6Concurrent_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6Concurrent) instead. + set(Qt6Concurrent_LIBRARIES "Qt6::Concurrent") + + get_target_property(_Qt6Concurrent_OWN_INCLUDE_DIRS + Qt6::Concurrent INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Concurrent_OWN_INCLUDE_DIRS) + set(_Qt6Concurrent_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::ConcurrentPrivate) + get_target_property(_Qt6Concurrent_OWN_PRIVATE_INCLUDE_DIRS + Qt6::ConcurrentPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Concurrent_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6Concurrent_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6Concurrent_DEFINITIONS + Qt6::Concurrent INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Concurrent_DEFINITIONS) + set(Qt6Concurrent_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6Concurrent_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6Concurrent_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6Concurrent_COMPILE_DEFINITIONS + Qt6::Concurrent INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Concurrent_COMPILE_DEFINITIONS) + set(Qt6Concurrent_COMPILE_DEFINITIONS "") + endif() + + set(Qt6Concurrent_INCLUDE_DIRS + ${_Qt6Concurrent_OWN_INCLUDE_DIRS}) + + set(Qt6Concurrent_PRIVATE_INCLUDE_DIRS + ${_Qt6Concurrent_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6Concurrent_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6Concurrent${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6Concurrent${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6Concurrent_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6Concurrent${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6Concurrent${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6Concurrent_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Concurrent_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Concurrent_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6Concurrent_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::Concurrent) + qt_make_features_available(Qt6::Concurrent) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Concurrent") + + get_target_property(_qt_module_target_type "Qt6::Concurrent" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::Concurrent MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6Concurrent_FOUND FALSE) + if(NOT DEFINED Qt6Concurrent_NOT_FOUND_MESSAGE) + set(Qt6Concurrent_NOT_FOUND_MESSAGE + "Target \"Qt6::Concurrent\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6Concurrent_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f883ee58eb7f6d0962c4c3ea29f880d793dedbae --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..06c43965531f1f6b49b1152962edb05ec96ea0b2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6Concurrent_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_Concurrent_third_party_deps "") + +_qt_internal_find_third_party_dependencies("Concurrent" __qt_Concurrent_third_party_deps) + +# Find Qt tool package. +set(__qt_Concurrent_tool_deps "") +_qt_internal_find_tool_dependencies("Concurrent" __qt_Concurrent_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_Concurrent_target_deps "Qt6Core\;6.8.1") +set(__qt_Concurrent_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("Concurrent" __qt_Concurrent_target_deps + __qt_Concurrent_find_dependency_paths) + +set(_Qt6Concurrent_MODULE_DEPENDENCIES "Core") +set(Qt6Concurrent_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..22ac0ed5a039ea24535eed02ec4c3048c3ff6f4e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Concurrent" for configuration "Debug" +set_property(TARGET Qt6::Concurrent APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::Concurrent PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6Concurrentd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6Concurrentd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Concurrent ) +list(APPEND _cmake_import_check_files_for_Qt6::Concurrent "${_IMPORT_PREFIX}/lib/Qt6Concurrentd.lib" "${_IMPORT_PREFIX}/bin/Qt6Concurrentd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2795cfdaba4f70dd867ac2ab323680170321ba4f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Concurrent" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::Concurrent APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::Concurrent PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6Concurrent.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6Concurrent.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Concurrent ) +list(APPEND _cmake_import_check_files_for_Qt6::Concurrent "${_IMPORT_PREFIX}/lib/Qt6Concurrent.lib" "${_IMPORT_PREFIX}/bin/Qt6Concurrent.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cdca6b650bcd3bbd798149f55e5816ec1a7d1f29 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentTargets.cmake @@ -0,0 +1,159 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Concurrent Qt6::ConcurrentPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Concurrent +add_library(Qt6::Concurrent SHARED IMPORTED) + +set_target_properties(Qt6::Concurrent PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_CONCURRENT_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtConcurrent;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6concurrent_metatypes.json>" + _qt_config_module_name "concurrent" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtConcurrent" + _qt_module_interface_name "Concurrent" + _qt_package_name "Qt6Concurrent" + _qt_package_version "6.8.1" + _qt_private_module_target_name "ConcurrentPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Concurrent" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::ConcurrentPrivate +add_library(Qt6::ConcurrentPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::ConcurrentPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtConcurrent/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtConcurrent/6.8.1/QtConcurrent>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::Concurrent" + _qt_config_module_name "concurrent_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6Concurrent" + _qt_package_version "6.8.1" + _qt_public_module_target_name "Concurrent" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Concurrent" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6ConcurrentTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Core" "Qt6::CorePrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b508ed92625aaf3e39526b1046d25b68fa415f95 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Concurrent;ConcurrentPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..484bf50be39ac6dd235b26dbcde2de992eaec9d4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Concurrent/Qt6ConcurrentVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Concurrent;ConcurrentPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CTestMacros.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CTestMacros.cmake new file mode 100644 index 0000000000000000000000000000000000000000..219c9a6a043d282dd013094d6e3af97c4297c54f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CTestMacros.cmake @@ -0,0 +1,776 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# +# W A R N I N G +# ------------- +# +# This file is not part of the Qt API. It exists purely as an +# implementation detail. This file, and its contents may change from version to +# version without notice, or even be removed. +# +# We mean it. + +message(STATUS "CMAKE_VERSION: ${CMAKE_VERSION}") +message(STATUS "CMAKE_PREFIX_PATH: ${CMAKE_PREFIX_PATH}") +message(STATUS "CMAKE_MODULES_UNDER_TEST: ${CMAKE_MODULES_UNDER_TEST}") + +# Generate a shell script wrapper that calls ninja with -v parameter. +# Upstream issue to allow specifying custom build tool options when using ctest's --build-and-test +# https://gitlab.kitware.com/cmake/cmake/-/issues/22443. +# Only one file is created that is used by all tests. +function(_qt_internal_get_ninja_wrapper ninja_path out_wrapper_path) + if(QT_INTERNAL_CTEST_NINJA_WRAPPER AND EXISTS "${QT_INTERNAL_CTEST_NINJA_WRAPPER}") + set(${out_wrapper_path} "${QT_INTERNAL_CTEST_NINJA_WRAPPER}" PARENT_SCOPE) + return() + endif() + + if(NOT ninja_path) + message(FATAL_ERROR "Invalid ninja path specified: '${ninja_path}'.") + endif() + + set(wrapper_extension "") + + if(NOT CMAKE_HOST_UNIX) + set(wrapper_extension ".bat") + endif() + + set(script_name "qt-internal-ninja") + + # the libexec literal is used on purpose for the source, so the file is found + # on Windows hosts. + set(wrapper_rel_path "libexec/${script_name}${wrapper_extension}.in") + + # Need to find the libexec input file depending whether the qtbase sources are available. + # This mirrors the logic in qt_set_up_build_internals_paths. + # TODO: Clean this up, together with qt_set_up_build_internals_paths to only use the + # the qtbase sources when building qtbase. And perhaps also when doing a non-prefix + # developer-build. + set(qtbase_wrapper_in_path "${QT_SOURCE_TREE}/${wrapper_rel_path}") + set(installed_wrapper_in_path + "${_qt_cmake_dir}/${QT_CMAKE_EXPORT_NAMESPACE}/${wrapper_rel_path}") + + # qtbase sources available, always use them, regardless of prefix or non-prefix builds. + if(EXISTS "${qtbase_wrapper_in_path}") + set(wrapper_in "${qtbase_wrapper_in_path}") + + # qtbase sources unavailable, use installed files. + elseif(EXISTS "${installed_wrapper_in_path}") + set(wrapper_in "${installed_wrapper_in_path}") + else() + message(FATAL_ERROR "Can't find ${script_name}${wrapper_extension}.in file.") + endif() + + set(wrapper_out "${CMAKE_BINARY_DIR}/.qt/${script_name}${wrapper_extension}") + + set(original_ninja "${ninja_path}") + set(ninja_arguments "-v") + + configure_file("${wrapper_in}" "${wrapper_out}" @ONLY) + + set(QT_INTERNAL_CTEST_NINJA_WRAPPER "${wrapper_out}" CACHE STRING + "Internal Qt ninja wrapper for ctest tests") + + set(${out_wrapper_path} "${QT_INTERNAL_CTEST_NINJA_WRAPPER}" PARENT_SCOPE) +endfunction() + +# The function collects configuring options for the test projects generated by Qt cmake tests. +# Arguments: +# OUT_PREFIX_PATH : stores the CMAKE_PREFIX_PATH value in the output variable. +function(_qt_internal_get_cmake_test_configure_options out_var) + cmake_parse_arguments(arg "" "OUT_PREFIX_PATH" "" ${ARGN}) + set(option_list) + + if (CMAKE_C_COMPILER AND NOT CMAKE_CROSSCOMPILING) + list(APPEND option_list "-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}") + endif() + + if (CMAKE_CXX_COMPILER AND NOT CMAKE_CROSSCOMPILING) + list(APPEND option_list "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}") + endif() + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + if(CMAKE_CONFIGURATION_TYPES) + string(REPLACE ";" "\;" configuration_types "${CMAKE_CONFIGURATION_TYPES}") + list(APPEND option_list "-DCMAKE_CONFIGURATION_TYPES=${configuration_types}") + endif() + else() + if(CMAKE_BUILD_TYPE) + list(APPEND option_list "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}") + endif() + endif() + + if (CMAKE_TOOLCHAIN_FILE) + file(TO_CMAKE_PATH "${CMAKE_TOOLCHAIN_FILE}" _CMAKE_TOOLCHAIN_FILE) + list(APPEND option_list "-DCMAKE_TOOLCHAIN_FILE=${_CMAKE_TOOLCHAIN_FILE}") + endif() + + if (CMAKE_VERBOSE_MAKEFILE) + list(APPEND option_list "-DCMAKE_VERBOSE_MAKEFILE=1") + endif() + + if (NO_GUI) + list(APPEND option_list "-DNO_GUI=True") + endif() + if (NO_WIDGETS) + list(APPEND option_list "-DNO_WIDGETS=True") + endif() + if (NO_OPENGL) + list(APPEND option_list "-DNO_OPENGL=True") + endif() + if (NO_DBUS) + list(APPEND option_list "-DNO_DBUS=True") + endif() + + list(APPEND option_list "-DCMAKE_MESSAGE_LOG_LEVEL=DEBUG") + list(APPEND option_list "-DCMAKE_AUTOGEN_VERBOSE=TRUE") + if(QT_BUILD_DIR) + list(APPEND option_list "-DQT_BUILD_DIR=${QT_BUILD_DIR}") + endif() + + if(APPLE AND CMAKE_OSX_ARCHITECTURES) + list(LENGTH CMAKE_OSX_ARCHITECTURES osx_arch_count) + + # When Qt is built as universal config (macOS or iOS), force CMake build tests to build one + # architecture instead of all of them, because the build machine that builds the cmake tests + # might not have a universal SDK installed. + if(osx_arch_count GREATER 1) + list(APPEND option_list "-DQT_FORCE_SINGLE_QT_OSX_ARCHITECTURE=ON") + endif() + endif() + + foreach(module ${CMAKE_MODULES_UNDER_TEST}) + list(APPEND option_list + "-DCMAKE_${module}_MODULE_MAJOR_VERSION=${CMAKE_${module}_MODULE_MAJOR_VERSION}" + "-DCMAKE_${module}_MODULE_MINOR_VERSION=${CMAKE_${module}_MODULE_MINOR_VERSION}" + "-DCMAKE_${module}_MODULE_PATCH_VERSION=${CMAKE_${module}_MODULE_PATCH_VERSION}" + ) + endforeach() + + _qt_internal_get_build_vars_for_external_projects( + PREFIXES_VAR prefixes + ADDITIONAL_PACKAGES_PREFIXES_VAR additional_prefixes + ) + + if(arg_OUT_PREFIX_PATH) + set(${arg_OUT_PREFIX_PATH} "${prefixes}" PARENT_SCOPE) + endif() + + string(REPLACE ";" "\;" prefixes "${prefixes}") + list(APPEND option_list "-DCMAKE_PREFIX_PATH=${prefixes}") + list(APPEND option_list "-DQT_ADDITIONAL_PACKAGES_PREFIX_PATH=${additional_prefixes}") + + set(${out_var} "${option_list}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_set_up_test_run_environment testname) + set(no_value_options NO_PLUGIN_PATH) + set(single_value_options "") + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 1 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + # This is copy-pasted from qt_add_test and adapted to the standalone project case. + if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") + set(QT_PATH_SEPARATOR "\\;") + else() + set(QT_PATH_SEPARATOR ":") + endif() + + if(NOT INSTALL_BINDIR) + set(INSTALL_BINDIR bin) + endif() + + if(NOT INSTALL_PLUGINSDIR) + set(INSTALL_PLUGINSDIR "plugins") + endif() + + set(install_prefixes "") + if(NOT CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(install_prefixes "${CMAKE_INSTALL_PREFIX}") + endif() + + # If part of Qt build or standalone tests, use the build internals install prefix. + # If the tests are configured as a separate project, use the Qt6 package provided install + # prefix. + if(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX) + list(APPEND install_prefixes "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}") + else() + list(APPEND install_prefixes "${QT6_INSTALL_PREFIX}") + endif() + + set(test_env_path "PATH=${CMAKE_CURRENT_BINARY_DIR}") + foreach(install_prefix ${install_prefixes}) + set(test_env_path "${test_env_path}${QT_PATH_SEPARATOR}${install_prefix}/${INSTALL_BINDIR}") + endforeach() + set(test_env_path "${test_env_path}${QT_PATH_SEPARATOR}$ENV{PATH}") + string(REPLACE ";" "\;" test_env_path "${test_env_path}") + set_property(TEST "${testname}" APPEND PROPERTY ENVIRONMENT "${test_env_path}") + set_property(TEST "${testname}" APPEND PROPERTY ENVIRONMENT "QT_TEST_RUNNING_IN_CTEST=1") + + if(NOT arg_NO_PLUGIN_PATH) + # Add the install prefix to list of plugin paths when doing a prefix build + if(NOT QT_INSTALL_DIR) + foreach(install_prefix ${install_prefixes}) + list(APPEND plugin_paths "${install_prefix}/${INSTALL_PLUGINSDIR}") + endforeach() + endif() + + # TODO: Collect all paths from known repositories when performing a super build. + list(APPEND plugin_paths "${PROJECT_BINARY_DIR}/${INSTALL_PLUGINSDIR}") + list(JOIN plugin_paths "${QT_PATH_SEPARATOR}" plugin_paths_joined) + set_property(TEST "${testname}" + APPEND PROPERTY ENVIRONMENT "QT_PLUGIN_PATH=${plugin_paths_joined}") + endif() +endfunction() + +# Checks if the test project can be built successfully. Arguments: +# +# NO_CLEAN_STEP: Skips calling 'clean' target before building. +# +# NO_BUILD_PROJECT_ARG: Skips adding --build-project argument. Useful when using Xcode generator. +# +# GENERATOR: Use a custom generator. When not specified, uses existing CMAKE_GENERATOR value. +# +# NO_IOS_DEFAULT_ARGS: Skips setting default iOS-specific options like the generator to be used. +# +# MAKE_PROGRAM: Specify a different make program. Can be useful with a custom make or ninja wrapper. +# +# BUILD_TYPE: Specify a different CMake build type. Defaults to CMAKE_BUILD_TYPE if it is not empty. +# Which means no build type is passed if the top-level project is configured with a +# multi-config generator. +# +# SIMULATE_IN_SOURCE: If the option is specified, the function copies sources of the tests to the +# CMAKE_CURRENT_BINARY_DIR directory, creates internal build directory in the +# copied sources and uses this directory to build and test the project. +# This makes possible to have relative paths to the source files in the +# generated ninja rules. +# +# BUILD_DIR: A custom build dir relative to the calling project CMAKE_CURRENT_BINARY_DIR. +# Useful when configuring the same test project with different options in separate +# build dirs. +# +# BINARY: Path to the test artifact that will be executed after the build is complete. If a +# relative path is specified, it will be counted from the build directory. +# Can also be passed a random executable to be found in PATH, like 'ctest'. +# +# BINARY_ARGS: Additional arguments to pass to the BINARY. +# +# TESTNAME: a custom test name to use instead of the one derived from the source directory name +# +# BUILD_OPTIONS: a list of -D style CMake definitions to pass to ctest's --build-options (which +# are ultimately passed to the CMake invocation of the test project). You may +# escape semicolons inside the definitions using: +# https://cmake.org/cmake/help/latest/manual/cmake-language.7.html#bracket-argument +# so the argument containing list will look as following: +# -DLIST_ARGUMENT=item1[[;]]item2[[;]]...itemN. +macro(_qt_internal_test_expect_pass _dir) + if(WASM) + return() + endif() + set(_test_option_args + SIMULATE_IN_SOURCE + NO_CLEAN_STEP + NO_BUILD_PROJECT_ARG + NO_IOS_DEFAULT_ARGS + NO_RUN_ENVIRONMENT_PLUGIN_PATH + ) + set(_test_single_args + BINARY + TESTNAME + BUILD_DIR + GENERATOR + MAKE_PROGRAM + BUILD_TYPE + ) + set(_test_multi_args + BUILD_OPTIONS + BINARY_ARGS + ) + cmake_parse_arguments(_ARGS + "${_test_option_args}" + "${_test_single_args}" + "${_test_multi_args}" + ${ARGN} + ) + + if(NOT _ARGS_NO_IOS_DEFAULT_ARGS AND IOS) + set(_ARGS_NO_BUILD_PROJECT_ARG TRUE) + set(_ARGS_GENERATOR Xcode) + set(_ARGS_MAKE_PROGRAM xcodebuild) + endif() + + if(_ARGS_TESTNAME) + set(testname "${_ARGS_TESTNAME}") + else() + string(REPLACE "(" "_" testname "${_dir}") + string(REPLACE ")" "_" testname "${testname}") + string(REPLACE "/" "_" testname "${testname}") + endif() + + # Allow setting a different generator. Needed for iOS. + set(generator "${CMAKE_GENERATOR}") + if(_ARGS_GENERATOR) + set(generator "${_ARGS_GENERATOR}") + endif() + + # Allow setting a different make program. + if(_ARGS_MAKE_PROGRAM) + set(make_program "${_ARGS_MAKE_PROGRAM}") + elseif(CMAKE_GENERATOR MATCHES "Ninja") + # Use a ninja wrapper when generator is ninja + _qt_internal_get_ninja_wrapper("${CMAKE_MAKE_PROGRAM}" ninja_wrapper) + set(make_program "${ninja_wrapper}") + else() + set(make_program "${CMAKE_MAKE_PROGRAM}") + endif() + + # Only pass build config if it was specified during the initial tests/auto project + # configuration. Important when using Qt multi-config builds which won't have CMAKE_BUILD_TYPE + # set. + set(build_type "") + + if(_ARGS_BUILD_TYPE) + set(build_type "${_ARGS_BUILD_TYPE}") + elseif(CMAKE_BUILD_TYPE) + set(build_type "${CMAKE_BUILD_TYPE}") + endif() + if(build_type) + set(build_type "--build-config" "${build_type}") + endif() + + # Allow skipping clean step. + set(build_no_clean "") + if(_ARGS_NO_CLEAN_STEP) + set(build_no_clean "--build-noclean") + endif() + + # Allow omitting the --build-project arg. It's relevant for xcode projects where the project + # name on disk is different from the project source dir name. + if(NOT _ARGS_NO_BUILD_PROJECT_ARG) + set(build_project "--build-project" "${_dir}") + else() + set(build_project) + endif() + + # Allow omitting test command if no binary or binary args are provided. + set(test_command "") + if(_ARGS_BINARY) + list(APPEND test_command ${_ARGS_BINARY} ${_ARGS_BINARY_ARGS}) + endif() + if(test_command) + set(test_command "--test-command" ${test_command}) + endif() + + set(additional_configure_args "") + + # Allow passing additional configure options to all projects via either a cache var or env var. + # Can be useful for certain catch-all scenarios. + if(QT_CMAKE_TESTS_ADDITIONAL_CONFIGURE_OPTIONS) + list(APPEND additional_configure_args ${QT_CMAKE_TESTS_ADDITIONAL_CONFIGURE_OPTIONS}) + endif() + if(DEFINED ENV{QT_CMAKE_TESTS_ADDITIONAL_CONFIGURE_OPTIONS}) + list(APPEND additional_configure_args $ENV{QT_CMAKE_TESTS_ADDITIONAL_CONFIGURE_OPTIONS}) + endif() + + # When building an iOS CMake test in the CI using a universal Qt build, target the simulator + # sdk, because the CI currently doesn't have a proper setup for signing device binaries + # (missing a working signing certificate and provisioning profile). Allow opt-out. + if(IOS) + set(osx_arch_count 0) + if(QT_OSX_ARCHITECTURES) + list(LENGTH QT_OSX_ARCHITECTURES osx_arch_count) + endif() + + set(build_environment "") + if(DEFINED ENV{QT_BUILD_ENVIRONMENT}) + set(build_environment "$ENV{QT_BUILD_ENVIRONMENT}") + endif() + if(build_environment STREQUAL "ci" + AND osx_arch_count GREATER_EQUAL 2 + AND NOT QT_APPLE_SDK + AND NOT QT_NO_IOS_BUILD_ADJUSTMENT_IN_CI) + list(APPEND additional_configure_args + -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_OSX_SYSROOT=iphonesimulator) + endif() + endif() + + set(__expect_pass_build_dir "${CMAKE_CURRENT_BINARY_DIR}/${_dir}") + if(_ARGS_BUILD_DIR) + set(__expect_pass_build_dir "${CMAKE_CURRENT_BINARY_DIR}/${_ARGS_BUILD_DIR}") + endif() + + set(__expect_pass_source_dir "${CMAKE_CURRENT_SOURCE_DIR}/${_dir}") + if(_ARGS_SIMULATE_IN_SOURCE) + set(__expect_pass_in_source_build_dir "${CMAKE_CURRENT_BINARY_DIR}/in_source") + set(__expect_pass_build_dir "${__expect_pass_in_source_build_dir}/${_dir}/build") + set(__expect_pass_source_dir "${__expect_pass_in_source_build_dir}/${_dir}") + + unset(__expect_pass_in_source_build_dir) + endif() + + if(_ARGS_BINARY AND NOT IS_ABSOLUTE "${_ARGS_BINARY}") + set(_ARGS_BINARY "${__expect_pass_build_dir}/${_ARGS_BINARY}") + endif() + + if(_ARGS_SIMULATE_IN_SOURCE) + add_test(NAME ${testname}_cleanup + COMMAND ${CMAKE_COMMAND} -E remove_directory "${__expect_pass_source_dir}" + ) + set_tests_properties(${testname}_cleanup PROPERTIES + FIXTURES_SETUP "${testname}SIMULATE_IN_SOURCE_FIXTURE" + ) + add_test(${testname}_copy_sources ${CMAKE_COMMAND} -E copy_directory + "${CMAKE_CURRENT_SOURCE_DIR}/${_dir}" "${__expect_pass_source_dir}" + ) + set_tests_properties(${testname}_copy_sources PROPERTIES + FIXTURES_SETUP "${testname}SIMULATE_IN_SOURCE_FIXTURE" + DEPENDS ${testname}_cleanup + ) + endif() + + string(REPLACE "[[;]]" "\;" _ARGS_BUILD_OPTIONS "${_ARGS_BUILD_OPTIONS}") + + _qt_internal_get_cmake_test_configure_options(option_list) + set(ctest_command_args + --build-and-test + "${__expect_pass_source_dir}" + "${__expect_pass_build_dir}" + ${build_type} + ${build_no_clean} + --build-generator "${generator}" + --build-makeprogram "${make_program}" + ${build_project} + --build-options "${option_list}" + "${_ARGS_BUILD_OPTIONS}" ${additional_configure_args} + ${test_command} + ) + add_test(${testname} ${CMAKE_CTEST_COMMAND} ${ctest_command_args}) + if(_ARGS_SIMULATE_IN_SOURCE) + set_tests_properties(${testname} PROPERTIES + FIXTURES_REQUIRED "${testname}SIMULATE_IN_SOURCE_FIXTURE" + ) + endif() + set_tests_properties(${testname} PROPERTIES ENVIRONMENT "ASAN_OPTIONS=detect_leaks=0") + + if(_ARGS_BINARY) + set(run_env_args "") + if(_ARGS_NO_RUN_ENVIRONMENT_PLUGIN_PATH) + list(APPEND run_env_args NO_PLUGIN_PATH) + endif() + _qt_internal_set_up_test_run_environment("${testname}" ${run_env_args}) + endif() + + unset(__expect_pass_source_dir) + unset(__expect_pass_build_dir) +endmacro() + +# Checks if a qmake project can be built successfully. Arguments: +# +# TESTNAME: a custom test name to use instead of the one derived from the source directory name. +# the name also applies to the generated build directory. +# +# QMAKE_OPTIONS: a list of variable assignments to pass to the qmake invocation. +# e.g. CONFIG+=debug +# +# BUILD_ENVIRONMENT: a list of environment assignments to use when invoking the build tool +function(_qt_internal_add_qmake_test dir_name) + set(test_option_args + ) + set(test_single_args + TESTNAME + ) + set(test_multi_args + QMAKE_OPTIONS + BUILD_ENVIRONMENT + ) + + # PARSE_ARGV parsing keeps ';' in ENVIRONMENT variables + cmake_parse_arguments(PARSE_ARGV 1 arg + "${test_option_args}" + "${test_single_args}" + "${test_multi_args}" + ) + + if(arg_TESTNAME) + set(testname "${arg_TESTNAME}") + else() + string(REGEX REPLACE "[/)(]" "_" testname "${dir_name}") + endif() + + set(source_dir "${CMAKE_CURRENT_SOURCE_DIR}/${dir_name}") + if(arg_TESTNAME) + set(build_dir "${CMAKE_CURRENT_BINARY_DIR}/${arg_TESTNAME}") + else() + set(build_dir "${CMAKE_CURRENT_BINARY_DIR}/${dir_name}") + endif() + + # Find the qmake binary or the wrapper qmake script when cross-compiling.. + if(QtBase_BINARY_DIR AND NOT QT_BUILD_STANDALONE_TESTS) + set(qmake_dir "${QtBase_BINARY_DIR}/${INSTALL_BINDIR}") + else() + set(qmake_dir "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_BINS}") + endif() + + set(qmake_path "${qmake_dir}/qmake${CMAKE_EXECUTABLE_SUFFIX}") + + set(qmake_args + "${source_dir}" + ${arg_QMAKE_OPTIONS} + ) + + # Try to choose an appropriate build tool. + if(ENV{QT_QMAKE_TEST_BUILD_TOOL}) + set(build_tool "$ENV{QT_QMAKE_TEST_BUILD_TOOL}") + elseif(MSVC) + set(build_tool "nmake") + elseif(MINGW) + set(build_tool "mingw32-make") + else() + set(build_tool "make") + endif() + + set(build_tool_args "") + if(ENV{QT_QMAKE_TEST_BUILD_TOOL_OPTIONS}) + set(build_tool_args "$ENV{QT_QMAKE_TEST_BUILD_TOOL_OPTIONS}") + endif() + + # Remove any stale build dir, and create a new one on each test rerun. + add_test(${testname}_remove_build_dir + ${CMAKE_COMMAND} -E remove_directory "${build_dir}" + ) + set_tests_properties(${testname}_remove_build_dir PROPERTIES + FIXTURES_SETUP "${testname}_ensure_clean_build_dir" + ) + + add_test(${testname}_create_build_dir + ${CMAKE_COMMAND} -E make_directory "${build_dir}" + ) + set_tests_properties(${testname}_create_build_dir PROPERTIES + FIXTURES_SETUP "${testname}_ensure_clean_build_dir" + ) + + set_tests_properties(${testname}_create_build_dir + PROPERTIES DEPENDS ${testname}_remove_build_dir) + + # Add test to call qmake. + # + # We can't use the add_test(NAME) signature to set a working directory, because that breaks + # when calling ctest without a -C using multi-config generators, and the CI calls + # ctest without -C, and we use Xcode when configuring tests for iOS, which is multi-config. + # The plain add_test signature does not have this issue. + # Work around this by using a wrapper script that sets a working directory and use the plain + # signature. + # Somewhat related issue https://gitlab.kitware.com/cmake/cmake/-/issues/20283 + set(qmake_wrapper_file "${CMAKE_CURRENT_BINARY_DIR}/run_qmake_${testname}.cmake") + _qt_internal_create_command_script( + COMMAND "${qmake_path}" ${qmake_args} + COMMAND_ECHO STDOUT + OUTPUT_FILE "${qmake_wrapper_file}" + WORKING_DIRECTORY "${build_dir}" + ) + + add_test(${testname}_qmake "${CMAKE_COMMAND}" "-P" "${qmake_wrapper_file}") + + set_tests_properties(${testname}_qmake PROPERTIES + DEPENDS ${testname}_create_build_dir + FIXTURES_REQUIRED "${testname}_ensure_clean_build_dir" + FIXTURES_SETUP "${testname}_configure_project" + ) + + # Add test to build the generated qmake project. + set(build_tool_wrapper_file "${CMAKE_CURRENT_BINARY_DIR}/run_build_${testname}.cmake") + _qt_internal_create_command_script( + COMMAND "${build_tool}" ${build_tool_args} + COMMAND_ECHO STDOUT + OUTPUT_FILE "${build_tool_wrapper_file}" + WORKING_DIRECTORY "${build_dir}" + ENVIRONMENT ${arg_BUILD_ENVIRONMENT} + ) + + add_test(${testname} "${CMAKE_COMMAND}" "-P" "${build_tool_wrapper_file}") + + set_tests_properties(${testname} PROPERTIES + DEPENDS ${testname}_qmake + FIXTURES_REQUIRED "${testname}_ensure_clean_build_dir;${testname}_configure_project" + ) +endfunction() + +# Checks if the build of the test project fails. +# This test passes if the test project fails either at the +# configuring or build steps. +# Arguments: See _qt_internal_test_expect_pass +macro(_qt_internal_test_expect_fail) + _qt_internal_test_expect_pass(${ARGV}) + set_tests_properties(${testname} PROPERTIES WILL_FAIL TRUE) +endmacro() + +# Checks if the build of the test project fails. +# This test passes only if the test project fails at the build step, +# but not at the configuring step. +macro(_qt_internal_test_expect_build_fail _dir) + string(REPLACE "(" "_" testname "${_dir}") + string(REPLACE ")" "_" testname "${testname}") + file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/failbuild/${_dir}") + file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/${_dir}" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/failbuild/${_dir}") + + set(__expect_fail_prefixes "") + _qt_internal_get_cmake_test_configure_options(option_list OUT_PREFIX_PATH __expect_fail_prefixes) + + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/failbuild/${_dir}/${_dir}/FindPackageHints.cmake" + "set(Qt6Tests_PREFIX_PATH \"${__expect_fail_prefixes}\") +list(APPEND CMAKE_PREFIX_PATH \"${__expect_fail_prefixes}\") +") + + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/failbuild/${_dir}/CMakeLists.txt" + " + cmake_minimum_required(VERSION 3.16) + project(${_dir}) + + try_compile(Result \${CMAKE_CURRENT_BINARY_DIR}/${_dir} + \${CMAKE_CURRENT_SOURCE_DIR}/${_dir} + ${_dir} + OUTPUT_VARIABLE Out + ) + message(\"\${Out}\") + if (Result) + message(SEND_ERROR \"Succeeded build which should fail\") + endif() + " + ) + + + if(CMAKE_GENERATOR MATCHES "Ninja") + # Use a ninja wrapper when generator is ninja + _qt_internal_get_ninja_wrapper("${CMAKE_MAKE_PROGRAM}" ninja_wrapper) + set(make_program "${ninja_wrapper}") + else() + set(make_program "${CMAKE_MAKE_PROGRAM}") + endif() + + add_test(${testname} ${CMAKE_CTEST_COMMAND} + --build-and-test + "${CMAKE_CURRENT_BINARY_DIR}/failbuild/${_dir}" + "${CMAKE_CURRENT_BINARY_DIR}/failbuild/${_dir}/build" + --build-config "${CMAKE_BUILD_TYPE}" + --build-generator "${CMAKE_GENERATOR}" + --build-makeprogram "${make_program}" + --build-project "${_dir}" + --build-options ${option_list} + ) + unset(__expect_fail_prefixes) +endmacro() + +function(_qt_internal_test_module_includes) + + set(all_args ${ARGN}) + set(packages_string "") + set(libraries_string "") + + foreach(_package ${Qt6_MODULE_TEST_DEPENDS}) + set(packages_string + " + ${packages_string} + find_package(Qt6${_package} 6.0.0 REQUIRED) + " + ) + endforeach() + + while(all_args) + list(GET all_args 0 qtmodule) + list(REMOVE_AT all_args 0 1) + + set(CMAKE_MODULE_VERSION ${CMAKE_${qtmodule}_MODULE_MAJOR_VERSION}.${CMAKE_${qtmodule}_MODULE_MINOR_VERSION}.${CMAKE_${qtmodule}_MODULE_PATCH_VERSION} ) + + set(packages_string + "${packages_string} + find_package(Qt6${qtmodule} 6.0.0 REQUIRED)\n") + + list(FIND CMAKE_MODULES_UNDER_TEST ${qtmodule} _findIndex) + if (NOT _findIndex STREQUAL -1) + set(packages_string + "${packages_string} + if(NOT \"\${Qt6${qtmodule}_VERSION}\" VERSION_EQUAL ${CMAKE_MODULE_VERSION}) + message(SEND_ERROR \"Qt6${qtmodule}_VERSION variable was not ${CMAKE_MODULE_VERSION}. Got \${Qt6${qtmodule}_VERSION} instead.\") + endif() + if(NOT \"\${Qt6${qtmodule}_VERSION_MAJOR}\" VERSION_EQUAL ${CMAKE_${qtmodule}_MODULE_MAJOR_VERSION}) + message(SEND_ERROR \"Qt6${qtmodule}_VERSION_MAJOR variable was not ${CMAKE_${qtmodule}_MODULE_MAJOR_VERSION}. Got \${Qt6${qtmodule}_VERSION_MAJOR} instead.\") + endif() + if(NOT \"\${Qt6${qtmodule}_VERSION_MINOR}\" VERSION_EQUAL ${CMAKE_${qtmodule}_MODULE_MINOR_VERSION}) + message(SEND_ERROR \"Qt6${qtmodule}_VERSION_MINOR variable was not ${CMAKE_${qtmodule}_MODULE_MINOR_VERSION}. Got \${Qt6${qtmodule}_VERSION_MINOR} instead.\") + endif() + if(NOT \"\${Qt6${qtmodule}_VERSION_PATCH}\" VERSION_EQUAL ${CMAKE_${qtmodule}_MODULE_PATCH_VERSION}) + message(SEND_ERROR \"Qt6${qtmodule}_VERSION_PATCH variable was not ${CMAKE_${qtmodule}_MODULE_PATCH_VERSION}. Got \${Qt6${qtmodule}_VERSION_PATCH} instead.\") + endif()\n" + ) + endif() + set(libraries_string "${libraries_string} Qt6::${qtmodule}") + endwhile() + + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/module_includes/CMakeLists.txt" + " + cmake_minimum_required(VERSION 3.16) + project(module_includes) + + ${packages_string} + + add_executable(module_includes_exe \"\${CMAKE_CURRENT_SOURCE_DIR}/main.cpp\") + target_link_libraries(module_includes_exe ${libraries_string})\n" + ) + + set(all_args ${ARGN}) + set(includes_string "") + set(instances_string "") + while(all_args) + list(GET all_args 0 qtmodule) + list(GET all_args 1 qtclass) + if (${qtclass}_NAMESPACE) + set(qtinstancetype ${${qtclass}_NAMESPACE}::${qtclass}) + else() + set(qtinstancetype ${qtclass}) + endif() + list(REMOVE_AT all_args 0 1) + set(includes_string + "${includes_string} + #include <${qtclass}> + #include + #include + #include " + ) + set(instances_string + "${instances_string} + ${qtinstancetype} local${qtclass}; + ") + endwhile() + + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/module_includes/main.cpp" + " + + ${includes_string} + + int main(int, char **) { ${instances_string} return 0; }\n" + ) + + _qt_internal_get_cmake_test_configure_options(option_list) + + if(CMAKE_GENERATOR MATCHES "Ninja") + # Use a ninja wrapper when generator is ninja + _qt_internal_get_ninja_wrapper("${CMAKE_MAKE_PROGRAM}" ninja_wrapper) + set(make_program "${ninja_wrapper}") + else() + set(make_program "${CMAKE_MAKE_PROGRAM}") + endif() + + add_test(module_includes ${CMAKE_CTEST_COMMAND} + --build-and-test + "${CMAKE_CURRENT_BINARY_DIR}/module_includes/" + "${CMAKE_CURRENT_BINARY_DIR}/module_includes/build" + --build-config "${CMAKE_BUILD_TYPE}" + --build-generator "${CMAKE_GENERATOR}" + --build-makeprogram "${make_program}" + --build-project module_includes + --build-options ${option_list} + ) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e33f8361990880a0af98de0d20549d157fa9fd27 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6Core +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::Core) +get_target_property(_qt_imported_location Qt6::Core IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::Core IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::Core IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::Core IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::Core IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::Core IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::Core" for configuration "Release" +set_property(TARGET Qt6::Core APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::Core" for configuration "MinSizeRel" +set_property(TARGET Qt6::Core APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::Core PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::CorePrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7e420ce531b42e91545b54d2f3418f6b578d24c9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfig.cmake @@ -0,0 +1,188 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin +set(QT_KNOWN_POLICY_QTP0002 TRUE) +set(QT_KNOWN_POLICY_QTP0003 TRUE) + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6CoreDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreDependencies.cmake") + _qt_internal_suggest_dependency_debugging(Core + __qt_Core_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6Core_FOUND") + set("Qt6Core_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6Core_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6Core) instead. + set(Qt6Core_LIBRARIES "Qt6::Core") + + get_target_property(_Qt6Core_OWN_INCLUDE_DIRS + Qt6::Core INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Core_OWN_INCLUDE_DIRS) + set(_Qt6Core_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::CorePrivate) + get_target_property(_Qt6Core_OWN_PRIVATE_INCLUDE_DIRS + Qt6::CorePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Core_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6Core_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6Core_DEFINITIONS + Qt6::Core INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Core_DEFINITIONS) + set(Qt6Core_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6Core_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6Core_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6Core_COMPILE_DEFINITIONS + Qt6::Core INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Core_COMPILE_DEFINITIONS) + set(Qt6Core_COMPILE_DEFINITIONS "") + endif() + + set(Qt6Core_INCLUDE_DIRS + ${_Qt6Core_OWN_INCLUDE_DIRS}) + + set(Qt6Core_PRIVATE_INCLUDE_DIRS + ${_Qt6Core_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6Core_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6Core${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6Core${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6Core_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6Core${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6Core${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6Core_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Core_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Core_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6Core_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::Core) + qt_make_features_available(Qt6::Core) + + foreach(extra_cmake_include Qt6CoreMacros.cmake;Qt6CoreConfigExtras.cmake) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6CorePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CorePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Core") + + get_target_property(_qt_module_target_type "Qt6::Core" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::Core MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6CoreBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6Core_FOUND FALSE) + if(NOT DEFINED Qt6Core_NOT_FOUND_MESSAGE) + set(Qt6Core_NOT_FOUND_MESSAGE + "Target \"Qt6::Core\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6Core_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6CoreTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigExtras.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigExtras.cmake new file mode 100644 index 0000000000000000000000000000000000000000..12958facf3a25a18ac988ebd83c4bd530ddefb8f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigExtras.cmake @@ -0,0 +1,60 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause +if(NOT DEFINED QT_DEFAULT_MAJOR_VERSION) + set(QT_DEFAULT_MAJOR_VERSION 6) +endif() + +if (NOT QT_NO_CREATE_TARGETS) + set(__qt_core_target Qt6::Core) + get_property(__qt_core_aliased_target TARGET ${__qt_core_target} PROPERTY ALIASED_TARGET) + if(__qt_core_aliased_target) + set(__qt_core_target "${__qt_core_aliased_target}") + endif() + unset(__qt_core_aliased_target) + + set_property(TARGET ${__qt_core_target} APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS $<$>:QT_NO_DEBUG>) + set_property(TARGET ${__qt_core_target} PROPERTY INTERFACE_COMPILE_FEATURES cxx_decltype) +endif() + +# note: all the other AUTOMOC_MACRO_NAMES are already set by upstream CMake +list(APPEND CMAKE_AUTOMOC_MACRO_NAMES Q_GADGET_EXPORT Q_ENUM_NS) +list(REMOVE_DUPLICATES CMAKE_AUTOMOC_MACRO_NAMES) + +set(QT6_IS_SHARED_LIBS_BUILD "ON") +set(QT6_DEBUG_POSTFIX "d") + +set(_Qt6CTestMacros "${CMAKE_CURRENT_LIST_DIR}/Qt6CTestMacros.cmake") + +_qt_internal_setup_deploy_support() + + + +if(ANDROID_PLATFORM) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6AndroidMacros.cmake") + _qt_internal_create_global_android_targets() + _qt_internal_collect_default_android_abis() + if(NOT QT_NO_CREATE_TARGETS) + set_property(TARGET ${__qt_core_target} APPEND PROPERTY + INTERFACE_QT_EXECUTABLE_FINALIZERS + _qt_internal_android_executable_finalizer + ) + endif() +endif() + +if(QT_FEATURE_permissions AND APPLE) + if(NOT QT_NO_CREATE_TARGETS) + set_property(TARGET ${__qt_core_target} APPEND PROPERTY + INTERFACE_QT_EXECUTABLE_FINALIZERS + _qt_internal_darwin_permission_finalizer + ) + endif() +endif() + +if(EMSCRIPTEN) + set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS TRUE) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6WasmMacros.cmake") +endif() + +_qt_internal_override_example_install_dir_to_dot() + +unset(__qt_core_target) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a9c3bb0c5871d1f7595af1ba8698bf660ee3c348 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigureFileTemplate.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigureFileTemplate.in new file mode 100644 index 0000000000000000000000000000000000000000..9e5e60f6b05a9cd4759e893f4105e79b7b9cdc04 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreConfigureFileTemplate.in @@ -0,0 +1 @@ +@qt_core_configure_file_contents@ diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..00e26b8b7f3b7a0a5963dddadd995dd22c2c3c27 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreDependencies.cmake @@ -0,0 +1,48 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6Core_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_Core_third_party_deps "WrapAtomic\;FALSE\;\;\;") +set(__qt_Core_third_party_package_WrapAtomic_provided_targets "WrapAtomic::WrapAtomic") + +_qt_internal_find_third_party_dependencies("Core" __qt_Core_third_party_deps) + +# Find Qt tool package. +set(__qt_Core_tool_deps "Qt6CoreTools\;6.8.1") +_qt_internal_find_tool_dependencies("Core" __qt_Core_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_Core_target_deps "Qt6ZlibPrivate\;6.8.1;Qt6EntryPointPrivate\;6.8.1") +set(__qt_Core_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("Core" __qt_Core_target_deps + __qt_Core_find_dependency_paths) + +set(_Qt6Core_MODULE_DEPENDENCIES "ZlibPrivate;EntryPointPrivate") +set(Qt6Core_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreDeploySupport.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreDeploySupport.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f5669d87fd835844011fe704e2b56bedcad34f3d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreDeploySupport.cmake @@ -0,0 +1,682 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# NOTE: This code should only ever be executed in script mode. It expects to be +# used either as part of an install(CODE) call or called by a script +# invoked via cmake -P as a POST_BUILD step. + +cmake_minimum_required(VERSION 3.16...3.21) + +function(qt6_deploy_qt_conf qt_conf_absolute_path) + set(no_value_options "") + set(single_value_options + PREFIX + DOC_DIR + HEADERS_DIR + LIB_DIR + LIBEXEC_DIR + BIN_DIR + PLUGINS_DIR + QML_DIR + ARCHDATA_DIR + DATA_DIR + TRANSLATIONS_DIR + EXAMPLES_DIR + TESTS_DIR + SETTINGS_DIR + ) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 1 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unparsed arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if(NOT IS_ABSOLUTE "${qt_conf_absolute_path}") + message(FATAL_ERROR + "Given qt.conf path is not an absolute path: '${qt_conf_absolute_path}'") + endif() + + # Only write out locations that differ from the defaults + set(contents "[Paths]\n") + if(arg_PREFIX) + string(APPEND contents "Prefix = ${arg_PREFIX}\n") + endif() + if(arg_DOC_DIR AND NOT arg_DOC_DIR STREQUAL "doc") + string(APPEND contents "Documentation = ${arg_DOC_DIR}\n") + endif() + if(arg_HEADERS_DIR AND NOT arg_HEADERS_DIR STREQUAL "include") + string(APPEND contents "Headers = ${arg_HEADERS_DIR}\n") + endif() + if(arg_LIB_DIR AND NOT arg_LIB_DIR STREQUAL "lib") + string(APPEND contents "Libraries = ${arg_LIB_DIR}\n") + endif() + + # This one is special, the default is platform-specific + if(arg_LIBEXEC_DIR AND + ((WIN32 AND NOT arg_LIBEXEC_DIR STREQUAL "bin") OR + (NOT WIN32 AND NOT arg_LIBEXEC_DIR STREQUAL "libexec"))) + string(APPEND contents "LibraryExecutables = ${arg_LIBEXEC_DIR}\n") + endif() + + if(arg_BIN_DIR AND NOT arg_BIN_DIR STREQUAL "bin") + string(APPEND contents "Binaries = ${arg_BIN_DIR}\n") + endif() + if(arg_PLUGINS_DIR AND NOT arg_PLUGINS_DIR STREQUAL "plugins") + string(APPEND contents "Plugins = ${arg_PLUGINS_DIR}\n") + endif() + if(arg_QML_DIR AND NOT arg_QML_DIR STREQUAL "qml") + string(APPEND contents "QmlImports = ${arg_QML_DIR}\n") + endif() + if(arg_ARCHDATA_DIR AND NOT arg_ARCHDATA_DIR STREQUAL ".") + string(APPEND contents "ArchData = ${arg_ARCHDATA_DIR}\n") + endif() + if(arg_DATA_DIR AND NOT arg_DATA_DIR STREQUAL ".") + string(APPEND contents "Data = ${arg_DATA_DIR}\n") + endif() + if(arg_TRANSLATIONS_DIR AND NOT arg_TRANSLATIONS_DIR STREQUAL "translations") + string(APPEND contents "Translations = ${arg_TRANSLATIONS_DIR}\n") + endif() + if(arg_EXAMPLES_DIR AND NOT arg_EXAMPLES_DIR STREQUAL "examples") + string(APPEND contents "Examples = ${arg_EXAMPLES_DIR}\n") + endif() + if(arg_TESTS_DIR AND NOT arg_TESTS_DIR STREQUAL "tests") + string(APPEND contents "Tests = ${arg_TESTS_DIR}\n") + endif() + if(arg_SETTINGS_DIR AND NOT arg_SETTINGS_DIR STREQUAL ".") + string(APPEND contents "Settings = ${arg_SETTINGS_DIR}\n") + endif() + + message(STATUS "Writing ${qt_conf_absolute_path}") + file(WRITE "${qt_conf_absolute_path}" "${contents}") +endfunction() + +if(NOT __QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_deploy_qt_conf) + if(__QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_deploy_qt_conf(${ARGV}) + else() + message(FATAL_ERROR "qt_deploy_qt_conf() is only available in Qt 6.") + endif() + endfunction() +endif() + +# Copied from QtCMakeHelpers.cmake +function(_qt_internal_re_escape out_var str) + string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" regex "${str}") + set(${out_var} ${regex} PARENT_SCOPE) +endfunction() + +function(_qt_internal_set_rpath) + if(NOT CMAKE_HOST_UNIX OR CMAKE_HOST_APPLE) + message(WARNING "_qt_internal_set_rpath is not implemented on this platform.") + return() + endif() + + set(no_value_options "") + set(single_value_options FILE NEW_RPATH) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + if(__QT_DEPLOY_USE_PATCHELF) + message(STATUS "Setting runtime path of '${arg_FILE}' to '${arg_NEW_RPATH}'.") + execute_process( + COMMAND ${__QT_DEPLOY_PATCHELF_EXECUTABLE} --set-rpath "${arg_NEW_RPATH}" "${arg_FILE}" + RESULT_VARIABLE process_result + ) + if(NOT process_result EQUAL "0") + if(process_result MATCHES "^[0-9]+$") + message(FATAL_ERROR "patchelf failed with exit code ${process_result}.") + else() + message(FATAL_ERROR "patchelf failed: ${process_result}.") + endif() + endif() + else() + # Warning: file(RPATH_SET) is CMake-internal API. + file(RPATH_SET + FILE "${arg_FILE}" + NEW_RPATH "${arg_NEW_RPATH}" + ) + endif() +endfunction() + +# Store the platform-dependent $ORIGIN marker in out_var. +function(_qt_internal_get_rpath_origin out_var) + if(__QT_DEPLOY_SYSTEM_NAME STREQUAL "Darwin") + set(rpath_origin "@loader_path") + else() + set(rpath_origin "$ORIGIN") + endif() + set(${out_var} ${rpath_origin} PARENT_SCOPE) +endfunction() + +# Add a function to the list of deployment hooks. +# The hooks are run at the end of _qt_internal_generic_deployqt. +# +# Every hook is passed the parameters of _qt_internal_generic_deployqt plus the following: +# RESOLVED_DEPENDENCIES: list of resolved dependencies that were installed. +function(_qt_internal_add_deployment_hook function_name) + set_property(GLOBAL APPEND PROPERTY QT_INTERNAL_DEPLOYMENT_HOOKS "${function_name}") +endfunction() + +# Run all registered deployment hooks. +function(_qt_internal_run_deployment_hooks) + get_property(hooks GLOBAL PROPERTY QT_INTERNAL_DEPLOYMENT_HOOKS) + foreach(hook IN LISTS hooks) + if(NOT COMMAND "${hook}") + message(AUTHOR_WARNING "'${hook}' is not a command but was added as deployment hook.") + continue() + endif() + if(CMAKE_VERSION GREATER_EQUAL "3.19") + cmake_language(CALL "${hook}" ${ARGV}) + else() + set(temp_file ".qt-run-deploy-hook.cmake") + file(WRITE "${temp_file}" "${hook}(${ARGV})") + include(${temp_file}) + file(REMOVE "${temp_file}") + endif() + endforeach() +endfunction() + +function(_qt_internal_generic_deployqt) + set(no_value_options + NO_TRANSLATIONS + VERBOSE + ) + set(single_value_options + LIB_DIR + PLUGINS_DIR + ) + set(file_GRD_options + EXECUTABLES + LIBRARIES + MODULES + PRE_INCLUDE_REGEXES + PRE_EXCLUDE_REGEXES + POST_INCLUDE_REGEXES + POST_EXCLUDE_REGEXES + POST_INCLUDE_FILES + POST_EXCLUDE_FILES + ) + set(multi_value_options ${file_GRD_options}) + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unparsed arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if(arg_VERBOSE OR __QT_DEPLOY_VERBOSE) + set(verbose TRUE) + endif() + + # Make input file paths absolute + foreach(var IN ITEMS EXECUTABLES LIBRARIES MODULES) + string(PREPEND var arg_) + set(abspaths "") + foreach(path IN LISTS ${var}) + get_filename_component(abspath "${path}" REALPATH BASE_DIR "${QT_DEPLOY_PREFIX}") + list(APPEND abspaths "${abspath}") + endforeach() + set(${var} "${abspaths}") + endforeach() + + # We need to get the runtime dependencies of plugins too. + list(APPEND arg_MODULES ${__QT_DEPLOY_PLUGINS}) + + # Forward the arguments that are exactly the same for file(GET_RUNTIME_DEPENDENCIES). + set(file_GRD_args "") + foreach(var IN LISTS file_GRD_options) + if(NOT "${arg_${var}}" STREQUAL "") + list(APPEND file_GRD_args ${var} ${arg_${var}}) + endif() + endforeach() + + # Compile a list of regular expressions that represent ignored library directories. + if("${arg_POST_EXCLUDE_REGEXES}" STREQUAL "") + set(regexes "") + foreach(path IN LISTS QT_DEPLOY_IGNORED_LIB_DIRS) + _qt_internal_re_escape(path_rex "${path}") + list(APPEND regexes "^${path_rex}") + endforeach() + if(regexes) + list(APPEND file_GRD_args POST_EXCLUDE_REGEXES ${regexes}) + endif() + endif() + + # Get the runtime dependencies recursively. + file(GET_RUNTIME_DEPENDENCIES + ${file_GRD_args} + RESOLVED_DEPENDENCIES_VAR resolved + UNRESOLVED_DEPENDENCIES_VAR unresolved + CONFLICTING_DEPENDENCIES_PREFIX conflicting + ) + if(verbose) + message("file(GET_RUNTIME_DEPENDENCIES ${file_args})") + foreach(file IN LISTS resolved) + message(" resolved: ${file}") + endforeach() + foreach(file IN LISTS unresolved) + message(" unresolved: ${file}") + endforeach() + foreach(file IN LISTS conflicting_FILENAMES) + message(" conflicting: ${file}") + message(" with ${conflicting_${file}}") + endforeach() + endif() + + # Deploy the Qt libraries. + file(INSTALL ${resolved} + DESTINATION "${CMAKE_INSTALL_PREFIX}/${arg_LIB_DIR}" + FOLLOW_SYMLINK_CHAIN + ) + + # Determine the runtime path origin marker if necessary. + if(__QT_DEPLOY_MUST_ADJUST_PLUGINS_RPATH) + _qt_internal_get_rpath_origin(rpath_origin) + endif() + + # Deploy the Qt plugins. + foreach(file_path IN LISTS __QT_DEPLOY_PLUGINS) + file(RELATIVE_PATH destination + "${__QT_DEPLOY_QT_INSTALL_PREFIX}/${__QT_DEPLOY_QT_INSTALL_PLUGINS}" + "${file_path}" + ) + get_filename_component(destination "${destination}" DIRECTORY) + string(PREPEND destination "${CMAKE_INSTALL_PREFIX}/${arg_PLUGINS_DIR}/") + file(INSTALL ${file_path} DESTINATION ${destination}) + + if(__QT_DEPLOY_MUST_ADJUST_PLUGINS_RPATH) + get_filename_component(file_name ${file_path} NAME) + file(RELATIVE_PATH rel_lib_dir "${destination}" + "${QT_DEPLOY_PREFIX}/${QT_DEPLOY_LIB_DIR}") + _qt_internal_set_rpath( + FILE "${destination}/${file_name}" + NEW_RPATH "${rpath_origin}/${rel_lib_dir}" + ) + endif() + endforeach() + + # Deploy translations. + if(NOT arg_NO_TRANSLATIONS) + qt6_deploy_translations() + endif() + + _qt_internal_run_deployment_hooks(${ARGV} RESOLVED_DEPENDENCIES ${resolved}) +endfunction() + +function(qt6_deploy_runtime_dependencies) + + if(NOT __QT_DEPLOY_TOOL) + message(FATAL_ERROR "No Qt deploy tool available for this target platform") + endif() + + set(no_value_options + GENERATE_QT_CONF + VERBOSE + NO_OVERWRITE + NO_APP_STORE_COMPLIANCE # TODO: Might want a better name + NO_TRANSLATIONS + NO_COMPILER_RUNTIME + ) + set(single_value_options + EXECUTABLE + BIN_DIR + LIB_DIR + LIBEXEC_DIR + PLUGINS_DIR + QML_DIR + ) + set(file_GRD_options + # The following include/exclude options are only used if the "generic deploy tool" is + # used. The options are what file(GET_RUNTIME_DEPENDENCIES) supports. + PRE_INCLUDE_REGEXES + PRE_EXCLUDE_REGEXES + POST_INCLUDE_REGEXES + POST_EXCLUDE_REGEXES + POST_INCLUDE_FILES + POST_EXCLUDE_FILES + ) + set(multi_value_options + # These ADDITIONAL_... options are based on what file(GET_RUNTIME_DEPENDENCIES) + # supports. We differentiate between the types of binaries so that we keep + # open the possibility of switching to a purely CMake implementation of + # the deploy tool based on file(GET_RUNTIME_DEPENDENCIES) instead of the + # individual platform-specific tools (macdeployqt, windeployqt, etc.). + ADDITIONAL_EXECUTABLES + ADDITIONAL_LIBRARIES + ADDITIONAL_MODULES + ${file_GRD_options} + DEPLOY_TOOL_OPTIONS + ) + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unparsed arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if(NOT arg_EXECUTABLE) + message(FATAL_ERROR "EXECUTABLE must be specified") + endif() + + # None of these are used if the executable is a macOS app bundle + if(NOT arg_BIN_DIR) + set(arg_BIN_DIR "${QT_DEPLOY_BIN_DIR}") + endif() + if(NOT arg_LIBEXEC_DIR) + set(arg_LIBEXEC_DIR "${QT_DEPLOY_LIBEXEC_DIR}") + endif() + if(NOT arg_LIB_DIR) + set(arg_LIB_DIR "${QT_DEPLOY_LIB_DIR}") + endif() + if(NOT arg_QML_DIR) + set(arg_QML_DIR "${QT_DEPLOY_QML_DIR}") + endif() + if(NOT arg_PLUGINS_DIR) + set(arg_PLUGINS_DIR "${QT_DEPLOY_PLUGINS_DIR}") + endif() + + # macdeployqt always writes out a qt.conf file. It will complain if one + # already exists, so leave it to create it for us if we will be running it. + if(__QT_DEPLOY_SYSTEM_NAME STREQUAL Darwin) + # We might get EXECUTABLE pointing to either the actual binary under the + # Contents/MacOS directory, or it might be pointing to the top of the + # app bundle (i.e. the .app directory). We want the latter to + # pass to macdeployqt. + if(arg_EXECUTABLE MATCHES "^((.*/)?(.*).app)/Contents/MacOS/(.*)$") + set(arg_EXECUTABLE "${CMAKE_MATCH_1}") + endif() + elseif(arg_GENERATE_QT_CONF) + set(exe_dir "${QT_DEPLOY_BIN_DIR}") + if(exe_dir STREQUAL "" OR exe_dir STREQUAL ".") + set(exe_dir ".") + set(prefix ".") + else() + string(REPLACE "/" ";" path "${exe_dir}") + list(LENGTH path path_count) + string(REPEAT "../" ${path_count} rel_path) + string(REGEX REPLACE "/+$" "" prefix "${rel_path}") + endif() + qt6_deploy_qt_conf("${QT_DEPLOY_PREFIX}/${exe_dir}/qt.conf" + PREFIX "${prefix}" + BIN_DIR "${arg_BIN_DIR}" + LIB_DIR "${arg_LIB_DIR}" + PLUGINS_DIR "${arg_PLUGINS_DIR}" + QML_DIR "${arg_QML_DIR}" + ) + endif() + + set(extra_binaries_option "") + set(tool_options "") + + if(arg_VERBOSE OR __QT_DEPLOY_VERBOSE) + # macdeployqt supports 0-3: 0=no output, 1=error/warn (default), 2=normal, 3=debug + # windeployqt supports 0-2: 0=error/warn (default), 1=verbose, 2=full_verbose + if(__QT_DEPLOY_SYSTEM_NAME STREQUAL Windows) + list(APPEND tool_options --verbose 2) + elseif(__QT_DEPLOY_SYSTEM_NAME STREQUAL Darwin) + list(APPEND tool_options -verbose=3) + else() + list(APPEND tool_options VERBOSE) + endif() + endif() + + if(__QT_DEPLOY_SYSTEM_NAME STREQUAL Windows) + list(APPEND tool_options + --dir . + --libdir "${arg_BIN_DIR}" # NOTE: Deliberately not arg_LIB_DIR + --plugindir "${arg_PLUGINS_DIR}" + --qml-deploy-dir "${arg_QML_DIR}" + --translationdir "${QT_DEPLOY_TRANSLATIONS_DIR}" + ) + if(NOT arg_NO_OVERWRITE) + list(APPEND tool_options --force) + endif() + if(arg_NO_TRANSLATIONS) + list(APPEND tool_options --no-translations) + endif() + if(arg_NO_COMPILER_RUNTIME) + list(APPEND tool_options --no-compiler-runtime) + endif() + + # Specify path to target Qt's qtpaths .exe or .bat file, so windeployqt deploys the correct + # libraries when cross-compiling from x86_64 to arm64 windows. + if(__QT_DEPLOY_TARGET_QT_PATHS_PATH AND EXISTS "${__QT_DEPLOY_TARGET_QT_PATHS_PATH}") + list(APPEND tool_options --qtpaths "${__QT_DEPLOY_TARGET_QT_PATHS_PATH}") + else() + message(WARNING + "No qtpaths executable found for target Qt " + "at: ${__QT_DEPLOY_TARGET_QT_PATHS_PATH}. " + "Libraries may not be deployed correctly.") + endif() + + list(APPEND tool_options ${arg_DEPLOY_TOOL_OPTIONS}) + elseif(__QT_DEPLOY_SYSTEM_NAME STREQUAL Darwin) + set(extra_binaries_option "-executable=") + if(NOT arg_NO_APP_STORE_COMPLIANCE) + list(APPEND tool_options -appstore-compliant) + endif() + if(NOT arg_NO_OVERWRITE) + list(APPEND tool_options -always-overwrite) + endif() + list(APPEND tool_options ${arg_DEPLOY_TOOL_OPTIONS}) + endif() + + # This is an internal variable. It is normally unset and is only intended + # for debugging purposes. It may be removed at any time without warning. + list(APPEND tool_options ${__qt_deploy_tool_extra_options}) + + if(__QT_DEPLOY_TOOL STREQUAL "GRD") + message(STATUS "Running generic Qt deploy tool on ${arg_EXECUTABLE}") + + if(NOT "${arg_DEPLOY_TOOL_OPTIONS}" STREQUAL "") + message(WARNING + "DEPLOY_TOOL_OPTIONS was specified but has no effect when using the generic " + "deployment tool." + ) + endif() + + # Construct the EXECUTABLES, LIBRARIES and MODULES arguments. + list(APPEND tool_options EXECUTABLES ${arg_EXECUTABLE}) + if(NOT "${arg_ADDITIONAL_EXECUTABLES}" STREQUAL "") + list(APPEND tool_options ${arg_ADDITIONAL_EXECUTABLES}) + endif() + foreach(file_type LIBRARIES MODULES) + if("${arg_ADDITIONAL_${file_type}}" STREQUAL "") + continue() + endif() + list(APPEND tool_options ${file_type} ${arg_ADDITIONAL_${file_type}}) + endforeach() + + # Forward the arguments that are exactly the same for file(GET_RUNTIME_DEPENDENCIES). + foreach(var IN LISTS file_GRD_options) + if(NOT "${arg_${var}}" STREQUAL "") + list(APPEND tool_options ${var} ${arg_${var}}) + endif() + endforeach() + + if(arg_NO_TRANSLATIONS) + list(APPEND tool_options NO_TRANSLATIONS) + endif() + + _qt_internal_generic_deployqt( + LIB_DIR "${arg_LIB_DIR}" + PLUGINS_DIR "${arg_PLUGINS_DIR}" + ${tool_options} + ) + return() + endif() + + # Both windeployqt and macdeployqt don't differentiate between the different + # types of binaries, so we merge the lists and treat them all the same. + set(additional_binaries + ${arg_ADDITIONAL_EXECUTABLES} + ${arg_ADDITIONAL_LIBRARIES} + ${arg_ADDITIONAL_MODULES} + ) + foreach(extra_binary IN LISTS additional_binaries) + list(APPEND tool_options "${extra_binaries_option}${extra_binary}") + endforeach() + + message(STATUS + "Running Qt deploy tool for ${arg_EXECUTABLE} in working directory '${QT_DEPLOY_PREFIX}'") + execute_process( + COMMAND_ECHO STDOUT + COMMAND "${__QT_DEPLOY_TOOL}" "${arg_EXECUTABLE}" ${tool_options} + WORKING_DIRECTORY "${QT_DEPLOY_PREFIX}" + RESULT_VARIABLE result + ) + if(result) + message(FATAL_ERROR "Executing ${__QT_DEPLOY_TOOL} failed: ${result}") + endif() + +endfunction() + +if(NOT __QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_deploy_runtime_dependencies) + if(__QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_deploy_runtime_dependencies(${ARGV}) + else() + message(FATAL_ERROR "qt_deploy_runtime_dependencies() is only available in Qt 6.") + endif() + endfunction() +endif() + +function(_qt_internal_show_skip_runtime_deploy_message qt_build_type_string) + set(no_value_options "") + set(single_value_options + EXTRA_MESSAGE + ) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 1 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + message(STATUS + "Skipping runtime deployment steps. " + "Support for installing runtime dependencies is not implemented for " + "this target platform (${__QT_DEPLOY_SYSTEM_NAME}, ${qt_build_type_string}). " + "${arg_EXTRA_MESSAGE}" + ) +endfunction() + +# This function is currently in Technical Preview. +# Its signature and behavior might change. +function(qt6_deploy_translations) + set(no_value_options VERBOSE) + set(single_value_options + LCONVERT + ) + set(multi_value_options + CATALOGS + LOCALES + ) + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + set(verbose OFF) + if(arg_VERBOSE OR __QT_DEPLOY_VERBOSE) + set(verbose ON) + endif() + + if(arg_CATALOGS) + set(catalogs ${arg_CATALOGS}) + else() + set(catalogs ${__QT_DEPLOY_I18N_CATALOGS}) + endif() + + get_filename_component(qt_translations_dir "${__QT_DEPLOY_QT_INSTALL_TRANSLATIONS}" ABSOLUTE + BASE_DIR "${__QT_DEPLOY_QT_INSTALL_PREFIX}" + ) + set(locales ${arg_LOCALES}) + if(NOT locales) + file(GLOB locales RELATIVE "${qt_translations_dir}" "${qt_translations_dir}/*.qm") + list(TRANSFORM locales REPLACE "\\.qm$" "") + list(TRANSFORM locales REPLACE "^qt_help" "qt-help") + list(TRANSFORM locales REPLACE "^[^_]+" "") + list(TRANSFORM locales REPLACE "^_" "") + list(REMOVE_DUPLICATES locales) + endif() + + # Ensure existence of the output directory. + set(output_dir "${QT_DEPLOY_PREFIX}/${QT_DEPLOY_TRANSLATIONS_DIR}") + if(NOT EXISTS "${output_dir}") + file(MAKE_DIRECTORY "${output_dir}") + endif() + + # Locate lconvert. + if(arg_LCONVERT) + set(lconvert "${arg_LCONVERT}") + else() + set(lconvert "${__QT_DEPLOY_QT_INSTALL_PREFIX}/${__QT_DEPLOY_QT_INSTALL_BINS}/lconvert") + if(CMAKE_HOST_WIN32) + string(APPEND lconvert ".exe") + endif() + if(NOT EXISTS ${lconvert}) + message(STATUS "lconvert was not found. Skipping deployment of translations.") + return() + endif() + endif() + + # Find the .qm files for the selected locales + if(verbose) + message(STATUS "Looking for translations in ${qt_translations_dir}") + endif() + foreach(locale IN LISTS locales) + set(qm_files "") + foreach(catalog IN LISTS catalogs) + set(qm_file "${catalog}_${locale}.qm") + if(EXISTS "${qt_translations_dir}/${qm_file}") + list(APPEND qm_files ${qm_file}) + endif() + endforeach() + + if(NOT qm_files) + message(WARNING "No translations found for requested locale '${locale}'.") + continue() + endif() + + if(verbose) + foreach(qm_file IN LISTS qm_files) + message(STATUS "found translation file: ${qm_file}") + endforeach() + endif() + + # Merge the .qm files into one qt_${locale}.qm file. + set(output_file_name "qt_${locale}.qm") + set(output_file_path "${output_dir}/${output_file_name}") + message(STATUS "Creating: ${output_file_path}") + set(extra_options) + if(verbose) + list(APPEND extra_options COMMAND_ECHO STDOUT) + endif() + execute_process( + COMMAND ${lconvert} -if qm -o ${output_file_path} ${qm_files} + WORKING_DIRECTORY ${qt_translations_dir} + RESULT_VARIABLE process_result + ${extra_options} + ) + if(NOT process_result EQUAL "0") + if(process_result MATCHES "^[0-9]+$") + message(WARNING "lconvert failed with exit code ${process_result}.") + else() + message(WARNING "lconvert failed: ${process_result}.") + endif() + endif() + endforeach() +endfunction() + +if(NOT __QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_deploy_translations) + if(__QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_deploy_translations(${ARGV}) + else() + message(FATAL_ERROR "qt_deploy_translations() is only available in Qt 6.") + endif() + endfunction() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreMacros.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreMacros.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e4d3ddd3897b4dc3e88208c2e9aa5073423e9884 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreMacros.cmake @@ -0,0 +1,3833 @@ +# Copyright 2005-2011 Kitware, Inc. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +###################################### +# +# Macros for building Qt files +# +###################################### + +# Save the 'macros base dir' in a global property instead of a variable, to allow access in a +# deferred function where the variable might not be accessible by the function scope. +set_property(GLOBAL PROPERTY __qt_core_macros_module_base_dir "${CMAKE_CURRENT_LIST_DIR}") + +# macro used to create the names of output files preserving relative dirs +macro(_qt_internal_make_output_file infile prefix ext outfile ) + string(LENGTH ${CMAKE_CURRENT_BINARY_DIR} _binlength) + string(LENGTH ${infile} _infileLength) + set(_checkinfile ${CMAKE_CURRENT_SOURCE_DIR}) + if(_infileLength GREATER _binlength) + string(SUBSTRING "${infile}" 0 ${_binlength} _checkinfile) + if(_checkinfile STREQUAL "${CMAKE_CURRENT_BINARY_DIR}") + file(RELATIVE_PATH rel ${CMAKE_CURRENT_BINARY_DIR} ${infile}) + else() + file(RELATIVE_PATH rel ${CMAKE_CURRENT_SOURCE_DIR} ${infile}) + endif() + else() + file(RELATIVE_PATH rel ${CMAKE_CURRENT_SOURCE_DIR} ${infile}) + endif() + if(WIN32 AND rel MATCHES "^([a-zA-Z]):(.*)$") # absolute path + set(rel "${CMAKE_MATCH_1}_${CMAKE_MATCH_2}") + endif() + set(_outfile "${CMAKE_CURRENT_BINARY_DIR}/${rel}") + string(REPLACE ".." "__" _outfile ${_outfile}) + get_filename_component(outpath ${_outfile} PATH) + if(CMAKE_VERSION VERSION_LESS "3.14") + get_filename_component(_outfile_ext ${_outfile} EXT) + get_filename_component(_outfile_ext ${_outfile_ext} NAME_WE) + get_filename_component(_outfile ${_outfile} NAME_WE) + string(APPEND _outfile ${_outfile_ext}) + else() + get_filename_component(_outfile ${_outfile} NAME_WLE) + endif() + file(MAKE_DIRECTORY ${outpath}) + set(${outfile} ${outpath}/${prefix}${_outfile}.${ext}) +endmacro() + +macro(_qt_internal_get_moc_flags _moc_flags) + set(${_moc_flags}) + get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES) + + if(CMAKE_INCLUDE_CURRENT_DIR) + list(APPEND _inc_DIRS ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) + endif() + + foreach(_current ${_inc_DIRS}) + if("${_current}" MATCHES "\\.framework/?$") + string(REGEX REPLACE "/[^/]+\\.framework" "" framework_path "${_current}") + set(${_moc_flags} ${${_moc_flags}} "-F${framework_path}") + else() + set(${_moc_flags} ${${_moc_flags}} "-I${_current}") + endif() + endforeach() + + get_directory_property(_defines COMPILE_DEFINITIONS) + foreach(_current ${_defines}) + set(${_moc_flags} ${${_moc_flags}} "-D${_current}") + endforeach() + + if(WIN32) + set(${_moc_flags} ${${_moc_flags}} -DWIN32) + endif() + if (MSVC) + set(${_moc_flags} ${${_moc_flags}} --compiler-flavor=msvc) + endif() +endmacro() + +# helper macro to set up a moc rule +function(_qt_internal_create_moc_command infile outfile moc_flags moc_options + moc_target moc_depends out_json_file) + # Pass the parameters in a file. Set the working directory to + # be that containing the parameters file and reference it by + # just the file name. This is necessary because the moc tool on + # MinGW builds does not seem to handle spaces in the path to the + # file given with the @ syntax. + get_filename_component(_moc_outfile_name "${outfile}" NAME) + get_filename_component(_moc_outfile_dir "${outfile}" PATH) + if(_moc_outfile_dir) + set(_moc_working_dir WORKING_DIRECTORY ${_moc_outfile_dir}) + endif() + set (_moc_parameters_file ${outfile}_parameters) + set (_moc_parameters ${moc_flags} ${moc_options} -o "${outfile}" "${infile}") + if(out_json_file) + list(APPEND _moc_parameters --output-json) + set(extra_output_files "${outfile}.json") + set(${out_json_file} "${extra_output_files}" PARENT_SCOPE) + endif() + + if(moc_target) + set(_moc_parameters_file ${_moc_parameters_file}$<$>:_$>) + set(targetincludes "$") + set(targetdefines "$") + + set(targetincludes "$<$:-I$>") + set(targetdefines "$<$:-D$>") + set(_moc_parameters_list_without_genex) + set(_moc_parameters_list_with_genex) + foreach(_moc_parameter ${_moc_parameters}) + if(_moc_parameter MATCHES "\\\$<") + list(APPEND _moc_parameters_list_with_genex ${_moc_parameter}) + else() + list(APPEND _moc_parameters_list_without_genex ${_moc_parameter}) + endif() + endforeach() + + string(REPLACE ">" "$" _moc_escaped_parameters "${_moc_parameters_list_without_genex}") + string(REPLACE "," "$" _moc_escaped_parameters "${_moc_escaped_parameters}") + string(REPLACE ";" "$" _moc_escaped_parameters "${_moc_escaped_parameters}") + set(concatenated "$<$:${targetincludes};>$<$:${targetdefines};>$<$:${_moc_escaped_parameters};>") + + list(APPEND concatenated ${_moc_parameters_list_with_genex}) + set(concatenated "$,EXCLUDE,^-[DI]$>") + set(concatenated "$") + + file (GENERATE + OUTPUT ${_moc_parameters_file} + CONTENT "${concatenated}" + ) + + set(concatenated) + set(targetincludes) + set(targetdefines) + else() + string (REPLACE ";" "\n" _moc_parameters "${_moc_parameters}") + file(WRITE ${_moc_parameters_file} "${_moc_parameters}\n") + endif() + + set(_moc_extra_parameters_file @${_moc_parameters_file}) + add_custom_command(OUTPUT ${outfile} ${extra_output_files} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::moc ${_moc_extra_parameters_file} + DEPENDS ${infile} ${moc_depends} + ${_moc_working_dir} + VERBATIM) + set_source_files_properties(${infile} PROPERTIES SKIP_AUTOMOC ON) + set_source_files_properties(${outfile} PROPERTIES SKIP_AUTOMOC ON + SKIP_AUTOUIC ON + ) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.27") + set_source_files_properties(${outfile} PROPERTIES SKIP_LINTING ON) + endif() +endfunction() + +function(qt6_generate_moc infile outfile ) + # get include dirs and flags + _qt_internal_get_moc_flags(moc_flags) + get_filename_component(abs_infile ${infile} ABSOLUTE) + set(_outfile "${outfile}") + if(NOT IS_ABSOLUTE "${outfile}") + set(_outfile "${CMAKE_CURRENT_BINARY_DIR}/${outfile}") + endif() + if ("x${ARGV2}" STREQUAL "xTARGET") + set(moc_target ${ARGV3}) + endif() + _qt_internal_create_moc_command(${abs_infile} ${_outfile} "${moc_flags}" "" "${moc_target}" + "" # moc_depends + "" # out_json_file + ) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_generate_moc) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_generate_moc(${ARGV}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_generate_moc(${ARGV}) + endif() + endfunction() +endif() + +function(qt6_wrap_cpp) + # check if the first argument is a target + if(TARGET ${ARGV0}) + _qt_internal_wrap_cpp(dummy TARGET ${ARGV}) + else() + set(output_parameter ${ARGV0}) + _qt_internal_wrap_cpp(${ARGV}) + set(${output_parameter} "${${output_parameter}}" PARENT_SCOPE) + endif() + + # Forward further return values of _qt_internal_wrap_cpp to the caller. + set(no_value_options "") + set(single_value_options __QT_INTERNAL_OUTPUT_MOC_JSON_FILES) + set(multi_value_options "") + cmake_parse_arguments(arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" ${ARGV} + ) + if(NOT "${arg___QT_INTERNAL_OUTPUT_MOC_JSON_FILES}" STREQUAL "") + set(${arg___QT_INTERNAL_OUTPUT_MOC_JSON_FILES} + "${${arg___QT_INTERNAL_OUTPUT_MOC_JSON_FILES}}" PARENT_SCOPE) + endif() +endfunction() + +# _qt_internal_wrap_cpp(outfiles inputfile ... ) + +function(_qt_internal_wrap_cpp outfiles) + # get include dirs + _qt_internal_get_moc_flags(moc_flags) + + set(options) + set(oneValueArgs + TARGET + __QT_INTERNAL_OUTPUT_MOC_JSON_FILES + ) + set(multiValueArgs OPTIONS DEPENDS) + + cmake_parse_arguments(_WRAP_CPP "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(moc_files ${_WRAP_CPP_UNPARSED_ARGUMENTS}) + set(moc_options ${_WRAP_CPP_OPTIONS}) + set(moc_target ${_WRAP_CPP_TARGET}) + set(moc_depends ${_WRAP_CPP_DEPENDS}) + + set(metatypes_json_list "") + + foreach(it ${moc_files}) + get_filename_component(it ${it} ABSOLUTE) + get_filename_component(it_ext ${it} EXT) + # remove the dot + string(SUBSTRING ${it_ext} 1 -1 it_ext) + set(HEADER_REGEX "(h|hh|h\\+\\+|hm|hpp|hxx|in|txx|inl)$") + + if(it_ext MATCHES "${HEADER_REGEX}") + _qt_internal_make_output_file("${it}" moc_ cpp outfile) + set(is_header_file TRUE) + else() + set(found_source_extension FALSE) + foreach(LANG C CXX OBJC OBJCXX CUDA) + list(FIND CMAKE_${LANG}_SOURCE_FILE_EXTENSIONS "${it_ext}" + index) + if(${index} GREATER -1) + set(found_extension TRUE) + break() + endif() + endforeach() + if(found_extension) + if(TARGET ${moc_target}) + _qt_internal_make_output_file(${it} "" moc outfile) + target_sources(${moc_target} PRIVATE "${outfile}") + target_include_directories("${moc_target}" PRIVATE + "${CMAKE_CURRENT_BINARY_DIR}") + else() + if("${moc_target}" STREQUAL "") + string(JOIN "" err_msg + "qt6_wrap_cpp: TARGET parameter is empty. " + "Since the file ${it} is a source file, " + "the TARGET option must be specified.") + else() + string(JOIN "" err_msg + "qt6_wrap_cpp: TARGET \"${moc_target}\" " + "not found.") + endif() + message(FATAL_ERROR "${err_msg}") + endif() + else() + string(JOIN "" err_msg "qt6_wrap_cpp: Unknown file extension: " + "\"\.${it_ext}\".") + message(FATAL_ERROR "${err_msg}") + endif() + endif() + + set(out_json_file_var "") + if(_WRAP_CPP___QT_INTERNAL_OUTPUT_MOC_JSON_FILES) + set(out_json_file_var "out_json_file") + endif() + + _qt_internal_create_moc_command( + ${it} ${outfile} "${moc_flags}" "${moc_options}" "${moc_target}" "${moc_depends}" + "${out_json_file_var}") + list(APPEND ${outfiles} ${outfile}) + if(_WRAP_CPP___QT_INTERNAL_OUTPUT_MOC_JSON_FILES) + list(APPEND metatypes_json_list "${${out_json_file_var}}") + endif() + endforeach() + + if(is_header_file) + set(${outfiles} "${${outfiles}}" PARENT_SCOPE) + endif() + + if(metatypes_json_list) + set(${_WRAP_CPP___QT_INTERNAL_OUTPUT_MOC_JSON_FILES} + "${metatypes_json_list}" PARENT_SCOPE) + endif() +endfunction() + +# This will override the CMake upstream command, because that one is for Qt 3. +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_wrap_cpp outfiles) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_wrap_cpp("${outfiles}" ${ARGN}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_wrap_cpp("${outfiles}" ${ARGN}) + endif() + set("${outfiles}" "${${outfiles}}" PARENT_SCOPE) + endfunction() +endif() + + +# _qt6_parse_qrc_file(infile _out_depends _rc_depends) +# internal + +function(_qt6_parse_qrc_file infile _out_depends _rc_depends) + get_filename_component(rc_path ${infile} PATH) + + if(EXISTS "${infile}") + # parse file for dependencies + # all files are absolute paths or relative to the location of the qrc file + file(READ "${infile}" RC_FILE_CONTENTS) + string(REGEX MATCHALL "]*>" "" RC_FILE "${RC_FILE}") + if(NOT IS_ABSOLUTE "${RC_FILE}") + set(RC_FILE "${rc_path}/${RC_FILE}") + endif() + set(RC_DEPENDS ${RC_DEPENDS} "${RC_FILE}") + endforeach() + # Since this cmake macro is doing the dependency scanning for these files, + # let's make a configured file and add it as a dependency so cmake is run + # again when dependencies need to be recomputed. + _qt_internal_make_output_file("${infile}" "" "qrc.depends" out_depends) + configure_file("${infile}" "${out_depends}" COPYONLY) + else() + # The .qrc file does not exist (yet). Let's add a dependency and hope + # that it will be generated later + set(out_depends) + endif() + + set(${_out_depends} ${out_depends} PARENT_SCOPE) + set(${_rc_depends} ${RC_DEPENDS} PARENT_SCOPE) +endfunction() + + +# qt6_add_binary_resources(target inputfiles ... ) + +function(qt6_add_binary_resources target ) + + set(options) + set(oneValueArgs DESTINATION) + set(multiValueArgs OPTIONS) + + cmake_parse_arguments(_RCC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(rcc_files ${_RCC_UNPARSED_ARGUMENTS}) + set(rcc_options ${_RCC_OPTIONS}) + set(rcc_destination ${_RCC_DESTINATION}) + + if(NOT QT_FEATURE_zstd) + list(APPEND rcc_options "--no-zstd") + endif() + + if(NOT rcc_destination) + set(rcc_destination ${CMAKE_CURRENT_BINARY_DIR}/${target}.rcc) + endif() + + foreach(it ${rcc_files}) + get_filename_component(infile ${it} ABSOLUTE) + + _qt6_parse_qrc_file(${infile} _out_depends _rc_depends) + set_source_files_properties(${infile} PROPERTIES SKIP_AUTORCC ON) + set(infiles ${infiles} ${infile}) + set(out_depends ${out_depends} ${_out_depends}) + set(rc_depends ${rc_depends} ${_rc_depends}) + endforeach() + + add_custom_command(OUTPUT ${rcc_destination} + DEPENDS ${QT_CMAKE_EXPORT_NAMESPACE}::rcc + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::rcc + ARGS ${rcc_options} --binary --name ${target} --output ${rcc_destination} ${infiles} + DEPENDS + ${QT_CMAKE_EXPORT_NAMESPACE}::rcc + ${rc_depends} + ${out_depends} + ${infiles} + VERBATIM) + + add_custom_target(${target} ALL DEPENDS ${rcc_destination}) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_binary_resources) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_add_binary_resources(${ARGV}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_binary_resources(${ARGV}) + endif() + endfunction() +endif() + + +# qt6_add_resources(target resourcename ... +# or +# qt6_add_resources(outfiles inputfile ... ) + +function(qt6_add_resources outfiles ) + if (TARGET ${outfiles}) + cmake_parse_arguments(arg "" "OUTPUT_TARGETS" "" ${ARGN}) + _qt_internal_process_resource(${ARGV}) + if (arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${${arg_OUTPUT_TARGETS}} PARENT_SCOPE) + endif() + else() + set(options) + set(oneValueArgs) + set(multiValueArgs OPTIONS) + + cmake_parse_arguments(_RCC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(rcc_files ${_RCC_UNPARSED_ARGUMENTS}) + set(rcc_options ${_RCC_OPTIONS}) + + if("${rcc_options}" MATCHES "-binary") + message(WARNING "Use qt6_add_binary_resources for binary option") + endif() + + if(NOT QT_FEATURE_zstd) + list(APPEND rcc_options "--no-zstd") + endif() + + foreach(it ${rcc_files}) + get_filename_component(outfilename ${it} NAME_WE) + get_filename_component(infile ${it} ABSOLUTE) + set(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cpp) + + _qt6_parse_qrc_file(${infile} _out_depends _rc_depends) + set_source_files_properties(${infile} PROPERTIES SKIP_AUTORCC ON) + + add_custom_command(OUTPUT ${outfile} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::rcc + ARGS ${rcc_options} --name ${outfilename} --output ${outfile} ${infile} + MAIN_DEPENDENCY ${infile} + DEPENDS ${_rc_depends} "${_out_depends}" ${QT_CMAKE_EXPORT_NAMESPACE}::rcc + VERBATIM) + set_source_files_properties(${outfile} PROPERTIES SKIP_AUTOMOC ON + SKIP_AUTOUIC ON + SKIP_UNITY_BUILD_INCLUSION ON + SKIP_PRECOMPILE_HEADERS ON + ) + list(APPEND ${outfiles} ${outfile}) + endforeach() + set(${outfiles} ${${outfiles}} PARENT_SCOPE) + endif() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_resources outfiles) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_add_resources("${outfiles}" ${ARGN}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_resources("${outfiles}" ${ARGN}) + endif() + if(TARGET ${outfiles}) + cmake_parse_arguments(PARSE_ARGV 1 arg "" "OUTPUT_TARGETS" "") + if (arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${${arg_OUTPUT_TARGETS}} PARENT_SCOPE) + endif() + else() + set("${outfiles}" "${${outfiles}}" PARENT_SCOPE) + endif() + endfunction() +endif() + + +# qt6_add_big_resources(outfiles inputfile ... ) + +function(qt6_add_big_resources outfiles ) + if(CMAKE_GENERATOR STREQUAL "Xcode" AND IOS) + message(WARNING + "Due to CMake limitations, qt6_add_big_resources can't be used when building for iOS. " + "See https://bugreports.qt.io/browse/QTBUG-103497 for details. " + "Falling back to using qt6_add_resources. " + "Consider using qt6_add_resources directly to silence this warning." + ) + qt6_add_resources(${ARGV}) + set(${outfiles} ${${outfiles}} PARENT_SCOPE) + return() + endif() + + if (CMAKE_VERSION VERSION_LESS 3.9) + message(FATAL_ERROR, "qt6_add_big_resources requires CMake 3.9 or newer") + endif() + + set(options) + set(oneValueArgs) + set(multiValueArgs OPTIONS) + + cmake_parse_arguments(_RCC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(rcc_files ${_RCC_UNPARSED_ARGUMENTS}) + set(rcc_options ${_RCC_OPTIONS}) + + if("${rcc_options}" MATCHES "-binary") + message(WARNING "Use qt6_add_binary_resources for binary option") + endif() + + if(NOT QT_FEATURE_zstd) + list(APPEND rcc_options "--no-zstd") + endif() + + foreach(it ${rcc_files}) + get_filename_component(outfilename ${it} NAME_WE) + + # Provide unique targets and output file names + # in case we add multiple .qrc files with the same base name. + string(MAKE_C_IDENTIFIER "_qt_big_resource_count_${outfilename}" prop) + get_property(count GLOBAL PROPERTY ${prop}) + if(count) + string(APPEND outfilename "_${count}") + else() + set(count 0) + endif() + math(EXPR count "${count} + 1") + set_property(GLOBAL PROPERTY ${prop} ${count}) + + get_filename_component(infile ${it} ABSOLUTE) + set(tmpoutfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}tmp.cpp) + set(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.o) + + _qt6_parse_qrc_file(${infile} _out_depends _rc_depends) + set_source_files_properties(${infile} PROPERTIES SKIP_AUTOGEN ON) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.27") + set_source_files_properties(${tmpoutfile} PROPERTIES SKIP_LINTING ON) + endif() + add_custom_command(OUTPUT ${tmpoutfile} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::rcc ${rcc_options} --name ${outfilename} --pass 1 --output ${tmpoutfile} ${infile} + DEPENDS ${infile} ${_rc_depends} "${out_depends}" ${QT_CMAKE_EXPORT_NAMESPACE}::rcc + COMMENT "Running rcc pass 1 for resource ${outfilename}" + VERBATIM) + add_custom_target(big_resources_${outfilename} ALL DEPENDS ${tmpoutfile}) + _qt_internal_add_rcc_pass2( + RESOURCE_NAME ${outfilename} + RCC_OPTIONS ${rcc_options} + OBJECT_LIB rcc_object_${outfilename} + QRC_FILE ${infile} + PASS1_OUTPUT_FILE ${tmpoutfile} + OUT_OBJECT_FILE ${outfile} + ) + add_dependencies(rcc_object_${outfilename} big_resources_${outfilename}) + list(APPEND ${outfiles} ${outfile}) + endforeach() + set(${outfiles} ${${outfiles}} PARENT_SCOPE) +endfunction() + +function(_qt_internal_add_rcc_pass2) + set(options) + set(oneValueArgs + RESOURCE_NAME + OBJECT_LIB + QRC_FILE + PASS1_OUTPUT_FILE + OUT_OBJECT_FILE + ) + set(multiValueArgs + RCC_OPTIONS + ) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + add_library(${arg_OBJECT_LIB} OBJECT ${arg_PASS1_OUTPUT_FILE}) + _qt_internal_set_up_static_runtime_library(${arg_OBJECT_LIB}) + target_compile_definitions(${arg_OBJECT_LIB} PUBLIC + "$") + set_target_properties(${arg_OBJECT_LIB} PROPERTIES + AUTOMOC OFF + AUTOUIC OFF) + # The modification of TARGET_OBJECTS needs the following change in cmake + # https://gitlab.kitware.com/cmake/cmake/commit/93c89bc75ceee599ba7c08b8fe1ac5104942054f + add_custom_command( + OUTPUT ${arg_OUT_OBJECT_FILE} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::rcc + ${arg_RCC_OPTIONS} --name ${arg_RESOURCE_NAME} --pass 2 + --temp $ + --output ${arg_OUT_OBJECT_FILE} ${arg_QRC_FILE} + DEPENDS ${arg_OBJECT_LIB} $ + ${QT_CMAKE_EXPORT_NAMESPACE}::rcc + COMMENT "Running rcc pass 2 for resource ${arg_RESOURCE_NAME}" + VERBATIM) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_big_resources outfiles) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_add_big_resources(${outfiles} ${ARGN}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_big_resources(${outfiles} ${ARGN}) + endif() + set("${outfiles}" "${${outfiles}}" PARENT_SCOPE) + endfunction() +endif() + +function(_qt_internal_apply_win_prefix_and_suffix target) + if(WIN32) + # Table of prefix / suffixes for MSVC libraries as qmake expects them to be created. + # static - Qt6EdidSupport.lib (platform support libraries / or static QtCore, etc) + # shared - Qt6Core.dll + # shared import library - Qt6Core.lib + # module aka Qt plugin - qwindows.dll + # module import library - qwindows.lib + # + # The CMake defaults are fine for us. + + # Table of prefix / suffixes for MinGW libraries as qmake expects them to be created. + # static - libQt6EdidSupport.a (platform support libraries / or static QtCore, etc) + # shared - Qt6Core.dll + # shared import library - libQt6Core.a + # module aka Qt plugin - qwindows.dll + # module import library - libqwindows.a + # + # CMake for Windows-GNU platforms defaults the prefix to "lib". + # CMake for Windows-GNU platforms defaults the import suffix to ".dll.a". + # These CMake defaults are not ok for us. + + # This should cover both MINGW with GCC and CLANG. + if(NOT MSVC) + set_property(TARGET "${target}" PROPERTY IMPORT_SUFFIX ".a") + + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "STATIC_LIBRARY") + set_property(TARGET "${target}" PROPERTY PREFIX "lib") + else() + set_property(TARGET "${target}" PROPERTY PREFIX "") + set_property(TARGET "${target}" PROPERTY IMPORT_PREFIX "lib") + endif() + endif() + endif() +endfunction() + +set(_Qt6_COMPONENT_PATH "${CMAKE_CURRENT_LIST_DIR}/..") + +# Wrapper function that adds an executable with some Qt specific behavior. +# Some scenarios require steps to be deferred to the end of the current +# directory scope so that the caller has an opportunity to modify certain +# target properties. +function(qt6_add_executable target) + cmake_parse_arguments(PARSE_ARGV 1 arg "MANUAL_FINALIZATION" "" "") + + _qt_internal_warn_about_example_add_subdirectory() + + _qt_internal_create_executable("${target}" ${arg_UNPARSED_ARGUMENTS}) + target_link_libraries("${target}" PRIVATE Qt6::Core) + set_property(TARGET ${target} PROPERTY _qt_expects_finalization TRUE) + + if(arg_MANUAL_FINALIZATION) + # Caller says they will call qt6_finalize_target() themselves later + return() + endif() + + _qt_internal_finalize_target_defer("${target}") +endfunction() + +# Just like for qt_add_resources, we should disable zstd compression when cross-compiling to a +# target that doesn't support zstd decompression, even if the host tool supports it. +# Allow an opt out via a QT_NO_AUTORCC_ZSTD variable. +function(_qt_internal_disable_autorcc_zstd_when_not_supported target) + if(TARGET "${target}" + AND DEFINED QT_FEATURE_zstd + AND NOT QT_FEATURE_zstd + AND NOT QT_NO_AUTORCC_ZSTD) + get_target_property(target_type ${target} TYPE) + if(NOT target_type STREQUAL "INTERFACE_LIBRARY") + set_property(TARGET "${target}" APPEND PROPERTY AUTORCC_OPTIONS "--no-zstd") + endif() + endif() +endfunction() + +function(_qt_internal_create_executable target) + if(ANDROID) + list(REMOVE_ITEM ARGN "WIN32" "MACOSX_BUNDLE") + cmake_policy(PUSH) + __qt_internal_set_cmp0156() + add_library("${target}" MODULE ${ARGN}) + cmake_policy(POP) + # On our qmake builds we do don't compile the executables with + # visibility=hidden. Not having this flag set will cause the + # executable to have main() hidden and can then no longer be loaded + # through dlopen() + set_property(TARGET "${target}" PROPERTY C_VISIBILITY_PRESET default) + set_property(TARGET "${target}" PROPERTY CXX_VISIBILITY_PRESET default) + set_property(TARGET "${target}" PROPERTY OBJC_VISIBILITY_PRESET default) + set_property(TARGET "${target}" PROPERTY OBJCXX_VISIBILITY_PRESET default) + set_property(TARGET "${target}" + PROPERTY _qt_android_apply_arch_suffix_called_from_qt_impl TRUE) + qt6_android_apply_arch_suffix("${target}") + set_property(TARGET "${target}" PROPERTY _qt_is_android_executable TRUE) + else() + cmake_policy(PUSH) + __qt_internal_set_cmp0156() + add_executable("${target}" ${ARGN}) + cmake_policy(POP) + endif() + + _qt_internal_disable_autorcc_zstd_when_not_supported("${target}") + _qt_internal_set_up_static_runtime_library("${target}") +endfunction() + +function(_qt_internal_finalize_executable target) + # We can't evaluate generator expressions at configure time, so we can't + # ask for any transitive properties or even the full library dependency + # chain. + # We can still look at the immediate dependencies + # (and recursively their dependencies) and query + # any that are not expressed as generator expressions. For any we can + # identify as a CMake target known to the current scope, we can check if + # that target has a finalizer to be called. This is expected to cover the + # vast majority of use cases, since projects will typically link directly + # to Qt::* targets. For the cases where this isn't so, the project will be + # responsible for calling any relevant functions themselves instead of + # relying on these automatic finalization calls. + set(finalizers) + + __qt_internal_collect_all_target_dependencies("${target}" dep_targets) + + if(dep_targets) + foreach(dep IN LISTS dep_targets) + get_target_property(dep_finalizers ${dep} + INTERFACE_QT_EXECUTABLE_FINALIZERS + ) + if(dep_finalizers) + list(APPEND finalizers ${dep_finalizers}) + endif() + endforeach() + list(REMOVE_DUPLICATES finalizers) + endif() + + if(finalizers) + if(CMAKE_VERSION VERSION_LESS 3.18) + # cmake_language() not available, fall back to the slower method of + # writing a file and including it + set(contents "") + foreach(finalizer_func IN LISTS finalizers) + string(APPEND contents "${finalizer_func}(${target})\n") + endforeach() + set(finalizer_file "${CMAKE_CURRENT_BINARY_DIR}/.qt/finalize_${target}.cmake") + file(WRITE ${finalizer_file} "${contents}") + include(${finalizer_file}) + else() + foreach(finalizer_func IN LISTS finalizers) + cmake_language(CALL ${finalizer_func} ${target}) + endforeach() + endif() + endif() + + if(EMSCRIPTEN) + _qt_internal_finalize_wasm_app("${target}") + endif() + + if(APPLE) + if(NOT CMAKE_SYSTEM_NAME OR CMAKE_SYSTEM_NAME STREQUAL "Darwin") + # macOS + _qt_internal_finalize_macos_app("${target}") + else() + _qt_internal_finalize_uikit_app("${target}") + endif() + endif() + + # For finalizer mode of plugin importing to work safely, we need to know the list of Qt + # dependencies the target has, but those might be added later than the qt_add_executable call. + # Most of our examples are like that. Only enable finalizer mode when we are sure that the user + # manually called qt_finalize_target at the end of their CMake project, or it was automatically + # done via a deferred call. This is also applicable to the resource object finalizer. + get_target_property(is_immediately_finalized "${target}" _qt_is_immediately_finalized) + if(NOT is_immediately_finalized) + __qt_internal_apply_plugin_imports_finalizer_mode("${target}") + __qt_internal_process_dependency_object_libraries("${target}") + endif() +endfunction() + +# If a task needs to run before any targets are finalized in the current directory +# scope, call this function and pass the ID of that task as the argument. +function(_qt_internal_delay_finalization_until_after defer_id) + set_property(DIRECTORY APPEND PROPERTY qt_internal_finalizers_wait_for_ids "${defer_id}") +endfunction() + +function(qt6_finalize_target target) + set_property(TARGET ${target} PROPERTY _qt_expects_finalization FALSE) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.19") + cmake_language(DEFER GET_CALL_IDS ids_queued) + get_directory_property(wait_for_ids qt_internal_finalizers_wait_for_ids) + while(wait_for_ids) + list(GET wait_for_ids 0 id_to_wait_for) + if(id_to_wait_for IN_LIST ids_queued) + # Something else needs to run before we finalize targets. + # Try again later by re-deferring ourselves, which effectively + # puts us at the end of the current list of deferred actions. + cmake_language(EVAL CODE "cmake_language(DEFER CALL ${CMAKE_CURRENT_FUNCTION} ${ARGV})") + set_directory_properties(PROPERTIES + qt_internal_finalizers_wait_for_ids "${wait_for_ids}" + ) + return() + endif() + list(POP_FRONT wait_for_ids) + endwhile() + # No other deferred tasks to wait for + set_directory_properties(PROPERTIES qt_internal_finalizers_wait_for_ids "") + endif() + + if(NOT TARGET "${target}") + message(FATAL_ERROR "No target '${target}' found in current scope.") + endif() + + get_target_property(is_finalized "${target}" _qt_is_finalized) + if(is_finalized) + message(AUTHOR_WARNING + "Tried to call qt6_finalize_target twice on target '${target}'. " + "Did you forget to specify MANUAL_FINALIZATION to qt6_add_executable, " + "qt6_add_library or qt6_add_plugin?") + return() + endif() + + _qt_internal_expose_deferred_files_to_ide(${target}) + _qt_internal_finalize_source_groups(${target}) + get_target_property(target_type ${target} TYPE) + get_target_property(is_android_executable "${target}" _qt_is_android_executable) + + if(target_type STREQUAL "EXECUTABLE" OR is_android_executable) + _qt_internal_finalize_executable(${ARGV}) + endif() + + if(APPLE) + # Tell CMake to generate run-scheme for the executable when generating + # Xcode projects. This avoids Xcode auto-generating default schemes for + # all targets, which includes internal and build-only targets. + get_target_property(generate_scheme "${target}" XCODE_GENERATE_SCHEME) + if(generate_scheme MATCHES "-NOTFOUND" AND ( + target_type STREQUAL "EXECUTABLE" OR + target_type STREQUAL "SHARED_LIBRARY" OR + target_type STREQUAL "STATIC_LIBRARY" OR + target_type STREQUAL "MODULE_LIBRARY")) + set_property(TARGET "${target}" PROPERTY XCODE_GENERATE_SCHEME TRUE) + endif() + endif() + + if(target_type STREQUAL "SHARED_LIBRARY" OR + target_type STREQUAL "STATIC_LIBRARY" OR + target_type STREQUAL "MODULE_LIBRARY" OR + target_type STREQUAL "OBJECT_LIBRARY") + get_target_property(is_immediately_finalized "${target}" _qt_is_immediately_finalized) + get_target_property(uses_automoc ${target} AUTOMOC) + if(uses_automoc AND NOT is_immediately_finalized) + qt6_extract_metatypes(${target}) + endif() + endif() + + set_target_properties(${target} PROPERTIES _qt_is_finalized TRUE) +endfunction() + +function(_qt_internal_finalize_target_defer target) + # Defer the finalization if we can. When the caller's project requires + # CMake 3.19 or later, this makes the calls to this function concise while + # still allowing target property modification before finalization. + if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.19) + # Need to wrap in an EVAL CODE or else ${target} won't be evaluated + # due to special behavior of cmake_language() argument handling + cmake_language(EVAL CODE "cmake_language(DEFER CALL qt6_finalize_target ${target})") + elseif(QT_BUILDING_QT AND QT_INTERNAL_USE_POOR_MANS_SCOPE_FINALIZER) + qt_add_list_file_finalizer(qt6_finalize_target "${target}") + else() + set_target_properties("${target}" PROPERTIES _qt_is_immediately_finalized TRUE) + qt6_finalize_target("${target}") + endif() +endfunction() + +function(_qt_internal_finalize_source_groups target) + if(NOT ("${CMAKE_GENERATOR}" STREQUAL "Xcode" + OR "${CMAKE_GENERATOR}" MATCHES "^Visual Studio")) + return() + endif() + + get_target_property(sources ${target} SOURCES) + if(NOT sources) + return() + endif() + + get_target_property(source_dir ${target} SOURCE_DIR) + get_target_property(binary_dir ${target} BINARY_DIR) + + get_property(generated_source_group GLOBAL PROPERTY AUTOGEN_SOURCE_GROUP) + if(NOT generated_source_group) + set(generated_source_group "Source Files/Generated") + endif() + + foreach(source IN LISTS sources) + string(GENEX_STRIP "${source}" source) + + if(IS_ABSOLUTE ${source}) + set(source_file_path "${source}") + else() + # Resolve absolute path. Can't use LOCATION, as that + # will error out if the file doesn't exist :( + get_filename_component(source_file_path "${source}" + ABSOLUTE BASE_DIR "${source_dir}") + if(NOT EXISTS ${source_file_path}) + # Likely generated file, will end up in build dir + get_filename_component(source_file_path "${source}" + ABSOLUTE BASE_DIR "${binary_dir}") + endif() + endif() + + # Include qml files in "Source Files". Can not be done via regex, + # due to https://gitlab.kitware.com/cmake/cmake/-/issues/25597 + if(${source_file_path} MATCHES "\\.qml$") + source_group("Source Files" FILES ${source_file_path}) + endif() + + get_source_file_property(is_generated "${source_file_path}" GENERATED) + if(${is_generated}) + source_group(${generated_source_group} FILES ${source_file_path}) + endif() + endforeach() +endfunction() + +function(_qt_internal_darwin_permission_finalizer target) + get_target_property(plist_file "${target}" MACOSX_BUNDLE_INFO_PLIST) + if(NOT plist_file) + return() + endif() + foreach(plugin_target IN LISTS QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_permissions) + set(versioned_plugin_target "${QT_CMAKE_EXPORT_NAMESPACE}::${plugin_target}") + get_target_property(usage_descriptions + ${versioned_plugin_target} + _qt_info_plist_usage_descriptions) + foreach(usage_description_key IN LISTS usage_descriptions) + execute_process(COMMAND "/usr/libexec/PlistBuddy" + -c "print ${usage_description_key}" "${plist_file}" + OUTPUT_VARIABLE usage_description + ERROR_VARIABLE plist_error) + if(usage_description AND NOT plist_error) + set_target_properties("${target}" + PROPERTIES "_qt_has_${plugin_target}_usage_description" TRUE) + qt6_import_plugins(${target} INCLUDE ${versioned_plugin_target}) + endif() + endforeach() + endforeach() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_executable) + qt6_add_executable(${ARGV}) + endfunction() + function(qt_finalize_target) + qt6_finalize_target(${ARGV}) + endfunction() + + # Kept for compatibility with Qt Creator 4.15 wizards + function(qt_finalize_executable) + qt6_finalize_target(${ARGV}) + endfunction() +endif() + +function(_qt_get_plugin_name_with_version target out_var) + string(REGEX REPLACE "^Qt::(.+)" "Qt${QT_DEFAULT_MAJOR_VERSION}::\\1" + qt_plugin_with_version "${target}") + if(TARGET "${qt_plugin_with_version}") + set("${out_var}" "${qt_plugin_with_version}" PARENT_SCOPE) + else() + set("${out_var}" "" PARENT_SCOPE) + endif() +endfunction() + +macro(_qt_import_plugin target plugin) + set(_final_plugin_name "${plugin}") + if(NOT TARGET "${plugin}") + _qt_get_plugin_name_with_version("${plugin}" _qt_plugin_with_version_name) + if(TARGET "${_qt_plugin_with_version_name}") + set(_final_plugin_name "${_qt_plugin_with_version_name}") + endif() + endif() + + if(NOT TARGET "${_final_plugin_name}") + message( + "Warning: plug-in ${_final_plugin_name} is not known to the current Qt installation.") + else() + get_target_property(_plugin_class_name "${_final_plugin_name}" QT_PLUGIN_CLASS_NAME) + if(_plugin_class_name) + set_property(TARGET "${target}" APPEND PROPERTY QT_PLUGINS "${plugin}") + endif() + endif() +endmacro() + +function(_qt_internal_disable_static_default_plugins target) + set_target_properties(${target} PROPERTIES QT_DEFAULT_PLUGINS 0) +endfunction() + +function(qt6_import_plugins target) + cmake_parse_arguments(arg "NO_DEFAULT" "" "INCLUDE;EXCLUDE;INCLUDE_BY_TYPE;EXCLUDE_BY_TYPE" ${ARGN}) + + # Handle NO_DEFAULT + if(${arg_NO_DEFAULT}) + _qt_internal_disable_static_default_plugins("${target}") + endif() + + # Handle INCLUDE + foreach(plugin ${arg_INCLUDE}) + _qt_import_plugin("${target}" "${plugin}") + endforeach() + + # Handle EXCLUDE + foreach(plugin ${arg_EXCLUDE}) + set_property(TARGET "${target}" APPEND PROPERTY QT_NO_PLUGINS "${plugin}") + endforeach() + + # Handle INCLUDE_BY_TYPE + set(_current_type "") + foreach(_arg ${arg_INCLUDE_BY_TYPE}) + string(REGEX REPLACE "[-/]" "_" _plugin_type "${_arg}") + list(FIND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_plugin_type}" _has_plugin_type) + + if(${_has_plugin_type} GREATER_EQUAL 0) + set(_current_type "${_plugin_type}") + else() + if("${_current_type}" STREQUAL "") + message(FATAL_ERROR "qt_import_plugins: invalid syntax for INCLUDE_BY_TYPE") + endif() + + # Check if passed plugin target name is a version-less one, and make a version-full + # one. + set_property(TARGET "${target}" APPEND PROPERTY "QT_PLUGINS_${_current_type}" "${_arg}") + set_property(TARGET "${target}" APPEND PROPERTY "_qt_plugins_by_type" "${_arg}") + _qt_get_plugin_name_with_version("${_arg}" qt_plugin_with_version) + + # TODO: Do we really need this check? We didn't have it in Qt5, and plugin targets + # wrapped in genexes end up causing warnings, but we explicitly use GENEX_EVAL to + # support them. + if(NOT TARGET "${_arg}" AND NOT TARGET "${qt_plugin_with_version}") + message("Warning: plug-in ${_arg} is not known to the current Qt installation.") + endif() + endif() + endforeach() + + # Handle EXCLUDE_BY_TYPE + foreach(_arg ${arg_EXCLUDE_BY_TYPE}) + string(REGEX REPLACE "[-/]" "_" _plugin_type "${_arg}") + set_property(TARGET "${target}" PROPERTY "QT_PLUGINS_${_plugin_type}" "-") + endforeach() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_import_plugins) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_import_plugins(${ARGV}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_import_plugins(${ARGV}) + endif() + endfunction() +endif() + +# This function is currently in Technical Preview. It's signature may change or be removed entirely. +function(qt6_set_finalizer_mode target) + cmake_parse_arguments(arg "ENABLE;DISABLE" "" "MODES" ${ARGN}) + if(NOT arg_ENABLE AND NOT arg_DISABLE) + message(FATAL_ERROR "No option was specified whether to enable or disable the modes.") + elseif(arg_ENABLE AND arg_DISABLE) + message(FATAL_ERROR "Both ENABLE and DISABLE options were specified.") + endif() + if(NOT arg_MODES) + message(FATAL_ERROR "No modes were specified in qt6_set_finalizer_mode() call.") + endif() + + if(arg_ENABLE) + set(value "TRUE") + elseif(arg_DISABLE) + set(value "FALSE") + endif() + + foreach(mode ${arg_MODES}) + __qt_internal_enable_finalizer_mode("${target}" "${mode}" "${value}") + endforeach() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_set_finalizer_mode) + qt6_set_finalizer_mode(${ARGV}) + endfunction() +endif() + +function(_qt_internal_assign_to_internal_targets_folder target) + get_property(folder_name GLOBAL PROPERTY QT_TARGETS_FOLDER) + if(NOT "${folder_name}" STREQUAL "") + set_property(TARGET ${target} PROPERTY FOLDER "${folder_name}") + endif() +endfunction() + +function(_qt_internal_get_target_autogen_build_dir target out_var) + get_property(target_autogen_build_dir TARGET ${target} PROPERTY AUTOGEN_BUILD_DIR) + if(target_autogen_build_dir) + set(${out_var} "${target_autogen_build_dir}" PARENT_SCOPE) + else() + get_property(target_binary_dir TARGET ${target} PROPERTY BINARY_DIR) + set(${out_var} "${target_binary_dir}/${target}_autogen" PARENT_SCOPE) + endif() +endfunction() + +function(_qt_internal_should_install_metatypes target) + set(args_option + INTERNAL_INSTALL + ) + set(args_single + OUT_VAR + ) + set(args_multi + ) + + cmake_parse_arguments(arg + "${args_option}" + "${args_single}" + "${args_multi}" ${ARGN}) + + # Check whether the generated json file needs to be installed. + # Executable metatypes.json files should not be installed. Qt non-prefix builds should also + # not install the files. + set(should_install FALSE) + + get_target_property(target_type ${target} TYPE) + if(NOT target_type STREQUAL "EXECUTABLE" AND arg_INTERNAL_INSTALL) + set(should_install TRUE) + endif() + set(${arg_OUT_VAR} "${should_install}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_get_metatypes_install_dir internal_install_dir arch_data_dir out_var) + # Automatically fill default install args when not specified. + if(NOT internal_install_dir) + # INSTALL_ARCHDATADIR is not set when QtBuildInternals is not loaded + # (when not doing a Qt build). Default to a hardcoded location for user + # projects (will likely be wrong). + if(arch_data_dir) + set(install_dir "${arch_data_dir}/metatypes") + else() + set(install_dir "lib/metatypes") + endif() + else() + set(install_dir "${internal_install_dir}") + endif() + set(${out_var} "${install_dir}" PARENT_SCOPE) +endfunction() + +# Propagates the build time metatypes file via INTERFACE_SOURCES (using $) +# and saves the path and file name in properties, so that they can be queryied in the qml api +# implementation for the purpose of duplicating a qml module backing library's metatypes in its +# associated plugin. This is required for qmltyperegistrar to get the full set of foreign types +# when projects link to the plugin and not the backing library. +function(_qt_internal_assign_build_metatypes_files_and_properties target) + get_target_property(existing_meta_types_file ${target} INTERFACE_QT_META_TYPES_BUILD_FILE) + if (existing_meta_types_file) + return() + endif() + + set(args_option + ) + set(args_single + METATYPES_FILE_NAME + METATYPES_FILE_PATH + ) + set(args_multi + ) + + cmake_parse_arguments(arg + "${args_option}" + "${args_single}" + "${args_multi}" ${ARGN}) + + if(NOT arg_METATYPES_FILE_NAME) + message(FATAL_ERROR "METATYPES_FILE_NAME must be specified") + endif() + + if(NOT arg_METATYPES_FILE_PATH) + message(FATAL_ERROR "METATYPES_FILE_PATH must be specified") + endif() + + set(metatypes_file_name "${arg_METATYPES_FILE_NAME}") + set(metatypes_file_path "${arg_METATYPES_FILE_PATH}") + + # Set up consumption of files via INTERFACE_SOURCES. + set(consumes_metatypes "$>") + set(metatypes_file_genex_build + "$>" + ) + target_sources(${target} INTERFACE ${metatypes_file_genex_build}) + + set_target_properties(${target} PROPERTIES + INTERFACE_QT_MODULE_HAS_META_TYPES YES + # The property name is a bit misleading, it's not wrapped in a genex. + INTERFACE_QT_META_TYPES_BUILD_FILE "${metatypes_file_path}" + INTERFACE_QT_META_TYPES_FILE_NAME "${metatypes_file_name}" + ) +endfunction() + +# Same as above, but with $. +function(_qt_internal_assign_install_metatypes_files_and_properties target) + get_target_property(existing_meta_types_file ${target} INTERFACE_QT_META_TYPES_INSTALL_FILE) + if (existing_meta_types_file) + return() + endif() + + set(args_option + ) + set(args_single + INSTALL_DIR + ) + set(args_multi + ) + + cmake_parse_arguments(arg + "${args_option}" + "${args_single}" + "${args_multi}" ${ARGN}) + + + get_target_property(metatypes_file_name "${target}" INTERFACE_QT_META_TYPES_FILE_NAME) + + if(NOT metatypes_file_name) + message(FATAL_ERROR "INTERFACE_QT_META_TYPES_FILE_NAME of target ${target} is empty") + endif() + + if(NOT arg_INSTALL_DIR) + message(FATAL_ERROR "INSTALL_DIR must be specified") + endif() + + # Set up consumption of files via INTERFACE_SOURCES. + set(consumes_metatypes "$>") + + set(install_dir "${arg_INSTALL_DIR}") + + set(metatypes_file_install_path "${install_dir}/${metatypes_file_name}") + set(metatypes_file_install_path_genex "$/${metatypes_file_install_path}") + set(metatypes_file_genex_install + "$>" + ) + target_sources(${target} INTERFACE ${metatypes_file_genex_install}) + + set_target_properties(${target} PROPERTIES + INTERFACE_QT_META_TYPES_INSTALL_FILE "${metatypes_file_install_path}" + ) +endfunction() + + +function(qt6_extract_metatypes target) + + get_target_property(existing_meta_types_file ${target} INTERFACE_QT_META_TYPES_BUILD_FILE) + if (existing_meta_types_file) + return() + endif() + + set(args_option + # TODO: Move this into a separate internal function, so it doesn't pollute the public one. + # When given, metatypes files will be installed into the default Qt + # metatypes folder. Only to be used by the Qt build. + __QT_INTERNAL_INSTALL + ) + set(args_single + # TODO: Move this into a separate internal function, so it doesn't pollute the public one. + # Location where to install the metatypes file. Only used if + # __QT_INTERNAL_INSTALL is given. It defaults to the + # ${CMAKE_INSTALL_PREFIX}/${INSTALL_ARCHDATADIR}/metatypes directory. + # Executable metatypes files are never installed. + __QT_INTERNAL_INSTALL_DIR + + OUTPUT_FILES + ) + set(args_multi + MANUAL_MOC_JSON_FILES + ) + + cmake_parse_arguments(arg + "${args_option}" + "${args_single}" + "${args_multi}" ${ARGN}) + + get_target_property(target_type ${target} TYPE) + if (target_type STREQUAL "INTERFACE_LIBRARY") + message(FATAL_ERROR "Meta types generation does not work on interface libraries") + return() + endif() + + if (CMAKE_VERSION VERSION_LESS "3.16.0") + message(FATAL_ERROR "Meta types generation requires CMake >= 3.16") + return() + endif() + + get_target_property(target_binary_dir ${target} BINARY_DIR) + set(type_list_file "${target_binary_dir}/meta_types/${target}_json_file_list.txt") + set(type_list_file_manual "${target_binary_dir}/meta_types/${target}_json_file_list_manual.txt") + + set(target_autogen_build_dir "") + _qt_internal_get_target_autogen_build_dir(${target} target_autogen_build_dir) + + get_target_property(uses_automoc ${target} AUTOMOC) + set(automoc_args) + set(automoc_dependencies) + # Handle automoc generated data + if (uses_automoc) + # Tell automoc to output json files) + set_property(TARGET "${target}" APPEND PROPERTY + AUTOMOC_MOC_OPTIONS "--output-json" + ) + + get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(NOT is_multi_config) + set(cmake_autogen_cache_file + "${target_binary_dir}/CMakeFiles/${target}_autogen.dir/ParseCache.txt") + set(multi_config_args + --cmake-autogen-include-dir-path "${target_autogen_build_dir}/include" + ) + else() + set(cmake_autogen_cache_file + "${target_binary_dir}/CMakeFiles/${target}_autogen.dir/ParseCache_$.txt") + set(multi_config_args + --cmake-autogen-include-dir-path "${target_autogen_build_dir}/include_$" + "--cmake-multi-config") + endif() + + set(cmake_autogen_info_file + "${target_binary_dir}/CMakeFiles/${target}_autogen.dir/AutogenInfo.json") + + set (use_dep_files FALSE) + if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.17") # Requires automoc changes present only in 3.17 + if(CMAKE_GENERATOR STREQUAL "Ninja" OR + CMAKE_GENERATOR STREQUAL "Ninja Multi-Config" OR + (CMAKE_GENERATOR MATCHES "Makefiles" AND + CMAKE_VERSION VERSION_GREATER_EQUAL "3.28")) + if(DEFINED QT_USE_CMAKE_DEPFILES) + set(use_dep_files ${QT_USE_CMAKE_DEPFILES}) + else() + set(use_dep_files TRUE) + endif() + endif() + endif() + + set(cmake_automoc_parser_timestamp "${type_list_file}.timestamp") + + if (NOT use_dep_files) + # When a project is configured with a Visual Studio generator, CMake's + # cmQtAutoGenInitializer::InitAutogenTarget() can take one of two code paths on how to + # handle AUTOMOC rules. + # It either creates a ${target}_autogen custom target or uses PRE_BUILD build events. + # + # The latter in considered an optimization and is used by CMake when possible. + # Unfortunately that breaks our add_dependency call because we expect on _autogen target + # to always exist. + # + # Ensure the PRE_BUILD path is not taken by generating a dummy header file and adding it + # as a source file to the target. This causes the file to be added to + # cmQtAutoGenInitializer::AutogenTarget.DependFiles, which disables the PRE_BUILD path. + if(CMAKE_GENERATOR MATCHES "Visual Studio") + # The file name should be target specific, but still short, so we don't hit path + # length issues. + string(MAKE_C_IDENTIFIER "ddf_${target}" dummy_dependency_file) + set(dummy_out_file "${CMAKE_CURRENT_BINARY_DIR}/${dummy_dependency_file}.h") + + # The content shouldn't be empty so we don't trigger AUTOMOC warnings about it. + file(GENERATE OUTPUT "${dummy_out_file}" CONTENT "//") + set_source_files_properties("${dummy_out_file}" PROPERTIES + GENERATED TRUE + SKIP_AUTOGEN OFF) + target_sources("${target}" PRIVATE "${dummy_out_file}") + endif() + + add_custom_target(${target}_automoc_json_extraction + DEPENDS ${QT_CMAKE_EXPORT_NAMESPACE}::cmake_automoc_parser + BYPRODUCTS + ${type_list_file} + "${cmake_automoc_parser_timestamp}" + COMMAND + ${QT_CMAKE_EXPORT_NAMESPACE}::cmake_automoc_parser + --cmake-autogen-cache-file "${cmake_autogen_cache_file}" + --cmake-autogen-info-file "${cmake_autogen_info_file}" + --output-file-path "${type_list_file}" + --timestamp-file-path "${cmake_automoc_parser_timestamp}" + ${multi_config_args} + COMMENT "Running AUTOMOC file extraction for target ${target}" + COMMAND_EXPAND_LISTS + ) + add_dependencies(${target}_automoc_json_extraction ${target}_autogen) + _qt_internal_assign_to_internal_targets_folder(${target}_automoc_json_extraction) + else() + set(timestamp_file "${target_autogen_build_dir}/timestamp") + set(timestamp_file_with_config "${timestamp_file}_$") + if (is_multi_config AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.29" + AND NOT QT_INTERNAL_USE_OLD_AUTOGEN_GRAPH_MULTI_CONFIG_METATYPES) + string(JOIN "" timestamp_genex + "$>," + "${timestamp_file_with_config},${timestamp_file}>") + set(cmake_autogen_timestamp_file "${timestamp_genex}") + else() + set(cmake_autogen_timestamp_file ${timestamp_file}) + endif() + + add_custom_command(OUTPUT ${type_list_file} + DEPENDS ${QT_CMAKE_EXPORT_NAMESPACE}::cmake_automoc_parser + ${cmake_autogen_timestamp_file} + BYPRODUCTS "${cmake_automoc_parser_timestamp}" + COMMAND + ${QT_CMAKE_EXPORT_NAMESPACE}::cmake_automoc_parser + --cmake-autogen-cache-file "${cmake_autogen_cache_file}" + --cmake-autogen-info-file "${cmake_autogen_info_file}" + --output-file-path "${type_list_file}" + --timestamp-file-path "${cmake_automoc_parser_timestamp}" + ${multi_config_args} + COMMENT "Running AUTOMOC file extraction for target ${target}" + COMMAND_EXPAND_LISTS + VERBATIM + ) + + endif() + set(automoc_args "@${type_list_file}") + set(automoc_dependencies "${type_list_file}") + endif() + + set(manual_args) + set(manual_dependencies) + if(arg_MANUAL_MOC_JSON_FILES) + list(REMOVE_DUPLICATES arg_MANUAL_MOC_JSON_FILES) + file(GENERATE + OUTPUT ${type_list_file_manual} + CONTENT "$,\n>" + ) + list(APPEND manual_dependencies ${arg_MANUAL_MOC_JSON_FILES} ${type_list_file_manual}) + set(manual_args "@${type_list_file_manual}") + endif() + + if (NOT manual_args AND NOT automoc_args) + message(FATAL_ERROR "Metatype generation requires either the use of AUTOMOC or a manual list of generated json files") + endif() + + if (CMAKE_BUILD_TYPE AND NOT is_multi_config) + string(TOLOWER ${target}_${CMAKE_BUILD_TYPE} target_lowercase) + else() + string(TOLOWER ${target} target_lowercase) + endif() + + set(metatypes_file_name "qt6${target_lowercase}_metatypes.json") + set(metatypes_file "${target_binary_dir}/meta_types/${metatypes_file_name}") + set(metatypes_file_gen "${target_binary_dir}/meta_types/${metatypes_file_name}.gen") + + set(metatypes_dep_file_name "qt6${target_lowercase}_metatypes_dep.txt") + set(metatypes_dep_file "${target_binary_dir}/meta_types/${metatypes_dep_file_name}") + + # Due to generated source file dependency rules being tied to the directory + # scope in which they are created it is not possible for other targets which + # are defined in a separate scope to see these rules. This leads to failures + # in locating the generated source files. + # To work around this we write a dummy file to disk to make sure targets + # which link against the current target do not produce the error. This dummy + # file is then replaced with the contents of the generated file during + # build. + if (NOT EXISTS ${metatypes_file}) + file(MAKE_DIRECTORY "${target_binary_dir}/meta_types") + file(TOUCH ${metatypes_file}) + endif() + + add_custom_command( + OUTPUT + ${metatypes_file_gen} + BYPRODUCTS + ${metatypes_file} + DEPENDS ${QT_CMAKE_EXPORT_NAMESPACE}::moc ${automoc_dependencies} ${manual_dependencies} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::moc + -o ${metatypes_file_gen} + --collect-json ${automoc_args} ${manual_args} + COMMAND ${CMAKE_COMMAND} -E copy_if_different + ${metatypes_file_gen} + ${metatypes_file} + COMMENT "Running moc --collect-json for target ${target}" + VERBATIM + ) + + if(CMAKE_GENERATOR MATCHES " Makefiles") + # Work around https://gitlab.kitware.com/cmake/cmake/-/issues/19005 to trigger the command + # that generates ${metatypes_file}. + add_custom_command( + OUTPUT ${metatypes_file} + DEPENDS ${metatypes_file_gen} + COMMAND ${CMAKE_COMMAND} -E true + VERBATIM + ) + endif() + + # We can't rely on policy CMP0118 since user project controls it + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${target}) + endif() + set_source_files_properties(${metatypes_file_gen} ${metatypes_file} ${scope_args} + PROPERTIES GENERATED TRUE + ) + + # We still need to add this file as a source of the target, otherwise the file + # rule above is not triggered. INTERFACE_SOURCES do not properly register + # as dependencies to build the current target. + # TODO: Can we pass ${metatypes_file} instead of ${metatypes_file_gen} as a source? + # TODO: Do we still need the _gen variant at all? + target_sources(${target} PRIVATE ${metatypes_file_gen}) + set_source_files_properties(${metatypes_file} ${scope_args} + PROPERTIES HEADER_FILE_ONLY TRUE + ) + + if(arg_OUTPUT_FILES) + set(${arg_OUTPUT_FILES} "${metatypes_file}" PARENT_SCOPE) + endif() + + # Propagate the build time metatypes file. + _qt_internal_assign_build_metatypes_files_and_properties( + "${target}" + METATYPES_FILE_NAME "${metatypes_file_name}" + METATYPES_FILE_PATH "${metatypes_file}" + ) + + if(arg___QT_INTERNAL_INSTALL) + set(internal_install_option "INTERNAL_INSTALL") + else() + set(internal_install_option "") + endif() + + # TODO: Clean up Qt-specific installation not to happen in the public api. + # Check whether the metatype files should be installed. + _qt_internal_should_install_metatypes("${target}" + ${internal_install_option} + OUT_VAR should_install + ) + + if(should_install) + _qt_internal_get_metatypes_install_dir( + "${arg___QT_INTERNAL_INSTALL_DIR}" + "${INSTALL_ARCHDATADIR}" + install_dir + ) + + # Propagate the install time metatypes file. + _qt_internal_assign_install_metatypes_files_and_properties( + "${target}" + INSTALL_DIR "${install_dir}" + ) + install(FILES "${metatypes_file}" DESTINATION "${install_dir}") + endif() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_extract_metatypes) + qt6_extract_metatypes(${ARGV}) + cmake_parse_arguments(PARSE_ARGV 0 arg "" "OUTPUT_FILES" "") + if(arg_OUTPUT_FILES) + set(${arg_OUTPUT_FILES} "${${arg_OUTPUT_FILES}}" PARENT_SCOPE) + endif() + endfunction() +endif() + +# Generate Win32 RC files for a target. All entries in the RC file are generated +# from target properties: +# +# QT_TARGET_COMPANY_NAME: RC Company name +# QT_TARGET_DESCRIPTION: RC File Description +# QT_TARGET_VERSION: RC File and Product Version +# QT_TARGET_COPYRIGHT: RC LegalCopyright +# QT_TARGET_PRODUCT_NAME: RC ProductName +# QT_TARGET_COMMENTS: RC Comments +# QT_TARGET_ORIGINAL_FILENAME: RC Original FileName +# QT_TARGET_TRADEMARKS: RC LegalTrademarks +# QT_TARGET_INTERNALNAME: RC InternalName +# QT_TARGET_RC_ICONS: List of paths to icon files +# +# If you do not wish to auto-generate rc files, it's possible to provide your +# own RC file by setting the property QT_TARGET_WINDOWS_RC_FILE with a path to +# an existing rc file. +function(_qt_internal_generate_win32_rc_file target) + set(prohibited_target_types INTERFACE_LIBRARY STATIC_LIBRARY OBJECT_LIBRARY) + get_target_property(target_type ${target} TYPE) + if(target_type IN_LIST prohibited_target_types) + return() + endif() + + get_target_property(target_binary_dir ${target} BINARY_DIR) + + get_target_property(target_rc_file ${target} QT_TARGET_WINDOWS_RC_FILE) + get_target_property(target_version ${target} QT_TARGET_VERSION) + + if (NOT target_rc_file AND NOT target_version) + return() + endif() + + if(MSVC) + set(extra_rc_flags "-c65001 -DWIN32 -nologo") + else() + set(extra_rc_flags) + endif() + + if (target_rc_file) + # Use the provided RC file + target_sources(${target} PRIVATE "${target_rc_file}") + set_property(SOURCE ${target_rc_file} PROPERTY COMPILE_FLAGS "${extra_rc_flags}") + else() + # Generate RC File + set(rc_file_output "${target_binary_dir}/") + if(QT_GENERATOR_IS_MULTI_CONFIG) + string(APPEND rc_file_output "$/") + endif() + string(APPEND rc_file_output "${target}_resource.rc") + set(target_rc_file "${rc_file_output}") + + set(company_name "") + get_target_property(target_company_name ${target} QT_TARGET_COMPANY_NAME) + if (target_company_name) + set(company_name "${target_company_name}") + endif() + + set(file_description "") + get_target_property(target_description ${target} QT_TARGET_DESCRIPTION) + if (target_description) + set(file_description "${target_description}") + endif() + + set(legal_copyright "") + get_target_property(target_copyright ${target} QT_TARGET_COPYRIGHT) + if (target_copyright) + set(legal_copyright "${target_copyright}") + endif() + + set(product_name "") + get_target_property(target_product_name ${target} QT_TARGET_PRODUCT_NAME) + if (target_product_name) + set(product_name "${target_product_name}") + else() + set(product_name "${target}") + endif() + + set(comments "") + get_target_property(target_comments ${target} QT_TARGET_COMMENTS) + if (target_comments) + set(comments "${target_comments}") + endif() + + set(legal_trademarks "") + get_target_property(target_trademarks ${target} QT_TARGET_TRADEMARKS) + if (target_trademarks) + set(legal_trademarks "${target_trademarks}") + endif() + + set(product_version "") + if (target_version) + if(target_version MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+") + # nothing to do + elseif(target_version MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+") + set(target_version "${target_version}.0") + elseif(target_version MATCHES "[0-9]+\\.[0-9]+") + set(target_version "${target_version}.0.0") + elseif (target_version MATCHES "[0-9]+") + set(target_version "${target_version}.0.0.0") + else() + message(FATAL_ERROR "Invalid version format: '${target_version}'") + endif() + set(product_version "${target_version}") + else() + set(product_version "0.0.0.0") + endif() + + set(file_version "${product_version}") + string(REPLACE "." "," version_comma ${product_version}) + + set(original_file_name "$") + get_target_property(target_original_file_name ${target} QT_TARGET_ORIGINAL_FILENAME) + if (target_original_file_name) + set(original_file_name "${target_original_file_name}") + endif() + + set(internal_name "") + get_target_property(target_internal_name ${target} QT_TARGET_INTERNALNAME) + if (target_internal_name) + set(internal_name "${target_internal_name}") + endif() + + set(icons "") + get_target_property(target_icons ${target} QT_TARGET_RC_ICONS) + if (target_icons) + set(index 1) + foreach( icon IN LISTS target_icons) + string(APPEND icons "IDI_ICON${index} ICON \"${icon}\"\n") + math(EXPR index "${index} +1") + endforeach() + endif() + + set(target_file_type "VFT_DLL") + if(target_type STREQUAL "EXECUTABLE") + set(target_file_type "VFT_APP") + endif() + + set(contents "#include +${icons} +VS_VERSION_INFO VERSIONINFO +FILEVERSION ${version_comma} +PRODUCTVERSION ${version_comma} +FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS VS_FF_DEBUG +#else + FILEFLAGS 0x0L +#endif +FILEOS VOS_NT_WINDOWS32 +FILETYPE ${target_file_type} +FILESUBTYPE VFT2_UNKNOWN +BEGIN + BLOCK \"StringFileInfo\" + BEGIN + BLOCK \"040904b0\" + BEGIN + VALUE \"CompanyName\", \"${company_name}\" + VALUE \"FileDescription\", \"${file_description}\" + VALUE \"FileVersion\", \"${file_version}\" + VALUE \"LegalCopyright\", \"${legal_copyright}\" + VALUE \"OriginalFilename\", \"${original_file_name}\" + VALUE \"ProductName\", \"${product_name}\" + VALUE \"ProductVersion\", \"${product_version}\" + VALUE \"Comments\", \"${comments}\" + VALUE \"LegalTrademarks\", \"${legal_trademarks}\" + VALUE \"InternalName\", \"${internal_name}\" + END + END + BLOCK \"VarFileInfo\" + BEGIN + VALUE \"Translation\", 0x0409, 1200 + END +END +/* End of Version info */\n" + ) + + # We can't use the output of file generate as source so we work around + # this by generating the file under a different name and then copying + # the file in place using add custom command. + file(GENERATE OUTPUT "${rc_file_output}.tmp" + CONTENT "${contents}" + ) + + if(QT_GENERATOR_IS_MULTI_CONFIG) + set(cfgs ${CMAKE_CONFIGURATION_TYPES}) + set(outputs "") + foreach(cfg ${cfgs}) + string(REPLACE "$" "${cfg}" expanded_rc_file_output "${rc_file_output}") + list(APPEND outputs "${expanded_rc_file_output}") + endforeach() + else() + set(cfgs "${CMAKE_BUILD_TYPE}") + set(outputs "${rc_file_output}") + endif() + + # We would like to do the following: + # target_sources(${target} PRIVATE "$<$:${output}>") + # + # However, https://gitlab.kitware.com/cmake/cmake/-/issues/20682 doesn't let us do that + # in CMake 3.19 and earlier. + # We can do it in CMake 3.20 and later. + # And we have to do it with CMake 3.21.0 to avoid a different issue + # https://gitlab.kitware.com/cmake/cmake/-/issues/22436 + # + # So use the object lib work around for <= 3.19 and target_sources directly for later + # versions. + set(use_obj_lib FALSE) + set(end_target "${target}") + if(CMAKE_VERSION VERSION_LESS 3.20) + set(use_obj_lib TRUE) + set(end_target "${target}_rc") + add_library(${target}_rc OBJECT "${output}") + target_link_libraries(${target} PRIVATE $) + endif() + + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${end_target}) + endif() + + while(outputs) + list(POP_FRONT cfgs cfg) + list(POP_FRONT outputs output) + set(input "${output}.tmp") + add_custom_command(OUTPUT "${output}" + DEPENDS "${input}" + COMMAND ${CMAKE_COMMAND} -E copy_if_different "${input}" "${output}" + VERBATIM + ) + # We can't rely on policy CMP0118 since user project controls it + set_source_files_properties(${output} ${scope_args} PROPERTIES + GENERATED TRUE + COMPILE_FLAGS "${extra_rc_flags}" + ) + target_sources(${end_target} PRIVATE "$<$:${output}>") + endwhile() + endif() +endfunction() + +# Generate Win32 longPathAware RC and Manifest files for a target. +# MSVC needs the manifest file as part of target_sources. MinGW the RC file. +# +function(_qt_internal_generate_longpath_win32_rc_file_and_manifest target) + set(prohibited_target_types INTERFACE_LIBRARY STATIC_LIBRARY OBJECT_LIBRARY) + get_target_property(target_type ${target} TYPE) + if(target_type IN_LIST prohibited_target_types) + return() + endif() + + get_target_property(target_binary_dir ${target} BINARY_DIR) + + # Generate manifest + set(target_mn_filename "${target}_longpath.manifest") + set(mn_file_output "${target_binary_dir}/${target_mn_filename}") + + set(mn_contents [=[ + + + + true + + +]=]) + file(GENERATE OUTPUT "${mn_file_output}" CONTENT "${mn_contents}") + + # Generate RC File + set(rc_file_output "${target_binary_dir}/${target}_longpath.rc") + set(rc_contents "1 /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ 24 /* RT_MANIFEST */ ${target_mn_filename}") + file(GENERATE OUTPUT "${rc_file_output}" CONTENT "${rc_contents}") + + if (MINGW) + set(outputs "${rc_file_output}") + endif() + list(APPEND outputs "${mn_file_output}") + + foreach(output IN LISTS outputs) + # Needed for CMake versions < 3.19 + set_source_files_properties(${output} PROPERTIES GENERATED TRUE) + target_sources(${target} PRIVATE "${output}") + endforeach() +endfunction() + +function(__qt_get_relative_resource_path_for_file output_alias file) + get_property(alias SOURCE ${file} PROPERTY QT_RESOURCE_ALIAS) + if (NOT alias) + set(alias "${file}") + if(IS_ABSOLUTE "${file}") + message(FATAL_ERROR + "The source file '${file}' was specified with an absolute path and is used in a Qt " + "resource. Please set the QT_RESOURCE_ALIAS property on that source file to a " + "relative path to make the file properly accessible via the resource system." + ) + endif() + endif() + set(${output_alias} ${alias} PARENT_SCOPE) +endfunction() + +# Performs linking and propagation of the specified objects via the target's usage requirements. +# The objects may be given as generator expression. +# +# Arguments: +# EXTRA_CONDITIONS +# Conditions to be checked before linking the object files to the end-point executable. +# EXTRA_TARGET_LINK_LIBRARIES_CONDITIONS +# Conditions for the target_link_libraries call. +# EXTRA_TARGET_SOURCES_CONDITIONS +# Conditions for the target_sources call. +function(__qt_internal_propagate_object_files target objects) + set(options "") + set(single_args "") + set(extra_conditions_args + EXTRA_CONDITIONS + EXTRA_TARGET_LINK_LIBRARIES_CONDITIONS + EXTRA_TARGET_SOURCES_CONDITIONS + ) + set(multi_args ${extra_conditions_args}) + cmake_parse_arguments(arg "${options}" "${single_args}" "${multi_args}" ${ARGN}) + + # Collect additional conditions. + foreach(arg IN LISTS extra_conditions_args) + string(TOLOWER "${arg}" lcvar) + if(arg_${arg}) + list(JOIN arg_${arg} "," ${lcvar}) + else() + set(${lcvar} "$") + endif() + endforeach() + + # Do not litter the static libraries + set(not_static_condition + "$,STATIC_LIBRARY>>" + ) + + # Check if link order matters for the Platform. + set(platform_link_order_property + "$" + ) + set(platform_link_order_condition + "$" + ) + + # Check if link options are propagated according to CMP0099 + # In user builds the _qt_cmp0099_policy_check is set to FALSE or $ + # depending on the used CMake version. + # See __qt_internal_check_cmp0099_available for details. + set(cmp0099_policy_check_property + "$" + ) + set(link_objects_using_link_options_condition + "$>" + ) + + # Collect link conditions for the target_sources call. + string(JOIN "" target_sources_genex + "$<" + "$," + "${extra_target_sources_conditions}," + "${extra_conditions}" + ">" + ":${objects}>" + ) + target_sources(${target} INTERFACE + "${target_sources_genex}" + ) + + # Collect link conditions for the target_link_options call. + string(JOIN "" target_link_options_genex + "$<" + "$" + ":${objects}>" + ) + # target_link_options works well since CMake 3.17 which has policy CMP0099 set to NEW for the + # minimum required CMake version greater than or equal to 3.17. The default is OLD. See + # https://cmake.org/cmake/help/git-master/policy/CMP0099.html for details. + # This provides yet another way of linking object libraries if user sets the policy to NEW + # before calling find_package(Qt...). + target_link_options(${target} INTERFACE + "${target_link_options_genex}" + ) + + # Collect link conditions for the target_link_libraries call. + string(JOIN "" target_link_libraries_genex + "$<" + "$," + "${extra_target_link_libraries_conditions}," + "${extra_conditions}" + ">" + ":${objects}>" + ) + target_link_libraries(${target} INTERFACE + "${target_link_libraries_genex}" + ) +endfunction() + +# Performs linking and propagation of the object library via the target's usage requirements. +# Arguments: +# NO_LINK_OBJECT_LIBRARY_REQUIREMENTS_TO_TARGET skip linking of ${object_library} to ${target}, only +# propagate $ by linking it to ${target}. It's useful in case +# if ${object_library} depends on the ${target}. E.g. resource libraries depend on the Core +# library so linking them back to Core will cause a CMake error. +# +# EXTRA_CONDITIONS object library specific conditions to be checked before link the object library +# to the end-point executable. +function(__qt_internal_propagate_object_library target object_library) + set(options NO_LINK_OBJECT_LIBRARY_REQUIREMENTS_TO_TARGET) + set(single_args "") + set(multi_args EXTRA_CONDITIONS) + cmake_parse_arguments(arg "${options}" "${single_args}" "${multi_args}" ${ARGN}) + + get_target_property(is_imported ${object_library} IMPORTED) + if(NOT is_imported) + target_link_libraries(${object_library} PRIVATE ${QT_CMAKE_EXPORT_NAMESPACE}::Platform) + _qt_internal_copy_dependency_properties(${object_library} ${target} PRIVATE_ONLY) + endif() + + # After internal discussion we decided to not rely on the linker order that CMake + # offers, until CMake provides the guaranteed linking order that suites our needs in a + # future CMake version. + # All object libraries mark themselves with the _is_qt_propagated_object_library property. + # Using a finalizer approach we walk through the target dependencies and look for libraries + # using the _is_qt_propagated_object_library property. Then, objects of the collected libraries + # are moved to the beginning of the linker line using target_sources. + # + # Note: target_link_libraries works well with linkers other than ld. If user didn't enforce + # a finalizer we rely on linker to resolve circular dependencies between objects and static + # libraries. + set_property(TARGET ${object_library} PROPERTY _is_qt_propagated_object_library TRUE) + if(NOT is_imported) + set_property(TARGET ${object_library} APPEND PROPERTY + EXPORT_PROPERTIES _is_qt_propagated_object_library + ) + endif() + + # Keep the implicit linking if finalizers are not used. + set(not_finalizer_mode_condition + "$>>" + ) + + # Use TARGET_NAME to have the correct namespaced name in the exports. + set(objects "$>") + + __qt_internal_propagate_object_files(${target} ${objects} + EXTRA_CONDITIONS ${arg_EXTRA_CONDITIONS} + EXTRA_TARGET_SOURCES_CONDITIONS ${not_finalizer_mode_condition} + EXTRA_TARGET_LINK_LIBRARIES_CONDITIONS ${not_finalizer_mode_condition} + ) + + if(NOT arg_NO_LINK_OBJECT_LIBRARY_REQUIREMENTS_TO_TARGET) + # It's necessary to link the object library target, since we want to pass the object library + # dependencies to the 'target'. Interface linking doesn't add the objects of the library to + # the end-point linker line but propagates all the dependencies of the object_library added + # before or AFTER the line below. + target_link_libraries(${target} INTERFACE ${object_library}) + endif() +endfunction() + +function(__qt_propagate_generated_resource target resource_name generated_source_code output_generated_target) + get_target_property(type ${target} TYPE) + if(type STREQUAL STATIC_LIBRARY) + get_target_property(resource_count ${target} _qt_generated_resource_target_count) + if(NOT resource_count) + set(resource_count "0") + endif() + math(EXPR resource_count "${resource_count} + 1") + set_target_properties(${target} PROPERTIES _qt_generated_resource_target_count ${resource_count}) + + __qt_internal_generate_init_resource_source_file( + resource_init_file ${target} ${resource_name}) + + set(resource_target "${target}_resources_${resource_count}") + add_library("${resource_target}" OBJECT "${resource_init_file}") + set_target_properties(${resource_target} PROPERTIES + AUTOMOC FALSE + AUTOUIC FALSE + AUTORCC FALSE + ) + # Needed so that qtsymbolmacros.h and its dependent headers are already created / syncqt'ed. + if(TARGET Core_sync_headers) + set(headers_available_target "Core_sync_headers") + else() + set(headers_available_target "${QT_CMAKE_EXPORT_NAMESPACE}::Core") + endif() + add_dependencies(${resource_target} ${headers_available_target}) + target_compile_definitions("${resource_target}" PRIVATE + "$" + ) + target_include_directories("${resource_target}" PRIVATE + "$" + ) + _qt_internal_set_up_static_runtime_library("${resource_target}") + + # Special handling is required for the Core library resources. The linking of the Core + # library to the resources adds a circular dependency. This leads to the wrong + # objects/library order in the linker command line, since the Core library target is + # resolved first. + if(NOT target STREQUAL "Core") + target_link_libraries(${resource_target} INTERFACE ${QT_CMAKE_EXPORT_NAMESPACE}::Core) + endif() + set_property(TARGET ${resource_target} APPEND PROPERTY _qt_resource_name ${resource_name}) + + # Save the path to the generated source file, relative to the the current build dir. + # The path will be used in static library prl file generation to ensure qmake links + # against the installed resource object files. + # Example saved path: + # .rcc/qrc_qprintdialog.cpp + file(RELATIVE_PATH generated_cpp_file_relative_path + "${CMAKE_CURRENT_BINARY_DIR}" + "${resource_init_file}") + set_property(TARGET ${resource_target} APPEND PROPERTY + _qt_resource_generated_cpp_relative_path "${generated_cpp_file_relative_path}") + + if(target STREQUAL "Core") + set(skip_direct_linking NO_LINK_OBJECT_LIBRARY_REQUIREMENTS_TO_TARGET) + endif() + __qt_internal_propagate_object_library(${target} ${resource_target} + ${skip_direct_linking} + ) + + set(${output_generated_target} "${resource_target}" PARENT_SCOPE) + else() + set(${output_generated_target} "" PARENT_SCOPE) + endif() + + target_sources(${target} PRIVATE ${generated_source_code}) +endfunction() + +function(__qt_internal_sanitize_resource_name out_var name) + # The sanitized output should match RCCResourceLibrary::writeInitializer()'s + # isAsciiLetterOrNumber-based substituion. + # MAKE_C_IDENTIFIER matches that, it replaces non-alphanumeric chars with underscores. + string(MAKE_C_IDENTIFIER "${name}" sanitized_resource_name) + set(${out_var} "${sanitized_resource_name}" PARENT_SCOPE) +endfunction() + +function(__qt_internal_generate_init_resource_source_file out_var target resource_name) + get_property(__qt_core_macros_module_base_dir GLOBAL PROPERTY __qt_core_macros_module_base_dir) + set(template_file "${__qt_core_macros_module_base_dir}/Qt6CoreResourceInit.in.cpp") + + # Gets replaced in the template + __qt_internal_sanitize_resource_name(RESOURCE_NAME "${resource_name}") + set(resource_init_path "${CMAKE_CURRENT_BINARY_DIR}/.qt/rcc/qrc_${resource_name}_init.cpp") + + configure_file("${template_file}" "${resource_init_path}" @ONLY) + + set(scope_args "") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${target}) + endif() + set_source_files_properties(${resource_init_path} ${scope_args} PROPERTIES + SKIP_AUTOGEN TRUE + SKIP_UNITY_BUILD_INCLUSION TRUE + SKIP_PRECOMPILE_HEADERS TRUE + ) + + set(${out_var} "${resource_init_path}" PARENT_SCOPE) +endfunction() + +# Make file visible in IDEs. +# Targets that are finalized add the file as HEADER_FILE_ONLY in the finalizer. +# Targets that are not finalized add the file under a ${target}_other_files target. +function(_qt_internal_expose_source_file_to_ide target file) + get_target_property(target_expects_finalization ${target} _qt_expects_finalization) + if(target_expects_finalization AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.19") + # The target is not yet finalized. The target finalizer will call the exposure function. + set_property(TARGET ${target} APPEND PROPERTY _qt_deferred_files ${file}) + return() + else() + get_target_property(is_finalized "${target}" _qt_is_finalized) + if(is_finalized) + # The target already has been finalized. Run the exposure function immediately. + set_property(TARGET ${target} APPEND PROPERTY _qt_deferred_files ${file}) + _qt_internal_expose_deferred_files_to_ide(${target}) + return() + endif() + endif() + + # Fallback for targets that are not finalized: Create fake target under which the file is added. + set(ide_target ${target}_other_files) + if(NOT TARGET ${ide_target}) + add_custom_target(${ide_target} SOURCES "${file}") + + # The new Xcode build system requires a common target to drive the generation of files, + # otherwise project configuration fails. + # By adding ${target} as a dependency of ${target}_other_files, + # it becomes the common target, so project configuration succeeds. + if(CMAKE_GENERATOR STREQUAL "Xcode") + add_dependencies(${ide_target} ${target}) + endif() + else() + set_property(TARGET ${ide_target} APPEND PROPERTY SOURCES "${file}") + endif() + + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY "${target}") + endif() + get_source_file_property( + target_dependency "${file}" ${scope_args} _qt_resource_target_dependency) + if(target_dependency) + if(NOT TARGET "${target_dependency}") + message(FATAL_ERROR "Target dependency on source file ${file} is not a cmake target.") + endif() + add_dependencies(${ide_target} ${target_dependency}) + endif() +endfunction() + +# Called by the target finalizer. +# Adds the files that were added to _qt_deferred_files to SOURCES. +# Sets HEADER_FILES_ONLY if they did not exist yet in SOURCES. +function(_qt_internal_expose_deferred_files_to_ide target) + get_target_property(new_sources ${target} _qt_deferred_files) + if(NOT new_sources) + return() + endif() + set(new_sources_real "") + foreach(f IN LISTS new_sources) + get_filename_component(realf "${f}" REALPATH) + list(APPEND new_sources_real ${realf}) + endforeach() + + set(filtered_new_sources "") + get_target_property(target_source_dir ${target} SOURCE_DIR) + get_filename_component(target_source_dir "${target_source_dir}" REALPATH) + get_target_property(existing_sources ${target} SOURCES) + if(existing_sources) + set(existing_sources_real "") + set(realf "") + foreach(f IN LISTS existing_sources) + get_filename_component(realf "${f}" REALPATH BASE_DIR ${target_source_dir}) + list(APPEND existing_sources_real ${realf}) + endforeach() + + list(LENGTH new_sources max_i) + math(EXPR max_i "${max_i} - 1") + foreach(i RANGE 0 ${max_i}) + list(GET new_sources_real ${i} realf) + if(NOT realf IN_LIST existing_sources_real) + list(GET new_sources ${i} f) + list(APPEND filtered_new_sources ${f}) + endif() + endforeach() + endif() + if("${filtered_new_sources}" STREQUAL "") + return() + endif() + + target_sources(${target} PRIVATE ${filtered_new_sources}) + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY "${target}") + endif() + set_source_files_properties(${filtered_new_sources} + ${scope_args} PROPERTIES HEADER_FILE_ONLY ON) +endfunction() + +# +# Process resources via file path instead of QRC files. Behind the +# scenes, it will generate a qrc file. +# +# The QRC Prefix is set via the PREFIX parameter. +# +# Alias settings for files need to be set via the QT_RESOURCE_ALIAS property +# via the set_source_files_properties() command. +# +# When using this command with static libraries, one or more special targets +# will be generated. Should you wish to perform additional processing on these +# targets pass a value to the OUTPUT_TARGETS parameter. +# +function(_qt_internal_process_resource target resourceName) + cmake_parse_arguments(rcc "BIG_RESOURCES" + "PREFIX;LANG;BASE;OUTPUT_TARGETS;DESTINATION" "FILES;OPTIONS" ${ARGN}) + + if("${rcc_OPTIONS}" MATCHES "-binary") + set(isBinary TRUE) + if(rcc_BIG_RESOURCES) + message(FATAL_ERROR "BIG_RESOURCES cannot be used together with the -binary option.") + endif() + endif() + + if(rcc_BIG_RESOURCES AND CMAKE_GENERATOR STREQUAL "Xcode" AND IOS) + message(WARNING + "Due to CMake limitations, the BIG_RESOURCES option can't be used when building " + "for iOS. " + "See https://bugreports.qt.io/browse/QTBUG-103497 for details. " + "Falling back to using regular resources. " + ) + set(rcc_BIG_RESOURCES OFF) + endif() + + if(rcc_BIG_RESOURCES AND CMAKE_VERSION VERSION_LESS "3.17") + message(WARNING + "The BIG_RESOURCES option does not work reliably with CMake < 3.17. " + "Consider upgrading to a more recent CMake version or disable the BIG_RESOURCES " + "option for older CMake versions." + ) + endif() + + string(REPLACE "/" "_" resourceName ${resourceName}) + string(REPLACE "." "_" resourceName ${resourceName}) + + set(resource_files "") + # Strip the ending slashes from the file_path. If paths contain slashes in the end + # set/get source properties works incorrect and may have the same QT_RESOURCE_ALIAS + # for two different paths. See https://gitlab.kitware.com/cmake/cmake/-/issues/23212 + # for details. + foreach(file_path IN LISTS rcc_FILES) + if(file_path MATCHES "(.+)/$") + set(file_path "${CMAKE_MATCH_1}") + endif() + list(APPEND resource_files ${file_path}) + endforeach() + + if(NOT "${rcc_BASE}" STREQUAL "") + get_filename_component(abs_base "${rcc_BASE}" ABSOLUTE) + foreach(file_path IN LISTS resource_files) + get_source_file_property(alias "${file_path}" QT_RESOURCE_ALIAS) + if(alias STREQUAL "NOTFOUND") + get_filename_component(abs_file "${file_path}" ABSOLUTE) + file(RELATIVE_PATH rel_file "${abs_base}" "${abs_file}") + set_property(SOURCE "${file_path}" PROPERTY QT_RESOURCE_ALIAS "${rel_file}") + endif() + endforeach() + endif() + + if(ANDROID) + if(COMMAND _qt_internal_collect_qml_root_paths) + _qt_internal_collect_qml_root_paths(${target} ${resource_files}) + endif() + endif() + + if(NOT rcc_PREFIX) + get_target_property(rcc_PREFIX ${target} QT_RESOURCE_PREFIX) + if (NOT rcc_PREFIX) + set(rcc_PREFIX "/") + endif() + endif() + + if (NOT resource_files) + if (rcc_OUTPUT_TARGETS) + set(${rcc_OUTPUT_TARGETS} "" PARENT_SCOPE) + endif() + return() + endif() + set(generatedResourceFile "${CMAKE_CURRENT_BINARY_DIR}/.qt/rcc/${resourceName}.qrc") + _qt_internal_expose_source_file_to_ide(${target} ${generatedResourceFile}) + set_source_files_properties(${generatedResourceFile} PROPERTIES GENERATED TRUE) + + # Generate .qrc file: + + # + set(qrcContents "\n \n") + + set(resource_dependencies) + foreach(file IN LISTS resource_files) + __qt_get_relative_resource_path_for_file(file_resource_path ${file}) + + if (NOT IS_ABSOLUTE ${file}) + set(file "${CMAKE_CURRENT_SOURCE_DIR}/${file}") + endif() + + get_property(is_empty SOURCE ${file} PROPERTY QT_DISCARD_FILE_CONTENTS) + + ### FIXME: escape file paths to be XML conform + # ... + string(APPEND qrcContents " ${file}\n") + list(APPEND files "${file}") + + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${target}) + endif() + get_source_file_property( + target_dependency ${file} ${scope_args} _qt_resource_target_dependency) + + # The target dependency code path does not take care of rebuilds when ${file} + # is touched. Limit its usage to the Xcode generator to avoid the Xcode common + # dependency issue. + # TODO: Figure out how to avoid the issue on Xcode, while also enabling proper + # dependency tracking when ${file} is touched. + if(target_dependency AND CMAKE_GENERATOR STREQUAL "Xcode") + if(NOT TARGET ${target_dependency}) + message(FATAL_ERROR + "Target dependency on resource file ${file} is not a cmake target.") + endif() + list(APPEND resource_dependencies ${target_dependency}) + else() + list(APPEND resource_dependencies ${file}) + endif() + _qt_internal_expose_source_file_to_ide(${target} "${file}") + endforeach() + + # + string(APPEND qrcContents " \n\n") + + get_property(__qt_core_macros_module_base_dir GLOBAL PROPERTY __qt_core_macros_module_base_dir) + set(template_file "${__qt_core_macros_module_base_dir}/Qt6CoreConfigureFileTemplate.in") + set(qt_core_configure_file_contents "${qrcContents}") + configure_file("${template_file}" "${generatedResourceFile}") + + set(rccArgs --name "${resourceName}" "${generatedResourceFile}") + set(rccArgsAllPasses "") + + if(rcc_OPTIONS) + list(APPEND rccArgsAllPasses ${rcc_OPTIONS}) + endif() + + # When cross-building, we use host tools to generate target code. If the host rcc was compiled + # with zstd support, it expects the target QtCore to be able to decompress zstd compressed + # content. This might be true with qmake where host tools are built as part of the + # cross-compiled Qt, but with CMake we build tools separate from the cross-compiled Qt. + # If the target does not support zstd (feature is disabled), tell rcc not to generate + # zstd related code. + if(NOT QT_FEATURE_zstd) + list(APPEND rccArgsAllPasses "--no-zstd") + endif() + + # Disable AUTOGEN on the generated .qrc file. + set(scope_args "") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${target}) + endif() + set_property(SOURCE "${generatedResourceFile}" ${scope_args} PROPERTY SKIP_AUTOGEN ON) + + # Set output file name for rcc command + if(isBinary) + set(generatedOutfile "${CMAKE_CURRENT_BINARY_DIR}/${resourceName}.rcc") + if(rcc_DESTINATION) + # Add .rcc suffix if it's not specified by user + get_filename_component(destinationRccExt "${rcc_DESTINATION}" LAST_EXT) + if("${destinationRccExt}" STREQUAL ".rcc") + set(generatedOutfile "${rcc_DESTINATION}") + else() + set(generatedOutfile "${rcc_DESTINATION}.rcc") + endif() + endif() + elseif(rcc_BIG_RESOURCES) + set(generatedOutfile "${CMAKE_CURRENT_BINARY_DIR}/.qt/rcc/qrc_${resourceName}_tmp.cpp") + else() + set(generatedOutfile "${CMAKE_CURRENT_BINARY_DIR}/.qt/rcc/qrc_${resourceName}.cpp") + endif() + + set(pass_msg) + if(rcc_BIG_RESOURCES) + list(PREPEND rccArgs --pass 1) + set(pass_msg " pass 1") + endif() + + list(PREPEND rccArgs --output "${generatedOutfile}") + + # Process .qrc file: + add_custom_command(OUTPUT "${generatedOutfile}" + COMMAND "${QT_CMAKE_EXPORT_NAMESPACE}::rcc" ${rccArgs} ${rccArgsAllPasses} + DEPENDS + ${resource_dependencies} + ${generatedResourceFile} + "${QT_CMAKE_EXPORT_NAMESPACE}::rcc" + COMMENT "Running rcc${pass_msg} for resource ${resourceName}" + VERBATIM) + + if(isBinary) + # Add generated .rcc target to 'all' set + add_custom_target(binary_resource_${resourceName} ALL DEPENDS "${generatedOutfile}") + return() + endif() + + # We can't rely on policy CMP0118 since user project controls it. + # We also want SKIP_AUTOGEN known in the target's scope, where we can. + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${target}) + endif() + set_source_files_properties(${generatedOutfile} ${scope_args} PROPERTIES + SKIP_AUTOGEN TRUE + GENERATED TRUE + SKIP_UNITY_BUILD_INCLUSION TRUE + SKIP_PRECOMPILE_HEADERS TRUE + ) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.27") + set_source_files_properties(${generatedOutfile} ${scope_args} PROPERTIES SKIP_LINTING ON) + endif() + + get_target_property(target_source_dir ${target} SOURCE_DIR) + if(NOT target_source_dir STREQUAL CMAKE_CURRENT_SOURCE_DIR) + # We have to create a separate target in this scope that depends on + # the generated file, otherwise the original target won't have the + # required dependencies in place to ensure correct build order. + add_custom_target(${target}_${resourceName} DEPENDS ${generatedOutfile}) + add_dependencies(${target} ${target}_${resourceName}) + endif() + + if(rcc_BIG_RESOURCES) + set(pass1OutputFile ${generatedOutfile}) + set(generatedOutfile + "${CMAKE_CURRENT_BINARY_DIR}/.qt/rcc/qrc_${resourceName}${CMAKE_CXX_OUTPUT_EXTENSION}") + _qt_internal_add_rcc_pass2( + RESOURCE_NAME ${resourceName} + RCC_OPTIONS ${rccArgsAllPasses} + OBJECT_LIB ${target}_${resourceName}_obj + QRC_FILE ${generatedResourceFile} + PASS1_OUTPUT_FILE ${pass1OutputFile} + OUT_OBJECT_FILE ${generatedOutfile} + ) + get_target_property(type ${target} TYPE) + if(type STREQUAL STATIC_LIBRARY) + # Create a custom target to trigger the generation of ${generatedOutfile} + set(pass2_target ${target}_${resourceName}_pass2) + add_custom_target(${pass2_target} DEPENDS ${generatedOutfile}) + add_dependencies(${target} ${pass2_target}) + + # Propagate the object files to the target. + __qt_internal_propagate_object_files(${target} "${generatedOutfile}") + else() + target_sources(${target} PRIVATE ${generatedOutfile}) + endif() + else() + __qt_propagate_generated_resource(${target} ${resourceName} "${generatedOutfile}" + output_targets) + endif() + + set_property(TARGET ${target} + APPEND PROPERTY _qt_generated_qrc_files "${generatedResourceFile}") + + if (rcc_OUTPUT_TARGETS) + set(${rcc_OUTPUT_TARGETS} "${output_targets}" PARENT_SCOPE) + endif() +endfunction() + +macro(_qt_internal_get_add_plugin_keywords option_args single_args multi_args) + set(${option_args} + STATIC + SHARED + __QT_INTERNAL_NO_PROPAGATE_PLUGIN_INITIALIZER + ) + set(${single_args} + PLUGIN_TYPE # Internal use only, may be changed or removed + CLASS_NAME + OUTPUT_NAME # Internal use only, may be changed or removed + OUTPUT_TARGETS + ) + set(${multi_args}) +endmacro() + +function(qt6_add_plugin target) + _qt_internal_get_add_plugin_keywords(opt_args single_args multi_args) + list(APPEND opt_args MANUAL_FINALIZATION) + + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + + if(arg_STATIC AND arg_SHARED) + message(FATAL_ERROR + "Both STATIC and SHARED options were given. Only one of the two should be used." + ) + endif() + + # Explicit option takes priority over the computed default. + if(arg_STATIC) + set(create_static_plugin TRUE) + elseif(arg_SHARED) + set(create_static_plugin FALSE) + else() + # If no explicit STATIC/SHARED option is set, default to the flavor of the Qt build. + if(QT6_IS_SHARED_LIBS_BUILD) + set(create_static_plugin FALSE) + else() + set(create_static_plugin TRUE) + endif() + endif() + + # The default of _qt_internal_add_library creates SHARED in a shared Qt build, so we need to + # be explicit about the MODULE. + if(create_static_plugin) + set(type_to_create STATIC) + else() + set(type_to_create MODULE) + endif() + + _qt_internal_add_library(${target} ${type_to_create} ${arg_UNPARSED_ARGUMENTS}) + set_property(TARGET ${target} PROPERTY _qt_expects_finalization TRUE) + + get_target_property(target_type "${target}" TYPE) + if (target_type STREQUAL "STATIC_LIBRARY") + target_compile_definitions(${target} PRIVATE QT_STATICPLUGIN) + endif() + + set(output_name ${target}) + if (arg_OUTPUT_NAME) + set(output_name ${arg_OUTPUT_NAME}) + endif() + set_property(TARGET "${target}" PROPERTY OUTPUT_NAME "${output_name}") + + if (ANDROID) + set_target_properties(${target} + PROPERTIES + LIBRARY_OUTPUT_NAME "plugins_${arg_PLUGIN_TYPE}_${output_name}" + ) + endif() + + # Derive the class name from the target name if it's not explicitly specified. + set(plugin_class_name "") + if (NOT "${arg_PLUGIN_TYPE}" STREQUAL "qml_plugin") + if (NOT arg_CLASS_NAME) + set(plugin_class_name "${target}") + else() + set(plugin_class_name "${arg_CLASS_NAME}") + endif() + else() + # Make sure to set any passed-in class name for qml plugins as well, because it's used for + # building the qml plugin foo_init object libraries. + if(arg_CLASS_NAME) + set(plugin_class_name "${arg_CLASS_NAME}") + else() + message(FATAL_ERROR "Qml plugin target has no CLASS_NAME specified: '${target}'") + endif() + endif() + + set_target_properties(${target} PROPERTIES QT_PLUGIN_CLASS_NAME "${plugin_class_name}") + + # Create a plugin initializer object library for static plugins. + # It contains a Q_IMPORT_PLUGIN(QT_PLUGIN_CLASS_NAME) call. + # Project targets will automatically link to the plugin initializer whenever they link to the + # plugin target. + # The plugin init target name is stored in OUTPUT_TARGETS, so projects may install them. + # Qml plugin inits are handled in Qt6QmlMacros. + if(NOT "${arg_PLUGIN_TYPE}" STREQUAL "qml_plugin" + AND target_type STREQUAL "STATIC_LIBRARY") + __qt_internal_add_static_plugin_init_object_library("${target}" plugin_init_target) + + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${plugin_init_target} PARENT_SCOPE) + endif() + + # We don't automatically propagate the plugin init library for Qt provided plugins, because + # there are 2 other code paths that take care of that, one involving finalizers and the + # other regular usage requirements. + if(NOT arg___QT_INTERNAL_NO_PROPAGATE_PLUGIN_INITIALIZER) + __qt_internal_propagate_object_library("${target}" "${plugin_init_target}") + endif() + else() + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} "" PARENT_SCOPE) + endif() + endif() + + target_compile_definitions(${target} PRIVATE + QT_PLUGIN + QT_DEPRECATED_WARNINGS + ) + + if(target_type STREQUAL "MODULE_LIBRARY") + if(NOT TARGET qt_internal_plugins) + add_custom_target(qt_internal_plugins) + _qt_internal_assign_to_internal_targets_folder(qt_internal_plugins) + endif() + add_dependencies(qt_internal_plugins ${target}) + endif() + + if(arg_MANUAL_FINALIZATION) + # Caller says they will call qt6_finalize_target() themselves later + return() + endif() + + _qt_internal_finalize_target_defer("${target}") +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_plugin) + qt6_add_plugin(${ARGV}) + cmake_parse_arguments(PARSE_ARGV 1 arg "" "OUTPUT_TARGETS" "") + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${${arg_OUTPUT_TARGETS}} PARENT_SCOPE) + endif() + endfunction() +endif() + +# Creates a library by forwarding arguments to add_library, applies some Qt naming file name naming +# conventions and ensures the execution of Qt specific finalizers. +function(qt6_add_library target) + cmake_parse_arguments(PARSE_ARGV 1 arg "MANUAL_FINALIZATION" "" "") + + _qt_internal_add_library("${target}" ${arg_UNPARSED_ARGUMENTS}) + set_property(TARGET ${target} PROPERTY _qt_expects_finalization TRUE) + + if(arg_MANUAL_FINALIZATION) + # Caller says they will call qt6_finalize_target() themselves later + return() + endif() + + _qt_internal_finalize_target_defer("${target}") +endfunction() + +# Creates a library target by forwarding the arguments to add_library. +# +# Applies some Qt specific behaviors: +# - If no type option is specified, rather than defaulting to STATIC it defaults to STATIC or SHARED +# depending on the Qt configuration. +# - Applies Qt specific prefixes and suffixes to file names depending on platform. +function(_qt_internal_add_library target) + set(opt_args + STATIC + SHARED + MODULE + INTERFACE + OBJECT + ) + set(single_args "") + set(multi_args "") + cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}") + + set(option_type_count 0) + if(arg_STATIC) + set(type_to_create STATIC) + math(EXPR option_type_count "${option_type_count}+1") + elseif(arg_SHARED) + set(type_to_create SHARED) + math(EXPR option_type_count "${option_type_count}+1") + elseif(arg_MODULE) + set(type_to_create MODULE) + math(EXPR option_type_count "${option_type_count}+1") + elseif(arg_INTERFACE) + set(type_to_create INTERFACE) + math(EXPR option_type_count "${option_type_count}+1") + elseif(arg_OBJECT) + set(type_to_create OBJECT) + math(EXPR option_type_count "${option_type_count}+1") + endif() + + if(option_type_count GREATER 1) + message(FATAL_ERROR + "Multiple type options were given. Only one should be used." + ) + endif() + + # If no explicit type option is set, default to the flavor of the Qt build. + # This in contrast to CMake which defaults to STATIC. + if(NOT arg_STATIC AND NOT arg_SHARED AND NOT arg_MODULE AND NOT arg_INTERFACE + AND NOT arg_OBJECT) + if(DEFINED BUILD_SHARED_LIBS AND NOT QT_BUILDING_QT AND NOT QT_BUILD_STANDALONE_TESTS) + __qt_internal_setup_policy(QTP0003 "6.7.0" + "BUILD_SHARED_LIBS is set to ${BUILD_SHARED_LIBS} but it has no effect on\ + default library type created by Qt CMake API commands. The default library type\ + is set to the Qt build type.\ + This behavior can be changed by setting QTP0003 to NEW.\ + Check https://doc.qt.io/qt-6/qt-cmake-policy-qtp0003.html for policy details." + ) + qt6_policy(GET QTP0003 build_shared_libs_policy) + else() + set(build_shared_libs_policy "") + endif() + + if(build_shared_libs_policy STREQUAL "NEW" OR QT_BUILDING_QT OR QT_BUILD_STANDALONE_TESTS) + if(BUILD_SHARED_LIBS OR (NOT DEFINED BUILD_SHARED_LIBS AND QT6_IS_SHARED_LIBS_BUILD)) + set(type_to_create SHARED) + else() + set(type_to_create STATIC) + endif() + else() + if(QT6_IS_SHARED_LIBS_BUILD) + set(type_to_create SHARED) + else() + set(type_to_create STATIC) + endif() + endif() + endif() + + cmake_policy(PUSH) + __qt_internal_set_cmp0156() + add_library(${target} ${type_to_create} ${arg_UNPARSED_ARGUMENTS}) + cmake_policy(POP) + + _qt_internal_disable_autorcc_zstd_when_not_supported("${target}") + _qt_internal_set_up_static_runtime_library(${target}) + + if(NOT type_to_create STREQUAL "INTERFACE" AND NOT type_to_create STREQUAL "OBJECT") + _qt_internal_apply_win_prefix_and_suffix("${target}") + endif() + + if(arg_MODULE AND APPLE) + # CMake defaults to using .so extensions for loadable modules, aka plugins, + # but Qt plugins are actually suffixed with .dylib. + set_property(TARGET "${target}" PROPERTY SUFFIX ".dylib") + endif() + + if(ANDROID) + set_property(TARGET "${target}" + PROPERTY _qt_android_apply_arch_suffix_called_from_qt_impl TRUE) + qt6_android_apply_arch_suffix("${target}") + endif() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_library) + qt6_add_library(${ARGV}) + endfunction() +endif() + +# TODO: Remove once all repositories use qt_internal_add_example instead of add_subdirectory. +macro(_qt_internal_override_example_install_dir_to_dot) + # Set INSTALL_EXAMPLEDIR to ".". + # This overrides the install destination of unclean Qt example projects to install directly + # to CMAKE_INSTALL_PREFIX. + if(QT_INTERNAL_SET_EXAMPLE_INSTALL_DIR_TO_DOT) + set(INSTALL_EXAMPLEDIR ".") + set(_qt_internal_example_dir_set_to_dot TRUE) + endif() +endmacro() + +function(qt6_allow_non_utf8_sources target) + set_target_properties("${target}" PROPERTIES QT_NO_UTF8_SOURCE TRUE) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_allow_non_utf8_sources) + qt6_allow_non_utf8_sources(${ARGV}) + endfunction() +endif() + +function(_qt_internal_apply_strict_cpp target) + # Disable C, Obj-C and C++ GNU extensions aka no "-std=gnu++11". + # Similar to mkspecs/features/default_post.prf's CONFIG += strict_cpp. + # Allow opt-out via variable. + if(NOT QT_ENABLE_CXX_EXTENSIONS) + get_target_property(target_type "${target}" TYPE) + if(NOT target_type STREQUAL "INTERFACE_LIBRARY") + set_target_properties("${target}" PROPERTIES + CXX_EXTENSIONS OFF + C_EXTENSIONS OFF + OBJC_EXTENSIONS OFF + OBJCXX_EXTENSIONS OFF) + endif() + endif() +endfunction() + +# Copies properties of the dependency to the target. +# Arguments: +# PROPERTIES list of properties to copy. If not specified the following properties are copied +# by default: INCLUDE_DIRECTORIES SYSTEM_INCLUDE_DIRECTORIES COMPILE_DEFINITIONS +# COMPILE_OPTIONS COMPILE_FEATURES +# PRIVATE_ONLY copy only private properties (without INTERFACE analogues). Optional. +# INTERFACE_ONLY copy only interface properties (without non-prefixed analogues). Optional. +# Note: Not all properties have INTERFACE properties analogues. +# See https://cmake.org/cmake/help/latest/prop_tgt/EXPORT_PROPERTIES.html for details. +# +# PRIVATE_ONLY and INTERFACE_ONLY in the same call are not allowed. Omit these options to copy +# both sets. +function(_qt_internal_copy_dependency_properties target dependency) + cmake_parse_arguments(arg "INTERFACE_ONLY;PRIVATE_ONLY" "" "PROPERTIES" ${ARGN}) + if(arg_PRIVATE_ONLY AND arg_INTERFACE_ONLY) + message("Both PRIVATE_ONLY and INTERFACE_ONLY options are set.\ +Please use _qt_internal_copy_dependency_properties without these options to copy a set of +properties of both types." + ) + endif() + + if(arg_PROPERTIES) + set(common_props_to_set ${arg_PROPERTIES}) + else() + set(common_props_to_set + INCLUDE_DIRECTORIES SYSTEM_INCLUDE_DIRECTORIES + COMPILE_DEFINITIONS COMPILE_OPTIONS + COMPILE_FEATURES + ) + endif() + + set(props_to_set "") + if(NOT arg_INTERFACE_ONLY) + set(props_to_set ${common_props_to_set}) + endif() + if(NOT arg_PRIVATE_ONLY) + list(TRANSFORM common_props_to_set PREPEND INTERFACE_ + OUTPUT_VARIABLE interface_properties) + list(APPEND props_to_set ${interface_properties}) + endif() + + foreach(prop ${props_to_set}) + set_property(TARGET + "${target}" APPEND PROPERTY + ${prop} "$" + ) + endforeach() +endfunction() + +function(qt6_disable_unicode_defines target) + set_target_properties(${target} PROPERTIES QT_NO_UNICODE_DEFINES TRUE) +endfunction() + +# Finalizer function for the top-level user projects. +# +# This function is currently in Technical Preview. +# Its signature and behavior might change. +function(qt6_finalize_project) + if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) + message("qt6_finalize_project is called not in the top-level CMakeLists.txt.") + endif() + if(ANDROID) + _qt_internal_collect_apk_dependencies() + endif() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_finalize_project) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_finalize_project() + else() + message(FATAL_ERROR "qt_finalize_project() is only available in Qt 6.") + endif() + endfunction() + + function(qt_disable_unicode_defines) + qt6_disable_unicode_defines(${ARGV}) + endfunction() +endif() + +function(_qt_internal_get_deploy_impl_dir var) + set(${var} "${CMAKE_BINARY_DIR}/.qt" PARENT_SCOPE) +endfunction() + +function(_qt_internal_add_deploy_support deploy_support_file) + get_filename_component(deploy_support_file "${deploy_support_file}" REALPATH) + + set(target ${QT_CMAKE_EXPORT_NAMESPACE}::Core) + get_target_property(aliased_target ${target} ALIASED_TARGET) + if(aliased_target) + set(target ${aliased_target}) + endif() + + get_property(scripts TARGET ${target} PROPERTY _qt_deploy_support_files) + if(NOT "${deploy_support_file}" IN_LIST scripts) + set_property(TARGET ${target} APPEND PROPERTY + _qt_deploy_support_files "${deploy_support_file}" + ) + endif() +endfunction() + +# Sets up the commands for use at install/deploy time +function(_qt_internal_setup_deploy_support) + if(QT_SKIP_SETUP_DEPLOYMENT) + return() + endif() + + get_property(cmake_role GLOBAL PROPERTY CMAKE_ROLE) + if(NOT cmake_role STREQUAL "PROJECT") + return() + endif() + + # Always set QT_DEPLOY_SUPPORT in the caller's scope, even if we've generated + # the deploy support file in a previous call. The project may be calling + # find_package() from sibling directories with separate variable scopes. + _qt_internal_get_deploy_impl_dir(deploy_impl_dir) + + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(QT_DEPLOY_SUPPORT "${deploy_impl_dir}/QtDeploySupport-$.cmake") + else() + set(QT_DEPLOY_SUPPORT "${deploy_impl_dir}/QtDeploySupport.cmake") + endif() + set(QT_DEPLOY_SUPPORT "${QT_DEPLOY_SUPPORT}" PARENT_SCOPE) + + get_property(have_generated_file GLOBAL PROPERTY _qt_have_generated_deploy_support) + if(have_generated_file) + return() + endif() + set_property(GLOBAL PROPERTY _qt_have_generated_deploy_support TRUE) + + include(GNUInstallDirs) + set(target ${QT_CMAKE_EXPORT_NAMESPACE}::Core) + get_target_property(aliased_target ${target} ALIASED_TARGET) + if(aliased_target) + set(target ${aliased_target}) + endif() + + # Generate deployment information for each target if the CMake version is recent enough. + # The call is deferred to have all targets of the projects available. + if(CMAKE_VERSION GREATER_EQUAL "3.19.0") + if(is_multi_config) + set(targets_file "${deploy_impl_dir}/QtDeployTargets-$.cmake") + else() + set(targets_file "${deploy_impl_dir}/QtDeployTargets.cmake") + endif() + cmake_language(EVAL CODE + "cmake_language(DEFER + DIRECTORY [[${CMAKE_SOURCE_DIR}]] + CALL _qt_internal_write_target_deploy_info [[${targets_file}]])" + ) + _qt_internal_add_deploy_support("${targets_file}") + endif() + + # Make sure to look under the Qt bin dir with find_program, rather than randomly picking up + # a deployqt tool in the system. + # QT6_INSTALL_PREFIX is not set during Qt build, so add the hints conditionally. + set(find_program_hints) + if(QT6_INSTALL_PREFIX) + set(find_program_hints HINTS ${QT6_INSTALL_PREFIX}/${QT6_INSTALL_BINS}) + endif() + + # In the generator expression logic below, we need safe_target_file because + # CMake evaluates expressions in both the TRUE and FALSE branches of $. + # We still need a target to give to $ when we have no deploy + # tool, so we cannot use something like $ directly. + if(APPLE AND NOT IOS) + find_program(MACDEPLOYQT_EXECUTABLE macdeployqt + ${find_program_hints}) + set(fallback "$<$:${MACDEPLOYQT_EXECUTABLE}>") + set(target_if_exists "$") + set(have_deploy_tool "$") + set(safe_target_file + "$>") + set(__QT_DEPLOY_TOOL "$") + elseif(WIN32) + find_program(WINDEPLOYQT_EXECUTABLE windeployqt + ${find_program_hints}) + set(fallback "$<$:${WINDEPLOYQT_EXECUTABLE}>") + set(target_if_exists "$") + set(have_deploy_tool "$") + set(safe_target_file + "$>") + set(__QT_DEPLOY_TOOL "$") + elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT CMAKE_CROSSCOMPILING) + set(__QT_DEPLOY_TOOL "GRD") + else() + # Android is handled as a build target, not via this install-based approach. + # Therefore, we don't consider androiddeployqt here. + set(__QT_DEPLOY_TOOL "") + endif() + + # Determine whether this is a multi-config build with a Debug configuration. + set(is_multi_config_build_with_debug_config FALSE) + get_target_property(target_is_imported ${target} IMPORTED) + if(target_is_imported) + get_target_property(target_imported_configs ${target} IMPORTED_CONFIGURATIONS) + list(LENGTH target_imported_configs target_imported_configs_length) + if(target_imported_configs_length GREATER "1" + AND "DEBUG" IN_LIST target_imported_configs) + set(is_multi_config_build_with_debug_config TRUE) + endif() + endif() + + _qt_internal_add_deploy_support("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreDeploySupport.cmake") + + set(deploy_ignored_lib_dirs "") + if(__QT_DEPLOY_TOOL STREQUAL "GRD" AND NOT "${QT6_INSTALL_PREFIX}" STREQUAL "") + # Set up the directories we want to ignore when running file(GET_RUNTIME_DEPENDENCIES). + # If the Qt prefix is the root of one of those directories, don't ignore that directory. + # For example, if Qt's installation prefix is /usr, then we don't want to ignore /usr/lib. + foreach(link_dir IN LISTS CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES) + file(RELATIVE_PATH relative_dir "${QT6_INSTALL_PREFIX}" "${link_dir}") + if(relative_dir STREQUAL "") + # The Qt prefix is exactly ${link_dir}. + continue() + endif() + if(IS_ABSOLUTE "${relative_dir}" OR relative_dir MATCHES "^\\.\\./") + # The Qt prefix is outside of ${link_dir}. + list(APPEND deploy_ignored_lib_dirs "${link_dir}") + endif() + endforeach() + endif() + + # Check whether we will have to adjust the RPATH of plugins. + if("${QT_DEPLOY_FORCE_ADJUST_RPATHS}" STREQUAL "") + set(must_adjust_plugins_rpath "") + if(NOT CMAKE_SYSTEM_NAME STREQUAL "Windows" + AND NOT CMAKE_INSTALL_LIBDIR STREQUAL QT6_INSTALL_LIBS) + set(must_adjust_plugins_rpath ON) + endif() + else() + set(must_adjust_plugins_rpath "${QT_DEPLOY_FORCE_ADJUST_RPATHS}") + endif() + + # Find the patchelf executable if necessary. + if(must_adjust_plugins_rpath) + if(CMAKE_VERSION VERSION_LESS "3.21") + set(QT_DEPLOY_USE_PATCHELF ON) + endif() + if(QT_DEPLOY_USE_PATCHELF) + find_program(QT_DEPLOY_PATCHELF_EXECUTABLE patchelf) + if(NOT QT_DEPLOY_PATCHELF_EXECUTABLE) + set(QT_DEPLOY_PATCHELF_EXECUTABLE "patchelf") + message(WARNING "The patchelf executable could not be located. " + "To use Qt's CMake deployment API, install patchelf or upgrade CMake to 3.21 " + "or newer.") + endif() + endif() + endif() + + # Generate path to the target (not host) qtpaths file. Needed for windeployqt when + # cross-compiling from an x86_64 host to an arm64 target, so it knows which architecture + # libraries should be deployed. + if(CMAKE_HOST_WIN32) + if(CMAKE_CROSSCOMPILING) + set(qt_paths_ext ".bat") + else() + set(qt_paths_ext ".exe") + endif() + else() + set(qt_paths_ext "") + endif() + + + + set(target_qtpaths_path "") + set(qtpaths_prefix "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_BINS}") + get_property(qt_major_version TARGET "${target}" PROPERTY INTERFACE_QT_MAJOR_VERSION) + if(qt_major_version) + set(target_qtpaths_with_major_version_path + "${qtpaths_prefix}/qtpaths${qt_major_version}${qt_paths_ext}") + if(EXISTS "${target_qtpaths_with_major_version_path}") + set(target_qtpaths_path "${target_qtpaths_with_major_version_path}") + endif() + endif() + + if(NOT target_qtpaths_path) + set(target_qtpaths_path_without_version "${qtpaths_prefix}/qtpaths${qt_paths_ext}") + if(EXISTS "${target_qtpaths_path_without_version}") + set(target_qtpaths_path "${target_qtpaths_path_without_version}") + endif() + endif() + + if(NOT target_qtpaths_path) + message(DEBUG "No qtpaths executable found for deployment purposes.") + endif() + + file(GENERATE OUTPUT "${QT_DEPLOY_SUPPORT}" CONTENT +"cmake_minimum_required(VERSION 3.16...3.21) + +# These are part of the public API. Projects should use them to provide a +# consistent set of prefix-relative destinations. +if(NOT QT_DEPLOY_BIN_DIR) + set(QT_DEPLOY_BIN_DIR \"${CMAKE_INSTALL_BINDIR}\") +endif() +if(NOT QT_DEPLOY_LIBEXEC_DIR) + set(QT_DEPLOY_LIBEXEC_DIR \"${CMAKE_INSTALL_LIBEXECDIR}\") +endif() +if(NOT QT_DEPLOY_LIB_DIR) + set(QT_DEPLOY_LIB_DIR \"${CMAKE_INSTALL_LIBDIR}\") +endif() +if(NOT QT_DEPLOY_PLUGINS_DIR) + set(QT_DEPLOY_PLUGINS_DIR \"plugins\") +endif() +if(NOT QT_DEPLOY_QML_DIR) + set(QT_DEPLOY_QML_DIR \"qml\") +endif() +if(NOT QT_DEPLOY_TRANSLATIONS_DIR) + set(QT_DEPLOY_TRANSLATIONS_DIR \"translations\") +endif() +if(NOT QT_DEPLOY_PREFIX) + set(QT_DEPLOY_PREFIX \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}\") +endif() +if(QT_DEPLOY_PREFIX STREQUAL \"\") + set(QT_DEPLOY_PREFIX .) +endif() +if(NOT QT_DEPLOY_IGNORED_LIB_DIRS) + set(QT_DEPLOY_IGNORED_LIB_DIRS \"${deploy_ignored_lib_dirs}\") +endif() + +# These are internal implementation details. They may be removed at any time. +set(__QT_DEPLOY_SYSTEM_NAME \"${CMAKE_SYSTEM_NAME}\") +set(__QT_DEPLOY_IS_SHARED_LIBS_BUILD \"${QT6_IS_SHARED_LIBS_BUILD}\") +set(__QT_DEPLOY_TOOL \"${__QT_DEPLOY_TOOL}\") +set(__QT_DEPLOY_IMPL_DIR \"${deploy_impl_dir}\") +set(__QT_DEPLOY_VERBOSE \"${QT_ENABLE_VERBOSE_DEPLOYMENT}\") +set(__QT_CMAKE_EXPORT_NAMESPACE \"${QT_CMAKE_EXPORT_NAMESPACE}\") +set(__QT_DEPLOY_GENERATOR_IS_MULTI_CONFIG \"${is_multi_config}\") +set(__QT_DEPLOY_ACTIVE_CONFIG \"$\") +set(__QT_NO_CREATE_VERSIONLESS_FUNCTIONS \"${QT_NO_CREATE_VERSIONLESS_FUNCTIONS}\") +set(__QT_DEFAULT_MAJOR_VERSION \"${QT_DEFAULT_MAJOR_VERSION}\") +set(__QT_DEPLOY_QT_ADDITIONAL_PACKAGES_PREFIX_PATH \"${QT_ADDITIONAL_PACKAGES_PREFIX_PATH}\") +set(__QT_DEPLOY_QT_INSTALL_PREFIX \"${QT6_INSTALL_PREFIX}\") +set(__QT_DEPLOY_QT_INSTALL_BINS \"${QT6_INSTALL_BINS}\") +set(__QT_DEPLOY_QT_INSTALL_DATA \"${QT6_INSTALL_DATA}\") +set(__QT_DEPLOY_QT_INSTALL_LIBEXECS \"${QT6_INSTALL_LIBEXECS}\") +set(__QT_DEPLOY_QT_INSTALL_PLUGINS \"${QT6_INSTALL_PLUGINS}\") +set(__QT_DEPLOY_QT_INSTALL_TRANSLATIONS \"${QT6_INSTALL_TRANSLATIONS}\") +set(__QT_DEPLOY_TARGET_QT_PATHS_PATH \"${target_qtpaths_path}\") +set(__QT_DEPLOY_PLUGINS \"\") +set(__QT_DEPLOY_MUST_ADJUST_PLUGINS_RPATH \"${must_adjust_plugins_rpath}\") +set(__QT_DEPLOY_USE_PATCHELF \"${QT_DEPLOY_USE_PATCHELF}\") +set(__QT_DEPLOY_PATCHELF_EXECUTABLE \"${QT_DEPLOY_PATCHELF_EXECUTABLE}\") +set(__QT_DEPLOY_QT_IS_MULTI_CONFIG_BUILD_WITH_DEBUG \"${is_multi_config_build_with_debug_config}\") +set(__QT_DEPLOY_QT_DEBUG_POSTFIX \"${QT6_DEBUG_POSTFIX}\") + +# Define the CMake commands to be made available during deployment. +set(__qt_deploy_support_files + \"$>,\" + \">\" +) +foreach(__qt_deploy_support_file IN LISTS __qt_deploy_support_files) + include(\"\${__qt_deploy_support_file}\") +endforeach() + +unset(__qt_deploy_support_file) +unset(__qt_deploy_support_files) +") +endfunction() + +# Write deployment information for the targets of the project. +function(_qt_internal_write_target_deploy_info out_file) + set(targets "") + set(dynamic_target_types EXECUTABLE SHARED_LIBRARY MODULE_LIBRARY) + _qt_internal_collect_buildsystem_targets(targets + "${CMAKE_SOURCE_DIR}" INCLUDE ${dynamic_target_types} STATIC_LIBRARY) + set(content "") + foreach(target IN LISTS targets) + set(var_prefix "__QT_DEPLOY_TARGET_${target}") + string(APPEND content "set(${var_prefix}_FILE $)\n") + get_target_property(target_type ${target} TYPE) + string(APPEND content "set(${var_prefix}_TYPE ${target_type})\n") + if(WIN32 AND CMAKE_VERSION GREATER_EQUAL "3.21" + AND target_type IN_LIST dynamic_target_types) + string(APPEND content + "set(${var_prefix}_RUNTIME_DLLS $)\n") + endif() + endforeach() + file(GENERATE OUTPUT "${out_file}" CONTENT "${content}") +endfunction() + +function(_qt_internal_is_examples_deployment_supported_in_current_config out_var out_var_reason) + # Deployment API doesn't work when examples / tests are built in-tree of a prefix qt build. + if(QT_BUILDING_QT AND QT_WILL_INSTALL AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS) + set(deployment_supported FALSE) + set(not_supported_reason "PREFIX_BUILD") + else() + set(deployment_supported TRUE) + set(not_supported_reason "") + endif() + + set(${out_var} "${deployment_supported}" PARENT_SCOPE) + set(${out_var_reason} "${not_supported_reason}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_should_skip_deployment_api out_var out_var_reason) + set(skip_deployment FALSE) + _qt_internal_is_examples_deployment_supported_in_current_config( + deployment_supported + not_supported_reason + ) + + # Allow opting out of deployment, so that we can add deployment api to all our examples, + # but only run it in the CI for a select few, to avoid the overhead of deploying all examples. + if(QT_INTERNAL_SKIP_DEPLOYMENT OR (NOT deployment_supported)) + set(skip_deployment TRUE) + endif() + + set(reason "") + if(NOT deployment_supported) + set(reason "${not_supported_reason}") + elseif(QT_INTERNAL_SKIP_DEPLOYMENT) + set(reason "SKIP_REQUESTED") + endif() + + set(${out_var} "${skip_deployment}" PARENT_SCOPE) + set(${out_var_reason} "${reason}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_should_skip_post_build_deployment_api out_var out_var_reason) + set(skip_deployment FALSE) + set(deployment_supported TRUE) + + # Allow opting out of deployment, so that we can add deployment api to all our examples, + # but only run it in the CI for a select few, to avoid the overhead of deploying all examples. + if(QT_INTERNAL_SKIP_DEPLOYMENT OR (NOT deployment_supported)) + set(skip_deployment TRUE) + endif() + + set(reason "") + if(NOT deployment_supported) + set(reason "REASON_UNSPECIFIED") + elseif(QT_INTERNAL_SKIP_DEPLOYMENT) + set(reason "SKIP_REQUESTED") + endif() + + set(${out_var} "${skip_deployment}" PARENT_SCOPE) + set(${out_var_reason} "${reason}" PARENT_SCOPE) +endfunction() + +# Generate a deploy script that does nothing aside from showing a warning message. +# The warning can be hidden by setting the QT_INTERNAL_HIDE_NO_OP_DEPLOYMENT_WARNING variable. +function(_qt_internal_generate_no_op_deploy_script) + set(no_value_options + ) + set(single_value_options + FUNCTION_NAME + NAME + OUTPUT_SCRIPT + SKIP_REASON + TARGET + ) + set(multi_value_options + ) + + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + if(NOT arg_OUTPUT_SCRIPT) + message(FATAL_ERROR "No OUTPUT_SCRIPT option specified") + endif() + if(NOT arg_FUNCTION_NAME) + message(FATAL_ERROR "No FUNCTION_NAME option specified") + endif() + + set(generate_args "") + if(arg_NAME) + list(APPEND generate_args NAME "${arg_NAME}") + endif() + if(arg_TARGET) + list(APPEND generate_args TARGET "${arg_TARGET}") + endif() + + set(function_name "${arg_FUNCTION_NAME}") + + # The empty space is required, otherwise + set(content " +message(DEBUG \"Running no-op deployment script because QT_INTERNAL_SKIP_DEPLOYMENT was ON.\") +") + if(NOT QT_INTERNAL_HIDE_NO_OP_DEPLOYMENT_WARNING AND arg_SKIP_REASON STREQUAL "PREFIX_BUILD") + set(content " +message(STATUS \"${function_name}(TARGET ${arg_TARGET}) is a no-op for prefix \" +\"non-standalone builds due to various issues. Consider using a -no-prefix build \" +\"or qt-internal-configure-tests or qt-internal-configure-examples if you want deployment to run.\") +") + endif() + + qt6_generate_deploy_script( + ${generate_args} + OUTPUT_SCRIPT deploy_script + CONTENT "${content}") + + set("${arg_OUTPUT_SCRIPT}" "${deploy_script}" PARENT_SCOPE) +endfunction() + +# We basically mirror CMake's policy setup +# A policy can be set to OLD, set to NEW or unset +# unset is the default state +# +function(qt6_policy mode policy behaviorOrVariable) + # When building Qt, tests and examples might expect a policy to be known, but they won't be + # known depending on which scope or when a find_package(Module) with the respective policy + # is called. Check the global list of known policies to accommodate that. + if(QT_BUILDING_QT AND NOT DEFINED QT_KNOWN_POLICY_${policy}) + get_property(global_known_policies GLOBAL PROPERTY _qt_global_known_policies) + if(policy IN_LIST global_known_policies) + set(QT_KNOWN_POLICY_${policy} TRUE) + endif() + endif() + + if (NOT DEFINED QT_KNOWN_POLICY_${policy}) + message(FATAL_ERROR + "${policy} is not a known Qt policy. Did you include the necessary Qt module?" + ) + endif() + if (${mode} STREQUAL "SET") + set(behavior ${behaviorOrVariable}) + if (${behavior} STREQUAL "NEW" OR ${behavior} STREQUAL "OLD") + set(__QT_INTERNAL_POLICY_${policy} ${behavior} PARENT_SCOPE) + else() + message(FATAL_ERROR "Qt policies must be either set to NEW or OLD, but got ${behavior}") + endif() + else(${mode} STREQUAL "GET") + set(variable "${behaviorOrVariable}") + set("${variable}" "${__QT_INTERNAL_POLICY_${policy}}" PARENT_SCOPE) + endif() +endfunction() + +# Internal helper function; can be used in any module before doing a policy check +function(__qt_internal_setup_policy policy sinceversion policyexplanation) + if(DEFINED __QT_INTERNAL_POLICY_${policy}) + if (__QT_INTERNAL_POLICY_${policy} STREQUAL "OLD") + # policy is explicitly disabled + message(DEPRECATION + "Qt policy ${policy} is set to OLD. " + "Support for the old behavior will be removed in a future major version of Qt." + ) + endif() + #else: policy is already enabled, nothing to do + elseif (${sinceversion} VERSION_LESS_EQUAL __qt_policy_check_version) + # we cannot use the public function here as we want to set it in parent scope + set(__QT_INTERNAL_POLICY_${policy} "NEW" PARENT_SCOPE) + elseif(NOT "${QT_NO_SHOW_OLD_POLICY_WARNINGS}") + message(AUTHOR_WARNING + "Qt policy ${policy} is not set: " + "${policyexplanation} " + "Use the qt_policy command to set the policy and suppress this warning.\n" + ) + endif() +endfunction() + +# Note this needs to be a macro because it sets variables intended for the +# calling scope. +macro(qt6_standard_project_setup) + # A parent project might want to prevent child projects pulled in with + # add_subdirectory() from changing the parent's preferred arrangement. + # They can set this variable to true to effectively disable this function. + if(NOT QT_NO_STANDARD_PROJECT_SETUP) + + set(__qt_sps_args_option) + set(__qt_sps_args_single + REQUIRES + SUPPORTS_UP_TO + I18N_SOURCE_LANGUAGE + ) + set(__qt_sps_args_multi + I18N_TRANSLATED_LANGUAGES + ) + cmake_parse_arguments(__qt_sps_arg + "${__qt_sps_args_option}" + "${__qt_sps_args_single}" + "${__qt_sps_args_multi}" + ${ARGN} + ) + + if(__qt_sps_arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + # Set the Qt CMake policy based on the requested version(s) + set(__qt_policy_check_version "6.0.0") + if(Qt6_VERSION_MAJOR) + set(__qt_current_version + "${Qt6_VERSION_MAJOR}.${Qt6_VERSION_MINOR}.${Qt6_VERSION_PATCH}") + elseif(QT_BUILDING_QT) + set(__qt_current_version + "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}") + else() + message(FATAL_ERROR "Can not determine Qt version.") + endif() + if(__qt_sps_arg_REQUIRES) + if("${__qt_current_version}" VERSION_LESS "${__qt_sps_arg_REQUIRES}") + message(FATAL_ERROR + "Project required a Qt minimum version of ${__qt_sps_arg_REQUIRES}, " + "but current version is only ${__qt_current_version}.") + endif() + set(__qt_policy_check_version "${__qt_sps_arg_REQUIRES}") + endif() + if(__qt_sps_arg_SUPPORTS_UP_TO) + if(__qt_sps_arg_REQUIRES) + if(${__qt_sps_arg_SUPPORTS_UP_TO} VERSION_LESS ${__qt_sps_arg_REQUIRES}) + message(FATAL_ERROR "SUPPORTS_UP_TO must be larger than or equal to REQUIRES.") + endif() + set(__qt_policy_check_version "${__qt_sps_arg_SUPPORTS_UP_TO}") + else() + message(FATAL_ERROR "Please specify the REQUIRES as well.") + endif() + endif() + + # All changes below this point should not result in a change to an + # existing value, except for CMAKE_INSTALL_RPATH which may append new + # values (but no duplicates). + + # Use standard install locations, provided by GNUInstallDirs. All + # platforms should have this included so that we know the + # CMAKE_INSTALL_xxxDIR variables will be set. + include(GNUInstallDirs) + if(WIN32) + # Windows has no RPATH support, so we need all non-plugin DLLs in + # the same directory as application executables if we want to be + # able to run them without having to augment the PATH environment + # variable. Don't discard an existing value in case the project has + # already set this to somewhere else. Our setting is somewhat + # opinionated, so make it easy for projects to choose something else. + if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif() + elseif(NOT APPLE) + # Apart from Windows and Apple, most other platforms support RPATH + # and $ORIGIN. Make executables and non-static libraries use an + # install RPATH that allows them to find library dependencies if the + # project installs things to the directories defined by the + # CMAKE_INSTALL_xxxDIR variables (which is what CMake's defaults + # are based on). + file(RELATIVE_PATH __qt_relDir + ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR} + ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR} + ) + list(APPEND CMAKE_INSTALL_RPATH $ORIGIN $ORIGIN/${__qt_relDir}) + list(REMOVE_DUPLICATES CMAKE_INSTALL_RPATH) + unset(__qt_reldir) + endif() + + # Turn these on by default, unless they are already set. Projects can + # always turn off any they really don't want after we return. + foreach(auto_set IN ITEMS MOC UIC) + if(NOT DEFINED CMAKE_AUTO${auto_set}) + set(CMAKE_AUTO${auto_set} TRUE) + endif() + endforeach() + + # Enable folder support for IDEs. CMake >= 3.26 enables USE_FOLDERS by default but this is + # guarded by CMake policy CMP0143. + get_property(__qt_use_folders GLOBAL PROPERTY USE_FOLDERS) + if(__qt_use_folders OR "${__qt_use_folders}" STREQUAL "") + set_property(GLOBAL PROPERTY USE_FOLDERS ON) + get_property(__qt_qt_targets_folder GLOBAL PROPERTY QT_TARGETS_FOLDER) + if("${__qt_qt_targets_folder}" STREQUAL "") + set(__qt_qt_targets_folder QtInternalTargets) + set_property(GLOBAL PROPERTY QT_TARGETS_FOLDER ${__qt_qt_targets_folder}) + endif() + get_property(__qt_autogen_targets_folder GLOBAL PROPERTY AUTOGEN_TARGETS_FOLDER) + if("${__qt_autogen_targets_folder}" STREQUAL "") + set_property(GLOBAL PROPERTY AUTOGEN_TARGETS_FOLDER ${__qt_qt_targets_folder}) + endif() + endif() + + # Hide generated files in dedicated folder. Unfortunately we can't use a + # top level "Generated Files" folder for this, as CMake will then put the + # folder first in the list of folders, whereas we want to keep Sources and + # Headers front and center. See also _qt_internal_finalize_source_groups + set_property(GLOBAL PROPERTY AUTOGEN_SOURCE_GROUP "Source Files/Generated") + + # Treat metatypes JSON files as generated. We propagate these INTERFACE_SOURCES, + # due to CMake's lack of a generic mechanism for property inheritance (see + # https://gitlab.kitware.com/cmake/cmake/-/issues/20416), but we don't want + # them to clutter up the user's project. + source_group("Source Files/Generated" REGULAR_EXPRESSION "(_metatypes\\.json)$") + + # I18N support. + if(DEFINED __qt_sps_arg_I18N_TRANSLATED_LANGUAGES + AND NOT DEFINED QT_I18N_TRANSLATED_LANGUAGES) + set(QT_I18N_TRANSLATED_LANGUAGES ${__qt_sps_arg_I18N_TRANSLATED_LANGUAGES}) + endif() + if(NOT DEFINED __qt_sps_arg_I18N_SOURCE_LANGUAGE) + set(__qt_sps_arg_I18N_SOURCE_LANGUAGE en) + endif() + if(NOT DEFINED QT_I18N_SOURCE_LANGUAGE) + set(QT_I18N_SOURCE_LANGUAGE ${__qt_sps_arg_I18N_SOURCE_LANGUAGE}) + endif() + + if(CMAKE_GENERATOR STREQUAL "Xcode") + # Ensure we always use device SDK for Xcode for single-arch Qt builds + set(qt_osx_arch_count 0) + if(QT_OSX_ARCHITECTURES) + list(LENGTH QT_OSX_ARCHITECTURES qt_osx_arch_count) + endif() + if(NOT qt_osx_arch_count GREATER 1 AND ${CMAKE_OSX_SYSROOT} MATCHES "^[a-z]+simulator$") + # Xcode expects the base SDK to be the device SDK + set(simulator_sysroot "${CMAKE_OSX_SYSROOT}") + string(REGEX REPLACE "simulator" "os" CMAKE_OSX_SYSROOT "${CMAKE_OSX_SYSROOT}") + set(CMAKE_OSX_SYSROOT "${CMAKE_OSX_SYSROOT}" CACHE STRING "" FORCE) + set(CMAKE_XCODE_ATTRIBUTE_SUPPORTED_PLATFORMS "${simulator_sysroot}") + endif() + endif() + endif() +endmacro() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + macro(qt_standard_project_setup) + qt6_standard_project_setup(${ARGV}) + endmacro() + macro(qt_policy) + qt6_policy(${ARGV}) + endmacro() +endif() + +# Store in ${out_var} the i18n catalogs that belong to the passed Qt modules. +# The catalog "qtbase" is always added to the result. +# +# Example: +# _qt_internal_get_i18n_catalogs_for_modules(catalogs Quick Help) +# catalogs -> qtbase;qtdeclarative;qt_help +function(_qt_internal_get_i18n_catalogs_for_modules out_var) + set(result "qtbase") + set(modules "${ARGN}") + set(module_catalog_mapping + "Bluetooth|Nfc" qtconnectivity + "Help" qt_help + "Multimedia(Widgets|QuickPrivate)?" qtmultimedia + "Qml|Quick" qtdeclarative + "SerialPort" qtserialport + "WebEngine" qtwebengine + "WebSockets" qtwebsockets + ) + list(LENGTH module_catalog_mapping max_i) + math(EXPR max_i "${max_i} - 1") + foreach(module IN LISTS modules) + foreach(i RANGE 0 ${max_i} 2) + list(GET module_catalog_mapping ${i} module_rex) + if(NOT module MATCHES "^(${module_rex})") + continue() + endif() + math(EXPR k "${i} + 1") + list(GET module_catalog_mapping ${k} catalog) + list(APPEND result ${catalog}) + endforeach() + endforeach() + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + +function(qt6_generate_deploy_script) + set(no_value_options "") + set(single_value_options + CONTENT + OUTPUT_SCRIPT + NAME + TARGET + + # TODO: For backward compatibility / transitional use only, + # remove at some point + FILENAME_VARIABLE + ) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + # TODO: Remove when FILENAME_VARIABLE is fully removed + # Handle the slow deprecation of FILENAME_VARIABLE + if(arg_FILENAME_VARIABLE) + if(arg_OUTPUT_SCRIPT AND NOT arg_FILENAME_VARIABLE STREQUAL arg_OUTPUT_SCRIPT) + message(FATAL_ERROR + "Both FILENAME_VARIABLE and OUTPUT_SCRIPT were given and were different. " + "Only one of the two should be used." + ) + endif() + message(AUTHOR_WARNING + "The FILENAME_VARIABLE keyword is deprecated and will be removed soon. Please use OUTPUT_SCRIPT instead.") + set(arg_OUTPUT_SCRIPT "${arg_FILENAME_VARIABLE}") + unset(arg_FILENAME_VARIABLE) + endif() + + if(NOT arg_OUTPUT_SCRIPT) + message(FATAL_ERROR "OUTPUT_SCRIPT must be specified") + endif() + + if("${arg_CONTENT}" STREQUAL "") + message(FATAL_ERROR "CONTENT must be specified") + endif() + + # Check whether manual finalization is needed. + if(CMAKE_VERSION VERSION_LESS "3.19") + get_target_property(is_immediately_finalized ${arg_TARGET} _qt_is_immediately_finalized) + if(is_immediately_finalized) + message(WARNING + "Deployment of plugins for target '${arg_TARGET}' will not work. " + "Either, upgrade CMake to version 3.19 or newer, or call " + "qt_finalize_target(${arg_TARGET}) after generating the deployment script." + ) + endif() + endif() + + # Mark the target as "to be deployed". + set_property(TARGET ${arg_TARGET} PROPERTY _qt_marked_for_deployment ON) + + # If the target already was finalized, maybe because it was defined in a subdirectory, generate + # the plugin deployment information here. + get_target_property(is_finalized "${arg_TARGET}" _qt_is_finalized) + if(is_finalized) + __qt_internal_generate_plugin_deployment_info(${arg_TARGET}) + endif() + + # Create a file name that will be unique for this target and the combination + # of arguments passed to this command. This allows the project to call us + # multiple times with different arguments for the same target (e.g. to + # create deployment scripts for different scenarios). + set(file_base_name "custom") + if(NOT "${arg_NAME}" STREQUAL "") + set(file_base_name "${arg_NAME}") + elseif(NOT "${arg_TARGET}" STREQUAL "") + set(file_base_name "${arg_TARGET}") + endif() + string(MAKE_C_IDENTIFIER "${file_base_name}" target_id) + string(SHA1 args_hash "${ARGV}") + string(SUBSTRING "${args_hash}" 0 10 short_hash) + _qt_internal_get_deploy_impl_dir(deploy_impl_dir) + set(deploy_script "${deploy_impl_dir}/deploy_${target_id}_${short_hash}") + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(config_infix "-$") + else() + set(config_infix "") + endif() + string(APPEND deploy_script "${config_infix}.cmake") + set(${arg_OUTPUT_SCRIPT} "${deploy_script}" PARENT_SCOPE) + + _qt_internal_get_i18n_catalogs_for_modules(catalogs ${QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE}) + set(boiler_plate "include(${QT_DEPLOY_SUPPORT}) +include(\"\${CMAKE_CURRENT_LIST_DIR}/${arg_TARGET}-plugins${config_infix}.cmake\" OPTIONAL) +set(__QT_DEPLOY_I18N_CATALOGS \"${catalogs}\") +") + list(TRANSFORM arg_CONTENT REPLACE "\\$" "\$") + file(GENERATE OUTPUT ${deploy_script} CONTENT "${boiler_plate}${arg_CONTENT}") +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + macro(qt_generate_deploy_script) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_generate_deploy_script(${ARGV}) + else() + message(FATAL_ERROR "qt_generate_deploy_script() is only available in Qt 6.") + endif() + endmacro() +endif() + +function(qt6_generate_deploy_app_script) + # We use a TARGET keyword option instead of taking the target as the first + # positional argument. This is to keep open the possibility of deploying + # an app for which we don't have a target (e.g. an application from a + # third party project that the caller may want to include in their own + # package). We would add an EXECUTABLE keyword for that, which would be + # mutually exclusive with the TARGET keyword. + set(no_value_options + NO_TRANSLATIONS + NO_COMPILER_RUNTIME + NO_UNSUPPORTED_PLATFORM_ERROR + ) + set(single_value_options + TARGET + OUTPUT_SCRIPT + + # TODO: For backward compatibility / transitional use only, + # remove at some point + FILENAME_VARIABLE + ) + set(qt_deploy_runtime_dependencies_options + # These options are forwarded as is to qt_deploy_runtime_dependencies. + DEPLOY_TOOL_OPTIONS + PRE_INCLUDE_REGEXES + PRE_EXCLUDE_REGEXES + POST_INCLUDE_REGEXES + POST_EXCLUDE_REGEXES + POST_INCLUDE_FILES + POST_EXCLUDE_FILES + ) + set(multi_value_options + ${qt_deploy_runtime_dependencies_options} + ) + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + if(NOT arg_TARGET) + message(FATAL_ERROR "TARGET must be specified") + endif() + + # TODO: Remove when FILENAME_VARIABLE is fully removed + # Handle the slow deprecation of FILENAME_VARIABLE + if(arg_FILENAME_VARIABLE) + if(arg_OUTPUT_SCRIPT AND NOT arg_FILENAME_VARIABLE STREQUAL arg_OUTPUT_SCRIPT) + message(FATAL_ERROR + "Both FILENAME_VARIABLE and OUTPUT_SCRIPT were given and were different. " + "Only one of the two should be used." + ) + endif() + message(AUTHOR_WARNING + "The FILENAME_VARIABLE keyword is deprecated and will be removed soon. Please use OUTPUT_SCRIPT instead.") + set(arg_OUTPUT_SCRIPT "${arg_FILENAME_VARIABLE}") + unset(arg_FILENAME_VARIABLE) + endif() + + if(NOT arg_OUTPUT_SCRIPT) + message(FATAL_ERROR "OUTPUT_SCRIPT must be specified") + endif() + + get_target_property(is_bundle ${arg_TARGET} MACOSX_BUNDLE) + + set(unsupported_platform_extra_message "") + if(QT6_IS_SHARED_LIBS_BUILD) + set(qt_build_type_string "shared Qt libs") + else() + set(qt_build_type_string "static Qt libs") + endif() + + if(CMAKE_CROSSCOMPILING) + string(APPEND qt_build_type_string ", cross-compiled") + endif() + + if(NOT is_bundle) + string(APPEND qt_build_type_string ", non-bundle app") + set(unsupported_platform_extra_message + "Executable targets have to be app bundles to use this command on Apple platforms.") + endif() + + set(generate_args + TARGET ${arg_TARGET} + OUTPUT_SCRIPT deploy_script + ) + + set(common_deploy_args "") + if(arg_NO_TRANSLATIONS) + string(APPEND common_deploy_args " NO_TRANSLATIONS\n") + endif() + if(arg_NO_COMPILER_RUNTIME) + string(APPEND common_deploy_args " NO_COMPILER_RUNTIME\n") + endif() + + # Forward the arguments that are exactly the same for qt_deploy_runtime_dependencies. + foreach(var IN LISTS qt_deploy_runtime_dependencies_options) + if(NOT "${arg_${var}}" STREQUAL "") + list(APPEND common_deploy_args ${var} ${arg_${var}}) + endif() + endforeach() + + _qt_internal_should_skip_deployment_api(skip_deployment skip_reason) + if(skip_deployment) + _qt_internal_generate_no_op_deploy_script( + FUNCTION_NAME "qt6_generate_deploy_app_script" + SKIP_REASON "${skip_reason}" + ${generate_args} + ) + elseif(APPLE AND NOT IOS AND QT6_IS_SHARED_LIBS_BUILD AND is_bundle) + # TODO: Consider handling non-bundle applications in the future using the generic cmake + # runtime dependency feature. + qt6_generate_deploy_script(${generate_args} + CONTENT " +qt6_deploy_runtime_dependencies( + EXECUTABLE $.app +${common_deploy_args}) +") + + elseif(WIN32 AND QT6_IS_SHARED_LIBS_BUILD) + qt6_generate_deploy_script(${generate_args} + CONTENT " +qt6_deploy_runtime_dependencies( + EXECUTABLE $ + GENERATE_QT_CONF +${common_deploy_args}) +") + + elseif(UNIX AND NOT APPLE AND NOT ANDROID AND QT6_IS_SHARED_LIBS_BUILD + AND NOT CMAKE_CROSSCOMPILING) + qt6_generate_deploy_script(${generate_args} + CONTENT " +qt6_deploy_runtime_dependencies( + EXECUTABLE $ + GENERATE_QT_CONF +${common_deploy_args}) +") + + elseif(NOT arg_NO_UNSUPPORTED_PLATFORM_ERROR AND NOT QT_INTERNAL_NO_UNSUPPORTED_PLATFORM_ERROR) + # Currently we don't deploy runtime dependencies if cross-compiling or using a static Qt. + # Error out by default unless the project opted out of the error. + # This provides us a migration path in the future without breaking compatibility promises. + message(FATAL_ERROR + "Support for installing runtime dependencies is not implemented for " + "this target platform (${CMAKE_SYSTEM_NAME}, ${qt_build_type_string}). " + ${unsupported_platform_extra_message} + ) + else() + set(skip_message + "_qt_internal_show_skip_runtime_deploy_message(\"${qt_build_type_string}\"") + if(unsupported_platform_extra_message) + string(APPEND skip_message + "\n EXTRA_MESSAGE \"${unsupported_platform_extra_message}\"") + endif() + string(APPEND skip_message "\n)") + qt6_generate_deploy_script(${generate_args} CONTENT "${skip_message}") + endif() + + set(${arg_OUTPUT_SCRIPT} "${deploy_script}" PARENT_SCOPE) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + macro(qt_generate_deploy_app_script) + qt6_generate_deploy_app_script(${ARGV}) + endmacro() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreResourceInit.in.cpp b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreResourceInit.in.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c35e26f2b61a80d4c50f2364c9aba3be32b723b9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreResourceInit.in.cpp @@ -0,0 +1,14 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause + +// This file was generated by the qt_add_resources command. + +#include + +QT_DECLARE_EXTERN_RESOURCE(@RESOURCE_NAME@) + +namespace { + struct resourceReferenceKeeper { + resourceReferenceKeeper() { QT_KEEP_RESOURCE(@RESOURCE_NAME@) } + } resourceReferenceKeeperInstance; +} diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a4e59f2d01fa55c9170bcb2ea1ac1862c2e1168a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Core" for configuration "Debug" +set_property(TARGET Qt6::Core APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::Core PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6Cored.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6Cored.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Core ) +list(APPEND _cmake_import_check_files_for_Qt6::Core "${_IMPORT_PREFIX}/lib/Qt6Cored.lib" "${_IMPORT_PREFIX}/bin/Qt6Cored.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7531ec25fa71e2472badc90e71406d05ca17c699 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Core" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::Core APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::Core PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6Core.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6Core.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Core ) +list(APPEND _cmake_import_check_files_for_Qt6::Core "${_IMPORT_PREFIX}/lib/Qt6Core.lib" "${_IMPORT_PREFIX}/bin/Qt6Core.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b5b6e50dd216e2dbe6131131e58c7079e95d9c53 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreTargets.cmake @@ -0,0 +1,168 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Core Qt6::CorePrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Core +add_library(Qt6::Core SHARED IMPORTED) + +set_target_properties(Qt6::Core PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION;QT_COORD_TYPE" + INTERFACE_COMPILE_DEFINITIONS "QT_CORE_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtCore;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Platform;mpr;userenv;WrapAtomic::WrapAtomic;\$<\$>>,\$,EXECUTABLE>,\$>>:Qt6::EntryPointPrivate>" + INTERFACE_QT_COORD_TYPE "double" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6core_metatypes.json>" + QT_DISABLED_PRIVATE_FEATURES "clock_gettime;close_range;system_doubleconversion;dladdr;futimens;getauxval;getentropy;glib;icu;inotify;journald;system_libb2;linkat;memmem;memrchr;system_pcre2;poll_ppoll;poll_pollts;poll_poll;poll_select;posix_sem;posix_shm;qqnx_pps;renameat2;slog2;syslog;sysv_sem;sysv_shm;backtrace;cxx23_stacktrace;timezone_locale;lttng;etw;ctf;forkfd_pidfd;poll_exit_on_error;openssl_hash;use_bfd_linker;use_gold_linker;use_lld_linker;use_mold_linker;android_style_assets;gc_binaries;developer_build;private_tests;elf_private_full_version;reduce_exports;no_direct_extern_access;mips_dsp;mips_dspr2;neon;arm_crc32;arm_crypto;localtime_r;posix_fallocate;alloca_h;system_zlib;stdlib_libcpp;dbus_linked;libudev;dlopen;glibc_fortify_source;trivial_auto_var_init_pattern;stack_protector;stack_clash_protection;libstdcpp_assertions;libcpp_hardening;relro_now_linker" + QT_DISABLED_PUBLIC_FEATURES "clock_monotonic;glib;inotify;static;cross_compile;pkg_config;separate_debug_info;appstore_compliant;simulator_and_device;rpath;force_asserts;framework;cxx20;cxx2a;cxx2b;reduce_relocations;wasm_simd128;wasm_exceptions;zstd;openssl_linked;opensslv11" + QT_ENABLED_PRIVATE_FEATURES "doubleconversion;broken_threadlocal_dtors;mimetype_database;cpp_winrt;sha3_fast;hijricalendar;datetimeparser;pcre2;debug;x86intrin;sse2;sse3;ssse3;sse4_1;sse4_2;avx;f16c;avx2;avx512f;avx512er;avx512cd;avx512pf;avx512dq;avx512bw;avx512vl;avx512ifma;avx512vbmi;avx512vbmi2;aesni;vaes;rdrnd;rdseed;shani;localtime_s;alloca_malloc_h;alloca;dbus;gui;network;printsupport;sql;testlib;widgets;xml;openssl;relocatable;intelcet;msvc_obj_debug_info;force_debug_info;largefile;precompile_header;sse2;sse3;ssse3;sse4_1;sse4_2;avx;f16c;avx2;avx512f;avx512er;avx512cd;avx512pf;avx512dq;avx512bw;avx512vl;avx512ifma;avx512vbmi;avx512vbmi2;aesni;vaes;rdrnd;rdseed;shani" + QT_ENABLED_PUBLIC_FEATURES "cxx11_future;cxx17_filesystem;std_atomic64;mimetype;regularexpression;sharedmemory;shortcut;systemsemaphore;xmlstream;cpp_winrt;xmlstreamreader;xmlstreamwriter;textdate;datestring;process;processenvironment;temporaryfile;library;settings;filesystemwatcher;filesystemiterator;itemmodel;proxymodel;sortfilterproxymodel;identityproxymodel;transposeproxymodel;concatenatetablesproxymodel;stringlistmodel;translation;easingcurve;animation;gestures;jalalicalendar;islamiccivilcalendar;timezone;commandlineparser;cborstreamreader;cborstreamwriter;permissions;version_tagging;shared;debug_and_release;signaling_nan;thread;future;concurrent;dbus;opensslv30;shared;plugin_manifest;intelcet;shared;no_pkg_config;debug_and_release;openssl" + QT_QMAKE_PRIVATE_CONFIG "pcre2;msvc_obj_debug_info;force_debug_info;largefile;precompile_header;sse2;sse3;ssse3;sse4_1;sse4_2;avx;f16c;avx2;avx512f;avx512er;avx512cd;avx512pf;avx512dq;avx512bw;avx512vl;avx512ifma;avx512vbmi;avx512vbmi2;aesni;vaes;rdrnd;rdseed;shani" + QT_QMAKE_PUBLIC_CONFIG "shared;plugin_manifest;intelcet" + QT_QMAKE_PUBLIC_QT_CONFIG "shared;no_pkg_config;debug_and_release;openssl" + _qt_config_module_name "core" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtCore" + _qt_module_interface_name "Core" + _qt_package_name "Qt6Core" + _qt_package_version "6.8.1" + _qt_private_module_target_name "CorePrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Core" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::CorePrivate +add_library(Qt6::CorePrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::CorePrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtCore/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtCore/6.8.1/QtCore>" + INTERFACE_LINK_LIBRARIES "Qt6::Core" + _qt_config_module_name "core_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6Core" + _qt_package_version "6.8.1" + _qt_public_module_target_name "Core" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Core" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6CoreTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Platform" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f809e87054222a572f187773bc61ad261fd870c0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Core;CorePrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..47c30fb8eadfae470ae5a11040c9006189c36988 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Core/Qt6CoreVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Core;CorePrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..78bf9585b3287ace1745098aa128cf6d09a82438 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsAdditionalTargetInfo.cmake @@ -0,0 +1,268 @@ +# Additional target information for Qt6CoreTools +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +get_target_property(_qt_imported_location Qt6::syncqt IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::syncqt IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::syncqt" for configuration "Release" +set_property(TARGET Qt6::syncqt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::syncqt PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::syncqt" for configuration "MinSizeRel" +set_property(TARGET Qt6::syncqt APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::syncqt PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::syncqt PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::moc IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::moc IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::moc" for configuration "Release" +set_property(TARGET Qt6::moc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::moc PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::moc" for configuration "MinSizeRel" +set_property(TARGET Qt6::moc APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::moc PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::moc PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::rcc IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::rcc IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::rcc" for configuration "Release" +set_property(TARGET Qt6::rcc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::rcc PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::rcc" for configuration "MinSizeRel" +set_property(TARGET Qt6::rcc APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::rcc PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::rcc PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::tracepointgen IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::tracepointgen IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::tracepointgen" for configuration "Release" +set_property(TARGET Qt6::tracepointgen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::tracepointgen PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::tracepointgen" for configuration "MinSizeRel" +set_property(TARGET Qt6::tracepointgen APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::tracepointgen PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::tracepointgen PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::tracegen IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::tracegen IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::tracegen" for configuration "Release" +set_property(TARGET Qt6::tracegen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::tracegen PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::tracegen" for configuration "MinSizeRel" +set_property(TARGET Qt6::tracegen APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::tracegen PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::tracegen PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::cmake_automoc_parser IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::cmake_automoc_parser IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::cmake_automoc_parser" for configuration "Release" +set_property(TARGET Qt6::cmake_automoc_parser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::cmake_automoc_parser PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::cmake_automoc_parser" for configuration "MinSizeRel" +set_property(TARGET Qt6::cmake_automoc_parser APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::cmake_automoc_parser PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::cmake_automoc_parser PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::qlalr IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::qlalr IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::qlalr" for configuration "Release" +set_property(TARGET Qt6::qlalr APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::qlalr PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::qlalr" for configuration "MinSizeRel" +set_property(TARGET Qt6::qlalr APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::qlalr PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::qlalr PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::qtpaths IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::qtpaths IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::qtpaths" for configuration "Release" +set_property(TARGET Qt6::qtpaths APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::qtpaths PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::qtpaths" for configuration "MinSizeRel" +set_property(TARGET Qt6::qtpaths APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::qtpaths PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::qtpaths PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::androiddeployqt IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::androiddeployqt IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::androiddeployqt" for configuration "Release" +set_property(TARGET Qt6::androiddeployqt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::androiddeployqt PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::androiddeployqt" for configuration "MinSizeRel" +set_property(TARGET Qt6::androiddeployqt APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::androiddeployqt PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::androiddeployqt PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::androidtestrunner IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::androidtestrunner IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::androidtestrunner" for configuration "Release" +set_property(TARGET Qt6::androidtestrunner APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::androidtestrunner PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::androidtestrunner" for configuration "MinSizeRel" +set_property(TARGET Qt6::androidtestrunner APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::androidtestrunner PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::androidtestrunner PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::windeployqt IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::windeployqt IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::windeployqt" for configuration "Release" +set_property(TARGET Qt6::windeployqt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::windeployqt PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::windeployqt" for configuration "MinSizeRel" +set_property(TARGET Qt6::windeployqt APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::windeployqt PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::windeployqt PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::qmake IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::qmake IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::qmake" for configuration "Release" +set_property(TARGET Qt6::qmake APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::qmake PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::qmake" for configuration "MinSizeRel" +set_property(TARGET Qt6::qmake APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::qmake PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::qmake PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6b57bbe2f03cfaf98d7933cf5bc19df25b490d78 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake @@ -0,0 +1,105 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleToolsConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6CoreToolsDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreToolsDependencies.cmake") +endif() + +# If *Dependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6CoreTools_FOUND") + set("Qt6CoreTools_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreToolsTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreToolsAdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreToolsVersionlessTargets.cmake") + endif() +endif() + +foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() + + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::syncqt) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::moc) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::rcc) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::tracepointgen) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::tracegen) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::cmake_automoc_parser) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::qlalr) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::qtpaths) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::androiddeployqt) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::androidtestrunner) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::windeployqt) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6CoreTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::qmake) +endif() +set(Qt6CoreTools_TARGETS "Qt6::syncqt;Qt6::moc;Qt6::rcc;Qt6::tracepointgen;Qt6::tracegen;Qt6::cmake_automoc_parser;Qt6::qlalr;Qt6::qtpaths;Qt6::androiddeployqt;Qt6::androidtestrunner;Qt6::windeployqt;Qt6::qmake") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..55c62f579912951a1bab3a525d456271d7573ecf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6CoreToolsConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..93e7b8fe45741c6ef60d1556c39854e2ad1acd30 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake @@ -0,0 +1,32 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..10854acd94d07ad6b09aebbc5c0615ef025012a0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake @@ -0,0 +1,16 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Find "ModuleTools" dependencies, which are other ModuleTools packages. +set(Qt6CoreTools_FOUND FALSE) +set(__qt_CoreTools_tool_deps "") +foreach(__qt_CoreTools_target_dep ${__qt_CoreTools_tool_deps}) + list(GET __qt_CoreTools_target_dep 0 __qt_CoreTools_pkg) + list(GET __qt_CoreTools_target_dep 1 __qt_CoreTools_version) + + if (NOT ${__qt_CoreTools_pkg}_FOUND) + find_dependency(${__qt_CoreTools_pkg} ${__qt_CoreTools_version}) + endif() +endforeach() + +set(Qt6CoreTools_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0c809c7650339e5c5ec95b84f02dd78c0c7a30da --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets-debug.cmake @@ -0,0 +1,9 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fac46e392394bf07994565d315a1bb412e57f4d4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets-relwithdebinfo.cmake @@ -0,0 +1,117 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::syncqt" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::syncqt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::syncqt PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/syncqt.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::syncqt ) +list(APPEND _cmake_import_check_files_for_Qt6::syncqt "${_IMPORT_PREFIX}/bin/syncqt.exe" ) + +# Import target "Qt6::moc" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::moc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::moc PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/moc.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::moc ) +list(APPEND _cmake_import_check_files_for_Qt6::moc "${_IMPORT_PREFIX}/bin/moc.exe" ) + +# Import target "Qt6::rcc" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::rcc APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::rcc PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/rcc.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::rcc ) +list(APPEND _cmake_import_check_files_for_Qt6::rcc "${_IMPORT_PREFIX}/bin/rcc.exe" ) + +# Import target "Qt6::tracepointgen" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::tracepointgen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::tracepointgen PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/tracepointgen.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::tracepointgen ) +list(APPEND _cmake_import_check_files_for_Qt6::tracepointgen "${_IMPORT_PREFIX}/bin/tracepointgen.exe" ) + +# Import target "Qt6::tracegen" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::tracegen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::tracegen PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/tracegen.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::tracegen ) +list(APPEND _cmake_import_check_files_for_Qt6::tracegen "${_IMPORT_PREFIX}/bin/tracegen.exe" ) + +# Import target "Qt6::cmake_automoc_parser" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::cmake_automoc_parser APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::cmake_automoc_parser PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/cmake_automoc_parser.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::cmake_automoc_parser ) +list(APPEND _cmake_import_check_files_for_Qt6::cmake_automoc_parser "${_IMPORT_PREFIX}/bin/cmake_automoc_parser.exe" ) + +# Import target "Qt6::qlalr" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::qlalr APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::qlalr PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/qlalr.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::qlalr ) +list(APPEND _cmake_import_check_files_for_Qt6::qlalr "${_IMPORT_PREFIX}/bin/qlalr.exe" ) + +# Import target "Qt6::qtpaths" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::qtpaths APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::qtpaths PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/qtpaths.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::qtpaths ) +list(APPEND _cmake_import_check_files_for_Qt6::qtpaths "${_IMPORT_PREFIX}/bin/qtpaths.exe" ) + +# Import target "Qt6::androiddeployqt" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::androiddeployqt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::androiddeployqt PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/androiddeployqt.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::androiddeployqt ) +list(APPEND _cmake_import_check_files_for_Qt6::androiddeployqt "${_IMPORT_PREFIX}/bin/androiddeployqt.exe" ) + +# Import target "Qt6::androidtestrunner" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::androidtestrunner APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::androidtestrunner PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/androidtestrunner.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::androidtestrunner ) +list(APPEND _cmake_import_check_files_for_Qt6::androidtestrunner "${_IMPORT_PREFIX}/bin/androidtestrunner.exe" ) + +# Import target "Qt6::windeployqt" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::windeployqt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::windeployqt PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/windeployqt.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::windeployqt ) +list(APPEND _cmake_import_check_files_for_Qt6::windeployqt "${_IMPORT_PREFIX}/bin/windeployqt.exe" ) + +# Import target "Qt6::qmake" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::qmake APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::qmake PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/qmake.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::qmake ) +list(APPEND _cmake_import_check_files_for_Qt6::qmake "${_IMPORT_PREFIX}/bin/qmake.exe" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..464272f6bc4f2de3ef36274f82a8dc830bfdc46c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets.cmake @@ -0,0 +1,279 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "2.8.3") + message(FATAL_ERROR "CMake >= 2.8.3 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.8.3...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::syncqt Qt6::moc Qt6::rcc Qt6::tracepointgen Qt6::tracegen Qt6::cmake_automoc_parser Qt6::qlalr Qt6::qtpaths Qt6::androiddeployqt Qt6::androidtestrunner Qt6::windeployqt Qt6::qmake) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::syncqt +add_executable(Qt6::syncqt IMPORTED) + +set_target_properties(Qt6::syncqt PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-syncqt" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::moc +add_executable(Qt6::moc IMPORTED) + +set_target_properties(Qt6::moc PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-moc" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::rcc +add_executable(Qt6::rcc IMPORTED) + +set_target_properties(Qt6::rcc PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-rcc" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::tracepointgen +add_executable(Qt6::tracepointgen IMPORTED) + +set_target_properties(Qt6::tracepointgen PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-tracepointgen" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::tracegen +add_executable(Qt6::tracegen IMPORTED) + +set_target_properties(Qt6::tracegen PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-tracegen" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::cmake_automoc_parser +add_executable(Qt6::cmake_automoc_parser IMPORTED) + +set_target_properties(Qt6::cmake_automoc_parser PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-cmake-automoc-parser" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::qlalr +add_executable(Qt6::qlalr IMPORTED) + +set_target_properties(Qt6::qlalr PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-qlalr" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::qtpaths +add_executable(Qt6::qtpaths IMPORTED) + +set_target_properties(Qt6::qtpaths PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-qtpaths" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::androiddeployqt +add_executable(Qt6::androiddeployqt IMPORTED) + +set_target_properties(Qt6::androiddeployqt PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-androiddeployqt" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::androidtestrunner +add_executable(Qt6::androidtestrunner IMPORTED) + +set_target_properties(Qt6::androidtestrunner PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-androidtestrunner" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::windeployqt +add_executable(Qt6::windeployqt IMPORTED) + +set_target_properties(Qt6::windeployqt PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-windeployqt" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::qmake +add_executable(Qt6::qmake IMPORTED) + +set_target_properties(Qt6::qmake PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-qmake" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6CoreToolsTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..660d6d5b8e57bd123936a247e0614569afbb007a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6CoreTools/Qt6CoreToolsVersionlessTargets.cmake @@ -0,0 +1,26 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +foreach(__qt_tool syncqt;moc;rcc;tracepointgen;tracegen;cmake_automoc_parser;qlalr;qtpaths;androiddeployqt;androidtestrunner;windeployqt;qmake) + if(NOT TARGET Qt::${__qt_tool} AND TARGET Qt6::${__qt_tool}) + add_executable(Qt::${__qt_tool} IMPORTED GLOBAL) + + # Check all the usual imported location properties to find one that contains a path. + foreach(__qt_imported_location_config + IMPORTED_LOCATION + IMPORTED_LOCATION_RELEASE + IMPORTED_LOCATION_RELWITHDEBINFO + IMPORTED_LOCATION_MINSIZEREL + IMPORTED_LOCATION_DEBUG) + + get_target_property(__qt_imported_location + Qt6::${__qt_tool} ${__qt_imported_location_config}) + if(__qt_imported_location AND EXISTS "${__qt_imported_location}") + break() + endif() + endforeach() + + set_target_properties(Qt::${__qt_tool} + PROPERTIES IMPORTED_LOCATION "${__qt_imported_location}") + endif() +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee0d36df940ec78d8761de9279ba35dd9a44a1b1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6DBus +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::DBus) +get_target_property(_qt_imported_location Qt6::DBus IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::DBus IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::DBus IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::DBus IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::DBus IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::DBus IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::DBus" for configuration "Release" +set_property(TARGET Qt6::DBus APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::DBus" for configuration "MinSizeRel" +set_property(TARGET Qt6::DBus APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::DBus PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::DBusPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2d88f8f1eaba5df27efaf36a1925ff5d2616dba0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DBusDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusDependencies.cmake") + _qt_internal_suggest_dependency_debugging(DBus + __qt_DBus_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6DBus_FOUND") + set("Qt6DBus_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6DBus_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6DBus) instead. + set(Qt6DBus_LIBRARIES "Qt6::DBus") + + get_target_property(_Qt6DBus_OWN_INCLUDE_DIRS + Qt6::DBus INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6DBus_OWN_INCLUDE_DIRS) + set(_Qt6DBus_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::DBusPrivate) + get_target_property(_Qt6DBus_OWN_PRIVATE_INCLUDE_DIRS + Qt6::DBusPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6DBus_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6DBus_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6DBus_DEFINITIONS + Qt6::DBus INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6DBus_DEFINITIONS) + set(Qt6DBus_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6DBus_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6DBus_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6DBus_COMPILE_DEFINITIONS + Qt6::DBus INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6DBus_COMPILE_DEFINITIONS) + set(Qt6DBus_COMPILE_DEFINITIONS "") + endif() + + set(Qt6DBus_INCLUDE_DIRS + ${_Qt6DBus_OWN_INCLUDE_DIRS}) + + set(Qt6DBus_PRIVATE_INCLUDE_DIRS + ${_Qt6DBus_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6DBus_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6DBus${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6DBus${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6DBus_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6DBus${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6DBus${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6DBus_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6DBus_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6DBus_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6DBus_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::DBus) + qt_make_features_available(Qt6::DBus) + + foreach(extra_cmake_include Qt6DBusMacros.cmake) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DBusPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "DBus") + + get_target_property(_qt_module_target_type "Qt6::DBus" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::DBus MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DBusBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6DBus_FOUND FALSE) + if(NOT DEFINED Qt6DBus_NOT_FOUND_MESSAGE) + set(Qt6DBus_NOT_FOUND_MESSAGE + "Target \"Qt6::DBus\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6DBus_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6DBusTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fdac11d554a95b31b0ca07bbc232cf4a3644083c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b0f1d7e3d2da551e3f956c658f77dd413eb70e27 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6DBus_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_DBus_third_party_deps "") + +_qt_internal_find_third_party_dependencies("DBus" __qt_DBus_third_party_deps) + +# Find Qt tool package. +set(__qt_DBus_tool_deps "Qt6DBusTools\;6.8.1") +_qt_internal_find_tool_dependencies("DBus" __qt_DBus_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_DBus_target_deps "Qt6Core\;6.8.1") +set(__qt_DBus_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("DBus" __qt_DBus_target_deps + __qt_DBus_find_dependency_paths) + +set(_Qt6DBus_MODULE_DEPENDENCIES "Core") +set(Qt6DBus_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusMacros.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusMacros.cmake new file mode 100644 index 0000000000000000000000000000000000000000..be5d8af2cfd5f58dbc3539170d3882a8c54749ba --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusMacros.cmake @@ -0,0 +1,236 @@ +# Copyright 2005-2011 Kitware, Inc. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include(MacroAddFileDependencies) + +function(qt6_add_dbus_interface _sources _interface _relativename) + get_filename_component(_infile ${_interface} ABSOLUTE) + get_filename_component(_basepath ${_relativename} DIRECTORY) + get_filename_component(_basename ${_relativename} NAME) + set(_header "${CMAKE_CURRENT_BINARY_DIR}/${_relativename}.h") + set(_impl "${CMAKE_CURRENT_BINARY_DIR}/${_relativename}.cpp") + if(_basepath) + set(_moc "${CMAKE_CURRENT_BINARY_DIR}/${_basepath}/moc_${_basename}.cpp") + else() + set(_moc "${CMAKE_CURRENT_BINARY_DIR}/moc_${_basename}.cpp") + endif() + + get_source_file_property(_nonamespace ${_interface} NO_NAMESPACE) + if(_nonamespace) + set(_params -N -m) + else() + set(_params -m) + endif() + + get_source_file_property(_classname ${_interface} CLASSNAME) + if(_classname) + set(_params ${_params} -c ${_classname}) + endif() + + get_source_file_property(_include ${_interface} INCLUDE) + if(_include) + set(_params ${_params} -i ${_include}) + endif() + + add_custom_command(OUTPUT "${_impl}" "${_header}" + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::qdbusxml2cpp ${_params} -p ${_relativename} ${_infile} + DEPENDS ${_infile} ${QT_CMAKE_EXPORT_NAMESPACE}::qdbuscpp2xml + VERBATIM + ) + + set_source_files_properties("${_impl}" "${_header}" PROPERTIES + SKIP_AUTOMOC TRUE + SKIP_AUTOUIC TRUE + ) + + qt6_generate_moc("${_header}" "${_moc}") + + list(APPEND ${_sources} "${_impl}" "${_header}") + macro_add_file_dependencies("${_impl}" "${_moc}") + set(${_sources} ${${_sources}} PARENT_SCOPE) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + # All three positional arguments are mandatory and there are no optional + # arguments, so we can preserve them exactly. As an added bonus, if the + # caller doesn't provide enough arguments, they will get an error message + # for their call site instead of here in the wrapper. + function(qt_add_dbus_interface sources interface relativename) + if(ARGC GREATER 3) + message(FATAL_ERROR "Unexpected arguments: ${ARGN}") + endif() + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_add_dbus_interface("${sources}" "${interface}" "${relativename}") + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_dbus_interface("${sources}" "${interface}" "${relativename}") + endif() + set("${sources}" "${${sources}}" PARENT_SCOPE) + endfunction() +endif() + + +function(qt6_add_dbus_interfaces _sources) + foreach(_current_FILE ${ARGN}) + get_filename_component(_infile ${_current_FILE} ABSOLUTE) + get_filename_component(_basename ${_current_FILE} NAME) + # get the part before the ".xml" suffix + string(TOLOWER ${_basename} _basename) + string(REGEX REPLACE "(.*\\.)?([^\\.]+)\\.xml" "\\2" _basename ${_basename}) + qt6_add_dbus_interface(${_sources} ${_infile} ${_basename}interface) + endforeach() + set(${_sources} ${${_sources}} PARENT_SCOPE) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_dbus_interfaces sources) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_add_dbus_interfaces("${sources}" ${ARGN}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_dbus_interfaces("${sources}" ${ARGN}) + endif() + set("${sources}" "${${sources}}" PARENT_SCOPE) + endfunction() +endif() + + +function(qt6_generate_dbus_interface _header) # _customName OPTIONS -some -options ) + set(options) + set(oneValueArgs) + set(multiValueArgs OPTIONS) + + cmake_parse_arguments(_DBUS_INTERFACE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(_customName ${_DBUS_INTERFACE_UNPARSED_ARGUMENTS}) + + get_filename_component(_in_file ${_header} ABSOLUTE) + get_filename_component(_basename ${_header} NAME_WE) + + if(_customName) + if(IS_ABSOLUTE ${_customName}) + get_filename_component(_containingDir ${_customName} PATH) + if(NOT EXISTS ${_containingDir}) + file(MAKE_DIRECTORY "${_containingDir}") + endif() + set(_target ${_customName}) + else() + set(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName}) + endif() + else() + set(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml) + endif() + + add_custom_command(OUTPUT ${_target} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::qdbuscpp2xml ${_DBUS_INTERFACE_OPTIONS} ${_in_file} -o ${_target} + DEPENDS ${_in_file} ${QT_CMAKE_EXPORT_NAMESPACE}::qdbuscpp2xml + VERBATIM + ) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_generate_dbus_interface) + # The versioned function's implementation doesn't preserve empty options, + # so we don't need to here either. Using ARGV is fine under those assumptions. + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_generate_dbus_interface(${ARGV}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_generate_dbus_interface(${ARGV}) + endif() + endfunction() +endif() + + +function(qt6_add_dbus_adaptor _sources _xml_file _include) # _optionalParentClass _optionalRelativename _optionalClassName) + get_filename_component(_infile ${_xml_file} ABSOLUTE) + + set(_optionalParentClass "${ARGV3}") + if(_optionalParentClass) + set(_parentClassOption "-l") + set(_parentClass "${_optionalParentClass}") + endif() + + set(_optionalRelativename "${ARGV4}") + if(_optionalRelativename) + set(_relativename ${_optionalRelativename}) + else() + string(REGEX REPLACE "(.*[/\\.])?([^\\.]+)\\.xml" "\\2adaptor" _relativename ${_infile}) + string(TOLOWER ${_relativename} _relativename) + endif() + get_filename_component(_basepath ${_relativename} DIRECTORY) + get_filename_component(_basename ${_relativename} NAME) + + set(_optionalClassName "${ARGV5}") + set(_header "${CMAKE_CURRENT_BINARY_DIR}/${_relativename}.h") + set(_impl "${CMAKE_CURRENT_BINARY_DIR}/${_relativename}.cpp") + if(_basepath) + set(_moc "${CMAKE_CURRENT_BINARY_DIR}/${_basepath}/moc_${_basename}.cpp") + else() + set(_moc "${CMAKE_CURRENT_BINARY_DIR}/moc_${_basename}.cpp") + endif() + + if(_optionalClassName) + add_custom_command(OUTPUT "${_impl}" "${_header}" + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::qdbusxml2cpp -m -a ${_relativename} -c ${_optionalClassName} -i ${_include} ${_parentClassOption} ${_parentClass} ${_infile} + DEPENDS ${_infile} ${QT_CMAKE_EXPORT_NAMESPACE}::qdbuscpp2xml + VERBATIM + ) + else() + add_custom_command(OUTPUT "${_impl}" "${_header}" + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::qdbusxml2cpp -m -a ${_relativename} -i ${_include} ${_parentClassOption} ${_parentClass} ${_infile} + DEPENDS ${_infile} ${QT_CMAKE_EXPORT_NAMESPACE}::qdbuscpp2xml + VERBATIM + ) + endif() + + qt6_generate_moc("${_header}" "${_moc}") + set_source_files_properties("${_impl}" "${_header}" PROPERTIES + SKIP_AUTOMOC TRUE + SKIP_AUTOUIC TRUE + ) + macro_add_file_dependencies("${_impl}" "${_moc}") + + list(APPEND ${_sources} "${_impl}" "${_header}") + set(${_sources} ${${_sources}} PARENT_SCOPE) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_dbus_adaptor sources dbus_spec header) + # We need to preserve empty values in both positional and optional arguments. + # The following explicit use of ARGVx variables ensures we don't silently + # drop any empty values, which is especially important if there are any + # non-empty values after empty ones. Note that we must not try to read + # ARGVx variables where x >= ARGC, as that is undefined behavior. + # Also note that the parent_class argument is required for qt5, but is + # optional for qt6. + if(ARGC LESS 4) + set(parent_class "") + else() + set(parent_class "${ARGV3}") + endif() + + if(ARGC LESS 5) + set(basename "") + else() + set(basename "${ARGV4}") + endif() + + if(ARGC LESS 6) + set(classname "") + else() + set(classname "${ARGV5}") + endif() + + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_add_dbus_adaptor( + "${sources}" "${dbus_spec}" "${header}" + "${parent_class}" "${basename}" "${classname}" + ) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_dbus_adaptor( + "${sources}" "${dbus_spec}" "${header}" + "${parent_class}" "${basename}" "${classname}" + ) + endif() + set("${sources}" "${${sources}}" PARENT_SCOPE) + endfunction() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..14a01546a12ef6fa4512e9463063ee943e6e6321 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::DBus" for configuration "Debug" +set_property(TARGET Qt6::DBus APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::DBus PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6DBusd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6DBusd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::DBus ) +list(APPEND _cmake_import_check_files_for_Qt6::DBus "${_IMPORT_PREFIX}/lib/Qt6DBusd.lib" "${_IMPORT_PREFIX}/bin/Qt6DBusd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ec82f7d5d9e150e2ef022c42929977c0562d4c1e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::DBus" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::DBus APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::DBus PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6DBus.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6DBus.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::DBus ) +list(APPEND _cmake_import_check_files_for_Qt6::DBus "${_IMPORT_PREFIX}/lib/Qt6DBus.lib" "${_IMPORT_PREFIX}/bin/Qt6DBus.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f5dc928ae6b594a67e6c3ec0fb7b379be14cbd0e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusTargets.cmake @@ -0,0 +1,160 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::DBus Qt6::DBusPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::DBus +add_library(Qt6::DBus SHARED IMPORTED) + +set_target_properties(Qt6::DBus PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_DBUS_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtDBus;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6dbus_metatypes.json>" + _qt_config_module_name "dbus" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtDBus" + _qt_module_interface_name "DBus" + _qt_package_name "Qt6DBus" + _qt_package_version "6.8.1" + _qt_private_module_target_name "DBusPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-DBus" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::DBusPrivate +add_library(Qt6::DBusPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::DBusPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtDBus/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtDBus/6.8.1/QtDBus>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::DBus" + _qt_config_module_name "dbus_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6DBus" + _qt_package_version "6.8.1" + _qt_public_module_target_name "DBus" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-DBus" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6DBusTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Core" "Qt6::CorePrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..943764f58a1aebcf368ecf32eba3a886758034f2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "DBus;DBusPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3027c8a58cd5863555cc42572c05e4d3c8117fd9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBus/Qt6DBusVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "DBus;DBusPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6b9a58b1877d8b57610ff239e4572aae71f17880 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsAdditionalTargetInfo.cmake @@ -0,0 +1,58 @@ +# Additional target information for Qt6DBusTools +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +get_target_property(_qt_imported_location Qt6::qdbuscpp2xml IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::qdbuscpp2xml IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::qdbuscpp2xml" for configuration "Release" +set_property(TARGET Qt6::qdbuscpp2xml APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::qdbuscpp2xml PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::qdbuscpp2xml" for configuration "MinSizeRel" +set_property(TARGET Qt6::qdbuscpp2xml APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::qdbuscpp2xml PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::qdbuscpp2xml PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::qdbusxml2cpp IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::qdbusxml2cpp IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::qdbusxml2cpp" for configuration "Release" +set_property(TARGET Qt6::qdbusxml2cpp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::qdbusxml2cpp PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::qdbusxml2cpp" for configuration "MinSizeRel" +set_property(TARGET Qt6::qdbusxml2cpp APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::qdbusxml2cpp PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::qdbusxml2cpp PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..58bc0d5d736035fb88e193ff741d80b77124efb6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfig.cmake @@ -0,0 +1,65 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleToolsConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DBusToolsDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusToolsDependencies.cmake") +endif() + +# If *Dependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6DBusTools_FOUND") + set("Qt6DBusTools_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6DBusTools_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusToolsTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusToolsAdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusToolsVersionlessTargets.cmake") + endif() +endif() + +foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() + + +if(NOT QT_NO_CREATE_TARGETS AND Qt6DBusTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::qdbuscpp2xml) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6DBusTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::qdbusxml2cpp) +endif() +set(Qt6DBusTools_TARGETS "Qt6::qdbuscpp2xml;Qt6::qdbusxml2cpp") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6fe4227ac9f6debddb09213e623cd54ea1fc1a4f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6DBusToolsConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..93e7b8fe45741c6ef60d1556c39854e2ad1acd30 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersionImpl.cmake @@ -0,0 +1,32 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f575ebfb301177090a5319ea693f4e9c8a30e345 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsDependencies.cmake @@ -0,0 +1,16 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Find "ModuleTools" dependencies, which are other ModuleTools packages. +set(Qt6DBusTools_FOUND FALSE) +set(__qt_DBusTools_tool_deps "Qt6CoreTools\;6.8.1") +foreach(__qt_DBusTools_target_dep ${__qt_DBusTools_tool_deps}) + list(GET __qt_DBusTools_target_dep 0 __qt_DBusTools_pkg) + list(GET __qt_DBusTools_target_dep 1 __qt_DBusTools_version) + + if (NOT ${__qt_DBusTools_pkg}_FOUND) + find_dependency(${__qt_DBusTools_pkg} ${__qt_DBusTools_version}) + endif() +endforeach() + +set(Qt6DBusTools_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0c809c7650339e5c5ec95b84f02dd78c0c7a30da --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets-debug.cmake @@ -0,0 +1,9 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dee7b4859153557f77c90bd8e3049bca1d244a48 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets-relwithdebinfo.cmake @@ -0,0 +1,27 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::qdbuscpp2xml" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::qdbuscpp2xml APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::qdbuscpp2xml PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/qdbuscpp2xml.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::qdbuscpp2xml ) +list(APPEND _cmake_import_check_files_for_Qt6::qdbuscpp2xml "${_IMPORT_PREFIX}/bin/qdbuscpp2xml.exe" ) + +# Import target "Qt6::qdbusxml2cpp" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::qdbusxml2cpp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::qdbusxml2cpp PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/qdbusxml2cpp.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::qdbusxml2cpp ) +list(APPEND _cmake_import_check_files_for_Qt6::qdbusxml2cpp "${_IMPORT_PREFIX}/bin/qdbusxml2cpp.exe" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f2d6821307cb6961c1098075edf9b552a97e1ea2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets.cmake @@ -0,0 +1,129 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "2.8.3") + message(FATAL_ERROR "CMake >= 2.8.3 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.8.3...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::qdbuscpp2xml Qt6::qdbusxml2cpp) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::qdbuscpp2xml +add_executable(Qt6::qdbuscpp2xml IMPORTED) + +set_target_properties(Qt6::qdbuscpp2xml PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-qdbuscpp2xml" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::qdbusxml2cpp +add_executable(Qt6::qdbusxml2cpp IMPORTED) + +set_target_properties(Qt6::qdbusxml2cpp PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-qdbusxml2cpp" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6DBusToolsTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..21bac32b0d8e65de1ffd6f527b6299da9610017a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DBusTools/Qt6DBusToolsVersionlessTargets.cmake @@ -0,0 +1,26 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +foreach(__qt_tool qdbuscpp2xml;qdbusxml2cpp) + if(NOT TARGET Qt::${__qt_tool} AND TARGET Qt6::${__qt_tool}) + add_executable(Qt::${__qt_tool} IMPORTED GLOBAL) + + # Check all the usual imported location properties to find one that contains a path. + foreach(__qt_imported_location_config + IMPORTED_LOCATION + IMPORTED_LOCATION_RELEASE + IMPORTED_LOCATION_RELWITHDEBINFO + IMPORTED_LOCATION_MINSIZEREL + IMPORTED_LOCATION_DEBUG) + + get_target_property(__qt_imported_location + Qt6::${__qt_tool} ${__qt_imported_location_config}) + if(__qt_imported_location AND EXISTS "${__qt_imported_location}") + break() + endif() + endforeach() + + set_target_properties(Qt::${__qt_tool} + PROPERTIES IMPORTED_LOCATION "${__qt_imported_location}") + endif() +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..400da562772917204cde8930cdd9cf625f11feb5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6Designer +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::Designer) +get_target_property(_qt_imported_location Qt6::Designer IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::Designer IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::Designer IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::Designer IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::Designer IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::Designer IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::Designer" for configuration "Release" +set_property(TARGET Qt6::Designer APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::Designer" for configuration "MinSizeRel" +set_property(TARGET Qt6::Designer APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::Designer PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::DesignerPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..501692a968fc97502bb97eb13345bee9653c7b63 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerDependencies.cmake") + _qt_internal_suggest_dependency_debugging(Designer + __qt_Designer_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6Designer_FOUND") + set("Qt6Designer_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6Designer_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6Designer) instead. + set(Qt6Designer_LIBRARIES "Qt6::Designer") + + get_target_property(_Qt6Designer_OWN_INCLUDE_DIRS + Qt6::Designer INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Designer_OWN_INCLUDE_DIRS) + set(_Qt6Designer_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::DesignerPrivate) + get_target_property(_Qt6Designer_OWN_PRIVATE_INCLUDE_DIRS + Qt6::DesignerPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Designer_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6Designer_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6Designer_DEFINITIONS + Qt6::Designer INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Designer_DEFINITIONS) + set(Qt6Designer_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6Designer_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6Designer_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6Designer_COMPILE_DEFINITIONS + Qt6::Designer INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Designer_COMPILE_DEFINITIONS) + set(Qt6Designer_COMPILE_DEFINITIONS "") + endif() + + set(Qt6Designer_INCLUDE_DIRS + ${_Qt6Designer_OWN_INCLUDE_DIRS}) + + set(Qt6Designer_PRIVATE_INCLUDE_DIRS + ${_Qt6Designer_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6Designer_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6Designer${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6Designer${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6Designer_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6Designer${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6Designer${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6Designer_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Designer_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Designer_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6Designer_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::Designer) + qt_make_features_available(Qt6::Designer) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Designer") + + get_target_property(_qt_module_target_type "Qt6::Designer" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::Designer MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6Designer_FOUND FALSE) + if(NOT DEFINED Qt6Designer_NOT_FOUND_MESSAGE) + set(Qt6Designer_NOT_FOUND_MESSAGE + "Target \"Qt6::Designer\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6Designer_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3bca8f9fc6e69a5662da06a7aba7589d82d60d09 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dc04379c1e133b8aa09b3f8b7ad2fd9a8476147d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6Designer_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_Designer_third_party_deps "") + +_qt_internal_find_third_party_dependencies("Designer" __qt_Designer_third_party_deps) + +# Find Qt tool package. +set(__qt_Designer_tool_deps "") +_qt_internal_find_tool_dependencies("Designer" __qt_Designer_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_Designer_target_deps "Qt6Core\;6.8.1;Qt6Gui\;6.8.1;Qt6UiPlugin\;6.8.1;Qt6Widgets\;6.8.1;Qt6Xml\;6.8.1;Qt6OpenGLWidgets\;6.8.1;Qt6OpenGL\;6.8.1") +set(__qt_Designer_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("Designer" __qt_Designer_target_deps + __qt_Designer_find_dependency_paths) + +set(_Qt6Designer_MODULE_DEPENDENCIES "Core;Gui;UiPlugin;Widgets;Xml;OpenGLWidgets;OpenGL") +set(Qt6Designer_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerPlugins.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerPlugins.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6c3e631eca91fff27f4e8f0acf6ad2cbc15da026 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerPlugins.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_PLUGIN_INCLUSION OFF) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION) + __qt_internal_include_plugin_packages(Designer) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a21856c2022d76d17c6b54c2ae8335024a9c7f7c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets-debug.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Designer" for configuration "Debug" +set_property(TARGET Qt6::Designer APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::Designer PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6Designerd.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_DEBUG "Qt6::OpenGL" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6Designerd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Designer ) +list(APPEND _cmake_import_check_files_for_Qt6::Designer "${_IMPORT_PREFIX}/lib/Qt6Designerd.lib" "${_IMPORT_PREFIX}/bin/Qt6Designerd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..87fddac5168cb030d342cd797fbb2788e0cd2b58 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets-relwithdebinfo.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Designer" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::Designer APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::Designer PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6Designer.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO "Qt6::OpenGL" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6Designer.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Designer ) +list(APPEND _cmake_import_check_files_for_Qt6::Designer "${_IMPORT_PREFIX}/lib/Qt6Designer.lib" "${_IMPORT_PREFIX}/bin/Qt6Designer.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f484f277c25f40754b7fe027f825504fc24e18bf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerTargets.cmake @@ -0,0 +1,161 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Designer Qt6::DesignerPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Designer +add_library(Qt6::Designer SHARED IMPORTED) + +set_target_properties(Qt6::Designer PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_DESIGNER_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtDesigner;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::Gui;Qt6::UiPlugin;Qt6::Widgets;Qt6::Xml;Qt6::OpenGLWidgets" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6designer_metatypes.json>" + MODULE_PLUGIN_TYPES "designer" + _qt_config_module_name "designer" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtDesigner" + _qt_module_interface_name "Designer" + _qt_package_name "Qt6Designer" + _qt_package_version "6.8.1" + _qt_private_module_target_name "DesignerPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-module-Designer" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Create imported target Qt6::DesignerPrivate +add_library(Qt6::DesignerPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::DesignerPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtDesigner/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtDesigner/6.8.1/QtDesigner>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::GuiPrivate;Qt6::WidgetsPrivate;Qt6::Designer" + _qt_config_module_name "designer_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6Designer" + _qt_package_version "6.8.1" + _qt_public_module_target_name "Designer" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-module-Designer" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::UiPlugin" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8e2297117f115bdf57af9ac19b82290f62f1092c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Designer;DesignerPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..911e0ae692a7cd9df56c29ee33b7db5be3e24d8f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6DesignerVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Designer;DesignerPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4cf0dac33e2738bc96b7bf32c6c0c0e560db16d5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QAxWidgetPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QAxWidgetPlugin) +get_target_property(_qt_imported_location Qt6::QAxWidgetPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QAxWidgetPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QAxWidgetPlugin" for configuration "Release" +set_property(TARGET Qt6::QAxWidgetPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QAxWidgetPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QAxWidgetPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QAxWidgetPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QAxWidgetPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QAxWidgetPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..04aa4367b0bfca70da2a5778ea37c8e6a7a089d0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtTools" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QAxWidgetPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QAxWidgetPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QAxWidgetPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QAxWidgetPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2b049852047b79d9b7c42fb5fa1126e9d4db901a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QAxWidgetPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..52552f27b7b0db835a17c4d08b9762bd792335ae --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QAxWidgetPlugin" for configuration "Debug" +set_property(TARGET Qt6::QAxWidgetPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QAxWidgetPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/designer/qaxwidgetd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QAxWidgetPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QAxWidgetPlugin "${_IMPORT_PREFIX}/plugins/designer/qaxwidgetd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..31effad97fefee0f77c29df7b71d9e8f7d29bf36 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QAxWidgetPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QAxWidgetPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QAxWidgetPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/designer/qaxwidget.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QAxWidgetPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QAxWidgetPlugin "${_IMPORT_PREFIX}/plugins/designer/qaxwidget.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..49b55e0a39985d02d8394c2f4bf7223d9966d54e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QAxWidgetPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QAxWidgetPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QAxWidgetPlugin +add_library(Qt6::QAxWidgetPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QAxWidgetPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Designer" + QT_PLUGIN_CLASS_NAME "QAxWidgetPlugin" + QT_PLUGIN_TYPE "designer" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-plugin-QAxWidgetPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QAxWidgetPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..af36a08ed499b0854693ffb356b6c18c24b05fb0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQuickWidgetPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQuickWidgetPlugin) +get_target_property(_qt_imported_location Qt6::QQuickWidgetPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQuickWidgetPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQuickWidgetPlugin" for configuration "Release" +set_property(TARGET Qt6::QQuickWidgetPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQuickWidgetPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQuickWidgetPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQuickWidgetPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQuickWidgetPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQuickWidgetPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..85f3f107d4a209e270b99bee107530528aee2490 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtTools" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickWidgetPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickWidgetPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickWidgetPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickWidgetPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ffad6d37ea8f80bb575b8e05681034b381f3834e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickWidgetPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..68b6f4f418d9b976699fb8179fa709ea4be554cb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQuickWidgetPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQuickWidgetPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQuickWidgetPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/designer/qquickwidgetd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQuickWidgetPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQuickWidgetPlugin "${_IMPORT_PREFIX}/plugins/designer/qquickwidgetd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9320a2169e447ceee00ba650e80498540f10c62d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQuickWidgetPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQuickWidgetPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQuickWidgetPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/designer/qquickwidget.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQuickWidgetPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQuickWidgetPlugin "${_IMPORT_PREFIX}/plugins/designer/qquickwidget.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..caf7a480bbb6330a0a599b25c6fe7ba02d7e1895 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Designer/Qt6QQuickWidgetPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQuickWidgetPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQuickWidgetPlugin +add_library(Qt6::QQuickWidgetPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQuickWidgetPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Designer" + QT_PLUGIN_CLASS_NAME "QQuickWidgetPlugin" + QT_PLUGIN_TYPE "designer" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-plugin-QQuickWidgetPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickWidgetPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..deeb5cc054c4c4205b80ee098546bcee3ac28b84 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,60 @@ +# Additional target information for Qt6DesignerComponentsPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::DesignerComponentsPrivate) +get_target_property(_qt_imported_location Qt6::DesignerComponentsPrivate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::DesignerComponentsPrivate IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::DesignerComponentsPrivate IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::DesignerComponentsPrivate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::DesignerComponentsPrivate IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::DesignerComponentsPrivate IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::DesignerComponentsPrivate" for configuration "Release" +set_property(TARGET Qt6::DesignerComponentsPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::DesignerComponentsPrivate" for configuration "MinSizeRel" +set_property(TARGET Qt6::DesignerComponentsPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::DesignerComponentsPrivate PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..307b1964522a7a410d0baae2e0a652e5de23ede5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(DesignerComponentsPrivate + __qt_DesignerComponentsPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6DesignerComponentsPrivate_FOUND") + set("Qt6DesignerComponentsPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6DesignerComponentsPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6DesignerComponentsPrivate) instead. + set(Qt6DesignerComponentsPrivate_LIBRARIES "Qt6::DesignerComponentsPrivate") + + get_target_property(_Qt6DesignerComponentsPrivate_OWN_INCLUDE_DIRS + Qt6::DesignerComponentsPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6DesignerComponentsPrivate_OWN_INCLUDE_DIRS) + set(_Qt6DesignerComponentsPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::DesignerComponentsPrivatePrivate) + get_target_property(_Qt6DesignerComponentsPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::DesignerComponentsPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6DesignerComponentsPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6DesignerComponentsPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6DesignerComponentsPrivate_DEFINITIONS + Qt6::DesignerComponentsPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6DesignerComponentsPrivate_DEFINITIONS) + set(Qt6DesignerComponentsPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6DesignerComponentsPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6DesignerComponentsPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6DesignerComponentsPrivate_COMPILE_DEFINITIONS + Qt6::DesignerComponentsPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6DesignerComponentsPrivate_COMPILE_DEFINITIONS) + set(Qt6DesignerComponentsPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6DesignerComponentsPrivate_INCLUDE_DIRS + ${_Qt6DesignerComponentsPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6DesignerComponentsPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6DesignerComponentsPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6DesignerComponentsPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6DesignerComponentsPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6DesignerComponentsPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6DesignerComponentsPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6DesignerComponentsPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6DesignerComponentsPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6DesignerComponentsPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6DesignerComponentsPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6DesignerComponentsPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6DesignerComponentsPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::DesignerComponentsPrivate) + qt_make_features_available(Qt6::DesignerComponentsPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "DesignerComponentsPrivate") + + get_target_property(_qt_module_target_type "Qt6::DesignerComponentsPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::DesignerComponentsPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6DesignerComponentsPrivate_FOUND FALSE) + if(NOT DEFINED Qt6DesignerComponentsPrivate_NOT_FOUND_MESSAGE) + set(Qt6DesignerComponentsPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::DesignerComponentsPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6DesignerComponentsPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4bf017abdb539a071475a8e48b36e3d92c531156 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d9376b4d3951257a3db7b39473c956c8c27f574c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6DesignerComponentsPrivate_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_DesignerComponentsPrivate_third_party_deps "") + +_qt_internal_find_third_party_dependencies("DesignerComponentsPrivate" __qt_DesignerComponentsPrivate_third_party_deps) + +# Find Qt tool package. +set(__qt_DesignerComponentsPrivate_tool_deps "") +_qt_internal_find_tool_dependencies("DesignerComponentsPrivate" __qt_DesignerComponentsPrivate_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_DesignerComponentsPrivate_target_deps "Qt6Core\;6.8.1;Qt6Designer\;6.8.1;Qt6Gui\;6.8.1;Qt6Widgets\;6.8.1;Qt6Xml\;6.8.1") +set(__qt_DesignerComponentsPrivate_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("DesignerComponentsPrivate" __qt_DesignerComponentsPrivate_target_deps + __qt_DesignerComponentsPrivate_find_dependency_paths) + +set(_Qt6DesignerComponentsPrivate_MODULE_DEPENDENCIES "Core;Designer;Gui;Widgets;Xml") +set(Qt6DesignerComponentsPrivate_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..eff1e86ae743b69e909d2cc53a12500b3ffc049f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::DesignerComponentsPrivate" for configuration "Debug" +set_property(TARGET Qt6::DesignerComponentsPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::DesignerComponentsPrivate PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6DesignerComponentsd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6DesignerComponentsd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::DesignerComponentsPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::DesignerComponentsPrivate "${_IMPORT_PREFIX}/lib/Qt6DesignerComponentsd.lib" "${_IMPORT_PREFIX}/bin/Qt6DesignerComponentsd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3ed195f32c1e2d8265cb5c603467bc1d895fadaf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::DesignerComponentsPrivate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::DesignerComponentsPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::DesignerComponentsPrivate PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6DesignerComponents.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6DesignerComponents.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::DesignerComponentsPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::DesignerComponentsPrivate "${_IMPORT_PREFIX}/lib/Qt6DesignerComponents.lib" "${_IMPORT_PREFIX}/bin/Qt6DesignerComponents.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..96a14b2f33014587b8f0ccc5697a8556f5d19e65 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateTargets.cmake @@ -0,0 +1,142 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::DesignerComponentsPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::DesignerComponentsPrivate +add_library(Qt6::DesignerComponentsPrivate SHARED IMPORTED) + +set_target_properties(Qt6::DesignerComponentsPrivate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_DESIGNERCOMPONENTS_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtDesignerComponents;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtDesignerComponents/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtDesignerComponents/6.8.1/QtDesignerComponents>" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::DesignerPrivate;Qt6::GuiPrivate;Qt6::WidgetsPrivate;Qt6::Xml" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6designercomponentsprivate_metatypes.json>" + _qt_config_module_name "designercomponents_private" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtDesignerComponents" + _qt_module_interface_name "DesignerComponents" + _qt_package_name "Qt6DesignerComponentsPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-module-DesignerComponentsPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6DesignerComponentsPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::DesignerPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..331b44ae7d0969684c1e73689c31dcb747a61d64 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "DesignerComponentsPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3572a05003c07653958b30277acd7d90eb4d4a7a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DesignerComponentsPrivate/Qt6DesignerComponentsPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "DesignerComponentsPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f435a61a0f4ebd267d4d4daab9e70adb1d1a936e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6DeviceDiscoverySupportPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::DeviceDiscoverySupportPrivate) +get_target_property(_qt_imported_location Qt6::DeviceDiscoverySupportPrivate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::DeviceDiscoverySupportPrivate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::DeviceDiscoverySupportPrivate" for configuration "Release" +set_property(TARGET Qt6::DeviceDiscoverySupportPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::DeviceDiscoverySupportPrivate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::DeviceDiscoverySupportPrivate" for configuration "MinSizeRel" +set_property(TARGET Qt6::DeviceDiscoverySupportPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::DeviceDiscoverySupportPrivate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::DeviceDiscoverySupportPrivate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6b2c808734dbe683e8d751799c9dd53b34ed4918 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(DeviceDiscoverySupportPrivate + __qt_DeviceDiscoverySupportPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6DeviceDiscoverySupportPrivate_FOUND") + set("Qt6DeviceDiscoverySupportPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6DeviceDiscoverySupportPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6DeviceDiscoverySupportPrivate) instead. + set(Qt6DeviceDiscoverySupportPrivate_LIBRARIES "Qt6::DeviceDiscoverySupportPrivate") + + get_target_property(_Qt6DeviceDiscoverySupportPrivate_OWN_INCLUDE_DIRS + Qt6::DeviceDiscoverySupportPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6DeviceDiscoverySupportPrivate_OWN_INCLUDE_DIRS) + set(_Qt6DeviceDiscoverySupportPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::DeviceDiscoverySupportPrivatePrivate) + get_target_property(_Qt6DeviceDiscoverySupportPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::DeviceDiscoverySupportPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6DeviceDiscoverySupportPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6DeviceDiscoverySupportPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6DeviceDiscoverySupportPrivate_DEFINITIONS + Qt6::DeviceDiscoverySupportPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6DeviceDiscoverySupportPrivate_DEFINITIONS) + set(Qt6DeviceDiscoverySupportPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6DeviceDiscoverySupportPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6DeviceDiscoverySupportPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6DeviceDiscoverySupportPrivate_COMPILE_DEFINITIONS + Qt6::DeviceDiscoverySupportPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6DeviceDiscoverySupportPrivate_COMPILE_DEFINITIONS) + set(Qt6DeviceDiscoverySupportPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6DeviceDiscoverySupportPrivate_INCLUDE_DIRS + ${_Qt6DeviceDiscoverySupportPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6DeviceDiscoverySupportPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6DeviceDiscoverySupportPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6DeviceDiscoverySupportPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6DeviceDiscoverySupportPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6DeviceDiscoverySupportPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6DeviceDiscoverySupportPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6DeviceDiscoverySupportPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6DeviceDiscoverySupportPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6DeviceDiscoverySupportPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6DeviceDiscoverySupportPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6DeviceDiscoverySupportPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6DeviceDiscoverySupportPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::DeviceDiscoverySupportPrivate) + qt_make_features_available(Qt6::DeviceDiscoverySupportPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "DeviceDiscoverySupportPrivate") + + get_target_property(_qt_module_target_type "Qt6::DeviceDiscoverySupportPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::DeviceDiscoverySupportPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6DeviceDiscoverySupportPrivate_FOUND FALSE) + if(NOT DEFINED Qt6DeviceDiscoverySupportPrivate_NOT_FOUND_MESSAGE) + set(Qt6DeviceDiscoverySupportPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::DeviceDiscoverySupportPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6DeviceDiscoverySupportPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..56af7363c6b367b91c84564324d2c6cc602c3e35 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..702d94b923afeb5ad2dbb4d8559482d362bf7636 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6DeviceDiscoverySupportPrivate_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_DeviceDiscoverySupportPrivate_third_party_deps "") + +_qt_internal_find_third_party_dependencies("DeviceDiscoverySupportPrivate" __qt_DeviceDiscoverySupportPrivate_third_party_deps) + +# Find Qt tool package. +set(__qt_DeviceDiscoverySupportPrivate_tool_deps "") +_qt_internal_find_tool_dependencies("DeviceDiscoverySupportPrivate" __qt_DeviceDiscoverySupportPrivate_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_DeviceDiscoverySupportPrivate_target_deps "Qt6Core\;6.8.1") +set(__qt_DeviceDiscoverySupportPrivate_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("DeviceDiscoverySupportPrivate" __qt_DeviceDiscoverySupportPrivate_target_deps + __qt_DeviceDiscoverySupportPrivate_find_dependency_paths) + +set(_Qt6DeviceDiscoverySupportPrivate_MODULE_DEPENDENCIES "Core") +set(Qt6DeviceDiscoverySupportPrivate_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..55dad50eeeb1e3cb0f89705c6f430ffc7c6c7e9d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::DeviceDiscoverySupportPrivate" for configuration "Debug" +set_property(TARGET Qt6::DeviceDiscoverySupportPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::DeviceDiscoverySupportPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6DeviceDiscoverySupportd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::DeviceDiscoverySupportPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::DeviceDiscoverySupportPrivate "${_IMPORT_PREFIX}/lib/Qt6DeviceDiscoverySupportd.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b04fdbf411afc41f84937418f013ae4850cb5e38 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::DeviceDiscoverySupportPrivate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::DeviceDiscoverySupportPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::DeviceDiscoverySupportPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6DeviceDiscoverySupport.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::DeviceDiscoverySupportPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::DeviceDiscoverySupportPrivate "${_IMPORT_PREFIX}/lib/Qt6DeviceDiscoverySupport.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..89a33f31851ff9a9d5e18de55a707aa5e9c8bac2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateTargets.cmake @@ -0,0 +1,141 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::DeviceDiscoverySupportPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::DeviceDiscoverySupportPrivate +add_library(Qt6::DeviceDiscoverySupportPrivate STATIC IMPORTED) + +set_target_properties(Qt6::DeviceDiscoverySupportPrivate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_DEVICEDISCOVERY_SUPPORT_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtDeviceDiscoverySupport;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtDeviceDiscoverySupport/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtDeviceDiscoverySupport/6.8.1/QtDeviceDiscoverySupport>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;\$" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6devicediscoverysupportprivate_metatypes.json>" + _qt_config_module_name "devicediscovery_support_private" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_include_name "QtDeviceDiscoverySupport" + _qt_module_interface_name "DeviceDiscoverySupport" + _qt_package_name "Qt6DeviceDiscoverySupportPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-DeviceDiscoverySupportPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6DeviceDiscoverySupportPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::CorePrivate" "Qt6::PlatformModuleInternal" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6a36cb233541c68425c650fee7177b39c3e08d24 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "DeviceDiscoverySupportPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a3863dfe9c4701a184a5ea4948a320ed52bef344 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6DeviceDiscoverySupportPrivate/Qt6DeviceDiscoverySupportPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "DeviceDiscoverySupportPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bc0c8431b35ca9c8712c115f9342d6e84be8a4f6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,39 @@ +# Additional target information for Qt6EntryPointPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::EntryPointPrivate) +__qt_internal_promote_target_to_global_checked(Qt6::EntryPointImplementation) +get_target_property(_qt_imported_location Qt6::EntryPointImplementation IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::EntryPointImplementation IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::EntryPointImplementation" for configuration "Release" +set_property(TARGET Qt6::EntryPointImplementation APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::EntryPointImplementation PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::EntryPointImplementation" for configuration "MinSizeRel" +set_property(TARGET Qt6::EntryPointImplementation APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::EntryPointImplementation PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::EntryPointImplementation PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fa7d2cd6f8452cf8dc055d3e73c2e8f7c9c59077 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(EntryPointPrivate + __qt_EntryPointPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6EntryPointPrivate_FOUND") + set("Qt6EntryPointPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6EntryPointPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6EntryPointPrivate) instead. + set(Qt6EntryPointPrivate_LIBRARIES "Qt6::EntryPointPrivate") + + get_target_property(_Qt6EntryPointPrivate_OWN_INCLUDE_DIRS + Qt6::EntryPointPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6EntryPointPrivate_OWN_INCLUDE_DIRS) + set(_Qt6EntryPointPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::EntryPointPrivatePrivate) + get_target_property(_Qt6EntryPointPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::EntryPointPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6EntryPointPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6EntryPointPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6EntryPointPrivate_DEFINITIONS + Qt6::EntryPointPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6EntryPointPrivate_DEFINITIONS) + set(Qt6EntryPointPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6EntryPointPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6EntryPointPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6EntryPointPrivate_COMPILE_DEFINITIONS + Qt6::EntryPointPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6EntryPointPrivate_COMPILE_DEFINITIONS) + set(Qt6EntryPointPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6EntryPointPrivate_INCLUDE_DIRS + ${_Qt6EntryPointPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6EntryPointPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6EntryPointPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6EntryPointPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6EntryPointPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6EntryPointPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6EntryPointPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6EntryPointPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6EntryPointPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6EntryPointPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6EntryPointPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6EntryPointPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6EntryPointPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::EntryPointPrivate) + qt_make_features_available(Qt6::EntryPointPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "EntryPointPrivate") + + get_target_property(_qt_module_target_type "Qt6::EntryPointPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::EntryPointPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6EntryPointPrivate_FOUND FALSE) + if(NOT DEFINED Qt6EntryPointPrivate_NOT_FOUND_MESSAGE) + set(Qt6EntryPointPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::EntryPointPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6EntryPointPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ce7243ac7a3809d0e3b07dd15e61986311218542 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8afaea680602ca4bc4c8ecfd48e439df5598b4a3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::EntryPointImplementation" for configuration "Debug" +set_property(TARGET Qt6::EntryPointImplementation APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::EntryPointImplementation PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6EntryPointd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::EntryPointImplementation ) +list(APPEND _cmake_import_check_files_for_Qt6::EntryPointImplementation "${_IMPORT_PREFIX}/lib/Qt6EntryPointd.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8e13e83b03777f294bb248634b98158f799a9a7a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::EntryPointImplementation" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::EntryPointImplementation APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::EntryPointImplementation PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6EntryPoint.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::EntryPointImplementation ) +list(APPEND _cmake_import_check_files_for_Qt6::EntryPointImplementation "${_IMPORT_PREFIX}/lib/Qt6EntryPoint.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3fa3382c3ecad40508e5dabf367f3ebab10e21cb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateTargets.cmake @@ -0,0 +1,146 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::EntryPointPrivate Qt6::EntryPointImplementation) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::EntryPointPrivate +add_library(Qt6::EntryPointPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::EntryPointPrivate PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "" + INTERFACE_INCLUDE_DIRECTORIES "" + INTERFACE_LINK_LIBRARIES "Qt6::EntryPointImplementation" + _qt_config_module_name "entrypoint_private" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "OFF" + _qt_module_interface_name "EntryPoint" + _qt_package_name "Qt6EntryPointPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-EntryPointPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::EntryPointImplementation +add_library(Qt6::EntryPointImplementation STATIC IMPORTED) + +set_target_properties(Qt6::EntryPointImplementation PROPERTIES + INTERFACE_LINK_LIBRARIES "\$;\$" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6EntryPointPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::PlatformCommonInternal" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8895d9c4e0826f2841ce64b9bf0ceee19515cfc5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "EntryPointPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..05715ba791ec31da57407efbf2bb8b4736b9863b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6EntryPointPrivate/Qt6EntryPointPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "EntryPointPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0cb6d3c92448146fd1e525efda5bda9536d2984e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,71 @@ +# Additional target information for Qt6ExampleIconsPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::ExampleIconsPrivate) +get_target_property(_qt_imported_location Qt6::ExampleIconsPrivate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::ExampleIconsPrivate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::ExampleIconsPrivate" for configuration "Release" +set_property(TARGET Qt6::ExampleIconsPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::ExampleIconsPrivate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::ExampleIconsPrivate" for configuration "MinSizeRel" +set_property(TARGET Qt6::ExampleIconsPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::ExampleIconsPrivate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::ExampleIconsPrivate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::ExampleIconsPrivate_resources_1) +get_target_property(_qt_imported_objects Qt6::ExampleIconsPrivate_resources_1 IMPORTED_OBJECTS_RELWITHDEBINFO) +get_target_property(_qt_imported_clr Qt6::ExampleIconsPrivate_resources_1 IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO) +get_target_property(_qt_imported_objects_default Qt6::ExampleIconsPrivate_resources_1 IMPORTED_OBJECTS_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_clr_default Qt6::ExampleIconsPrivate_resources_1 IMPORTED_COMMON_LANGUAGE_RUNTIME_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::ExampleIconsPrivate_resources_1" for configuration "Release" +set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_objects) + set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 PROPERTY IMPORTED_OBJECTS_RELEASE "${_qt_imported_objects}") +endif() +if(_qt_imported_clr) + set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 PROPERTY IMPORTED_COMMON_LANGUAGE_RUNTIME_RELEASE "${_qt_imported_clr}") +endif() + +# Import target "Qt6::ExampleIconsPrivate_resources_1" for configuration "MinSizeRel" +set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_objects) + set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 PROPERTY IMPORTED_OBJECTS_MINSIZEREL "${_qt_imported_objects}") +endif() +if(_qt_imported_clr) + set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 PROPERTY IMPORTED_COMMON_LANGUAGE_RUNTIME_MINSIZEREL "${_qt_imported_clr}") +endif() + +# Default configuration +if(_qt_imported_objects_default) + set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 PROPERTY IMPORTED_OBJECTS "${_qt_imported_objects_default}") +endif() +if(_qt_imported_clr_default) + set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 PROPERTY IMPORTED_COMMON_LANGUAGE_RUNTIME "${_qt_imported_clr_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..50d00ccc0f17e15cf6e749605f016d0e92ffd573 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(ExampleIconsPrivate + __qt_ExampleIconsPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6ExampleIconsPrivate_FOUND") + set("Qt6ExampleIconsPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6ExampleIconsPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6ExampleIconsPrivate) instead. + set(Qt6ExampleIconsPrivate_LIBRARIES "Qt6::ExampleIconsPrivate") + + get_target_property(_Qt6ExampleIconsPrivate_OWN_INCLUDE_DIRS + Qt6::ExampleIconsPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6ExampleIconsPrivate_OWN_INCLUDE_DIRS) + set(_Qt6ExampleIconsPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::ExampleIconsPrivatePrivate) + get_target_property(_Qt6ExampleIconsPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::ExampleIconsPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6ExampleIconsPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6ExampleIconsPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6ExampleIconsPrivate_DEFINITIONS + Qt6::ExampleIconsPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6ExampleIconsPrivate_DEFINITIONS) + set(Qt6ExampleIconsPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6ExampleIconsPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6ExampleIconsPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6ExampleIconsPrivate_COMPILE_DEFINITIONS + Qt6::ExampleIconsPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6ExampleIconsPrivate_COMPILE_DEFINITIONS) + set(Qt6ExampleIconsPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6ExampleIconsPrivate_INCLUDE_DIRS + ${_Qt6ExampleIconsPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6ExampleIconsPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6ExampleIconsPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6ExampleIconsPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6ExampleIconsPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6ExampleIconsPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6ExampleIconsPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6ExampleIconsPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6ExampleIconsPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6ExampleIconsPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6ExampleIconsPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6ExampleIconsPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6ExampleIconsPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::ExampleIconsPrivate) + qt_make_features_available(Qt6::ExampleIconsPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "ExampleIconsPrivate") + + get_target_property(_qt_module_target_type "Qt6::ExampleIconsPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::ExampleIconsPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6ExampleIconsPrivate_FOUND FALSE) + if(NOT DEFINED Qt6ExampleIconsPrivate_NOT_FOUND_MESSAGE) + set(Qt6ExampleIconsPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::ExampleIconsPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6ExampleIconsPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4ff21162658cf95ff2e725133a54aef3fe8337c1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6be8ec21b95fefefb1eb8dfb6d87c210d0d19c4d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets-debug.cmake @@ -0,0 +1,29 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::ExampleIconsPrivate" for configuration "Debug" +set_property(TARGET Qt6::ExampleIconsPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::ExampleIconsPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6ExampleIconsd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::ExampleIconsPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::ExampleIconsPrivate "${_IMPORT_PREFIX}/lib/Qt6ExampleIconsd.lib" ) + +# Import target "Qt6::ExampleIconsPrivate_resources_1" for configuration "Debug" +set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::ExampleIconsPrivate_resources_1 PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_OBJECTS_DEBUG "${_IMPORT_PREFIX}/lib/objects-Debug/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj" + ) + +list(APPEND _cmake_import_check_targets Qt6::ExampleIconsPrivate_resources_1 ) +list(APPEND _cmake_import_check_files_for_Qt6::ExampleIconsPrivate_resources_1 "${_IMPORT_PREFIX}/lib/objects-Debug/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2b549269e268fa9147daced3abf6c74a71d2433c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,29 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::ExampleIconsPrivate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::ExampleIconsPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::ExampleIconsPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6ExampleIcons.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::ExampleIconsPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::ExampleIconsPrivate "${_IMPORT_PREFIX}/lib/Qt6ExampleIcons.lib" ) + +# Import target "Qt6::ExampleIconsPrivate_resources_1" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::ExampleIconsPrivate_resources_1 APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::ExampleIconsPrivate_resources_1 PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_OBJECTS_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/objects-RelWithDebInfo/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj" + ) + +list(APPEND _cmake_import_check_targets Qt6::ExampleIconsPrivate_resources_1 ) +list(APPEND _cmake_import_check_files_for_Qt6::ExampleIconsPrivate_resources_1 "${_IMPORT_PREFIX}/lib/objects-RelWithDebInfo/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f17c7f8a7deeb64bd40a70cda3bf2b7c5ab92941 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateTargets.cmake @@ -0,0 +1,149 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::ExampleIconsPrivate Qt6::ExampleIconsPrivate_resources_1) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::ExampleIconsPrivate +add_library(Qt6::ExampleIconsPrivate STATIC IMPORTED) + +set_target_properties(Qt6::ExampleIconsPrivate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_EXAMPLE_ICONS_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtExampleIcons;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtExampleIcons/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtExampleIcons/6.8.1/QtExampleIcons>" + INTERFACE_LINK_LIBRARIES "\$;\$<\$,STATIC_LIBRARY>>,\$>>,\$>>,\$>:\$>;Qt6::ExampleIconsPrivate_resources_1" + INTERFACE_LINK_OPTIONS "\$<\$,STATIC_LIBRARY>>,\$>,\$>>,\$>:\$>" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6exampleiconsprivate_metatypes.json>;\$<\$,STATIC_LIBRARY>>,\$>,\$>>>,\$>>,\$>:\$>" + _qt_config_module_name "example_icons_private" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_include_name "QtExampleIcons" + _qt_module_interface_name "ExampleIcons" + _qt_package_name "Qt6ExampleIconsPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-ExampleIconsPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::ExampleIconsPrivate_resources_1 +add_library(Qt6::ExampleIconsPrivate_resources_1 OBJECT IMPORTED) + +set_target_properties(Qt6::ExampleIconsPrivate_resources_1 PROPERTIES + INTERFACE_LINK_LIBRARIES "Qt6::Core;\$;\$" + _is_qt_propagated_object_library "TRUE" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6ExampleIconsPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Platform" "Qt6::PlatformModuleInternal" "Qt6::Core" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c0edd9d0067a546740230bc6330d4945c0c69073 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "ExampleIconsPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..309c97884893d37cb3b12fce9c3688c9ebf256bd --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExampleIconsPrivate/Qt6ExampleIconsPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "ExampleIconsPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b2918a613e3706551ba0dabe5f0d17f77f30ccca --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6ExamplesAssetDownloaderPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::ExamplesAssetDownloaderPrivate) +get_target_property(_qt_imported_location Qt6::ExamplesAssetDownloaderPrivate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::ExamplesAssetDownloaderPrivate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::ExamplesAssetDownloaderPrivate" for configuration "Release" +set_property(TARGET Qt6::ExamplesAssetDownloaderPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::ExamplesAssetDownloaderPrivate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::ExamplesAssetDownloaderPrivate" for configuration "MinSizeRel" +set_property(TARGET Qt6::ExamplesAssetDownloaderPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::ExamplesAssetDownloaderPrivate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::ExamplesAssetDownloaderPrivate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c6e775bd43789e7e9c0d90e5babddf26fecc0662 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(ExamplesAssetDownloaderPrivate + __qt_ExamplesAssetDownloaderPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6ExamplesAssetDownloaderPrivate_FOUND") + set("Qt6ExamplesAssetDownloaderPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6ExamplesAssetDownloaderPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6ExamplesAssetDownloaderPrivate) instead. + set(Qt6ExamplesAssetDownloaderPrivate_LIBRARIES "Qt6::ExamplesAssetDownloaderPrivate") + + get_target_property(_Qt6ExamplesAssetDownloaderPrivate_OWN_INCLUDE_DIRS + Qt6::ExamplesAssetDownloaderPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6ExamplesAssetDownloaderPrivate_OWN_INCLUDE_DIRS) + set(_Qt6ExamplesAssetDownloaderPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::ExamplesAssetDownloaderPrivatePrivate) + get_target_property(_Qt6ExamplesAssetDownloaderPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::ExamplesAssetDownloaderPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6ExamplesAssetDownloaderPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6ExamplesAssetDownloaderPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6ExamplesAssetDownloaderPrivate_DEFINITIONS + Qt6::ExamplesAssetDownloaderPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6ExamplesAssetDownloaderPrivate_DEFINITIONS) + set(Qt6ExamplesAssetDownloaderPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6ExamplesAssetDownloaderPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6ExamplesAssetDownloaderPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6ExamplesAssetDownloaderPrivate_COMPILE_DEFINITIONS + Qt6::ExamplesAssetDownloaderPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6ExamplesAssetDownloaderPrivate_COMPILE_DEFINITIONS) + set(Qt6ExamplesAssetDownloaderPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6ExamplesAssetDownloaderPrivate_INCLUDE_DIRS + ${_Qt6ExamplesAssetDownloaderPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6ExamplesAssetDownloaderPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6ExamplesAssetDownloaderPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6ExamplesAssetDownloaderPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6ExamplesAssetDownloaderPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6ExamplesAssetDownloaderPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6ExamplesAssetDownloaderPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6ExamplesAssetDownloaderPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6ExamplesAssetDownloaderPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6ExamplesAssetDownloaderPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6ExamplesAssetDownloaderPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6ExamplesAssetDownloaderPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6ExamplesAssetDownloaderPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::ExamplesAssetDownloaderPrivate) + qt_make_features_available(Qt6::ExamplesAssetDownloaderPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "ExamplesAssetDownloaderPrivate") + + get_target_property(_qt_module_target_type "Qt6::ExamplesAssetDownloaderPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::ExamplesAssetDownloaderPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6ExamplesAssetDownloaderPrivate_FOUND FALSE) + if(NOT DEFINED Qt6ExamplesAssetDownloaderPrivate_NOT_FOUND_MESSAGE) + set(Qt6ExamplesAssetDownloaderPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::ExamplesAssetDownloaderPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6ExamplesAssetDownloaderPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e13e7c6c4c193256a97e973cc5f292970a0b857e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..785ca796ca81cfa9ba0cfaf7b736d039613fbc53 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6ExamplesAssetDownloaderPrivate_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_ExamplesAssetDownloaderPrivate_third_party_deps "") + +_qt_internal_find_third_party_dependencies("ExamplesAssetDownloaderPrivate" __qt_ExamplesAssetDownloaderPrivate_third_party_deps) + +# Find Qt tool package. +set(__qt_ExamplesAssetDownloaderPrivate_tool_deps "") +_qt_internal_find_tool_dependencies("ExamplesAssetDownloaderPrivate" __qt_ExamplesAssetDownloaderPrivate_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_ExamplesAssetDownloaderPrivate_target_deps "Qt6Concurrent\;6.8.1;Qt6Core\;6.8.1;Qt6Network\;6.8.1") +set(__qt_ExamplesAssetDownloaderPrivate_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("ExamplesAssetDownloaderPrivate" __qt_ExamplesAssetDownloaderPrivate_target_deps + __qt_ExamplesAssetDownloaderPrivate_find_dependency_paths) + +set(_Qt6ExamplesAssetDownloaderPrivate_MODULE_DEPENDENCIES "Concurrent;Core;Network") +set(Qt6ExamplesAssetDownloaderPrivate_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..32a40f2c63bc8e347e09e09a99b50b3a5d65f797 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::ExamplesAssetDownloaderPrivate" for configuration "Debug" +set_property(TARGET Qt6::ExamplesAssetDownloaderPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::ExamplesAssetDownloaderPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6ExamplesAssetDownloaderd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::ExamplesAssetDownloaderPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::ExamplesAssetDownloaderPrivate "${_IMPORT_PREFIX}/lib/Qt6ExamplesAssetDownloaderd.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..75eb8dc17670a431bd3ca580f5f7b138c1d01668 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::ExamplesAssetDownloaderPrivate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::ExamplesAssetDownloaderPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::ExamplesAssetDownloaderPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6ExamplesAssetDownloader.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::ExamplesAssetDownloaderPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::ExamplesAssetDownloaderPrivate "${_IMPORT_PREFIX}/lib/Qt6ExamplesAssetDownloader.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..961f6ad082fd336493bba45a17356018cf92044f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateTargets.cmake @@ -0,0 +1,141 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::ExamplesAssetDownloaderPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::ExamplesAssetDownloaderPrivate +add_library(Qt6::ExamplesAssetDownloaderPrivate STATIC IMPORTED) + +set_target_properties(Qt6::ExamplesAssetDownloaderPrivate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_EXAMPLES_ASSET_DOWNLOADER_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtExamplesAssetDownloader;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtExamplesAssetDownloader/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtExamplesAssetDownloader/6.8.1/QtExamplesAssetDownloader>" + INTERFACE_LINK_LIBRARIES "Qt6::Concurrent;Qt6::Core;Qt6::CorePrivate;Qt6::Network;\$" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6examplesassetdownloaderprivate_metatypes.json>" + _qt_config_module_name "examples_asset_downloader_private" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtExamplesAssetDownloader" + _qt_module_interface_name "ExamplesAssetDownloader" + _qt_package_name "Qt6ExamplesAssetDownloaderPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-ExamplesAssetDownloaderPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6ExamplesAssetDownloaderPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Concurrent" "Qt6::Core" "Qt6::CorePrivate" "Qt6::Network" "Qt6::PlatformModuleInternal" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..492e22ee7a856929e4eb93e43f417609c8e9bd00 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "ExamplesAssetDownloaderPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ddcd8a71881cfa162ae31da594cc06910ea09850 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6ExamplesAssetDownloaderPrivate/Qt6ExamplesAssetDownloaderPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "ExamplesAssetDownloaderPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8508e582c10b59dac17913c4b86b36c68fe39e0c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6FbSupportPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::FbSupportPrivate) +get_target_property(_qt_imported_location Qt6::FbSupportPrivate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::FbSupportPrivate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::FbSupportPrivate" for configuration "Release" +set_property(TARGET Qt6::FbSupportPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::FbSupportPrivate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::FbSupportPrivate" for configuration "MinSizeRel" +set_property(TARGET Qt6::FbSupportPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::FbSupportPrivate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::FbSupportPrivate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..99164cd537a8181097dad9fd99eece833033cc5c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(FbSupportPrivate + __qt_FbSupportPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6FbSupportPrivate_FOUND") + set("Qt6FbSupportPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6FbSupportPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6FbSupportPrivate) instead. + set(Qt6FbSupportPrivate_LIBRARIES "Qt6::FbSupportPrivate") + + get_target_property(_Qt6FbSupportPrivate_OWN_INCLUDE_DIRS + Qt6::FbSupportPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6FbSupportPrivate_OWN_INCLUDE_DIRS) + set(_Qt6FbSupportPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::FbSupportPrivatePrivate) + get_target_property(_Qt6FbSupportPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::FbSupportPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6FbSupportPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6FbSupportPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6FbSupportPrivate_DEFINITIONS + Qt6::FbSupportPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6FbSupportPrivate_DEFINITIONS) + set(Qt6FbSupportPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6FbSupportPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6FbSupportPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6FbSupportPrivate_COMPILE_DEFINITIONS + Qt6::FbSupportPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6FbSupportPrivate_COMPILE_DEFINITIONS) + set(Qt6FbSupportPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6FbSupportPrivate_INCLUDE_DIRS + ${_Qt6FbSupportPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6FbSupportPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6FbSupportPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6FbSupportPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6FbSupportPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6FbSupportPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6FbSupportPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6FbSupportPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6FbSupportPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6FbSupportPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6FbSupportPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6FbSupportPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6FbSupportPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::FbSupportPrivate) + qt_make_features_available(Qt6::FbSupportPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "FbSupportPrivate") + + get_target_property(_qt_module_target_type "Qt6::FbSupportPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::FbSupportPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6FbSupportPrivate_FOUND FALSE) + if(NOT DEFINED Qt6FbSupportPrivate_NOT_FOUND_MESSAGE) + set(Qt6FbSupportPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::FbSupportPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6FbSupportPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e871e164fc02cda61355afc7af68f411d585d8da --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c7164daedee155a91f614d7869e9a516d4e42035 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6FbSupportPrivate_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_FbSupportPrivate_third_party_deps "") + +_qt_internal_find_third_party_dependencies("FbSupportPrivate" __qt_FbSupportPrivate_third_party_deps) + +# Find Qt tool package. +set(__qt_FbSupportPrivate_tool_deps "") +_qt_internal_find_tool_dependencies("FbSupportPrivate" __qt_FbSupportPrivate_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_FbSupportPrivate_target_deps "Qt6Core\;6.8.1;Qt6Gui\;6.8.1") +set(__qt_FbSupportPrivate_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("FbSupportPrivate" __qt_FbSupportPrivate_target_deps + __qt_FbSupportPrivate_find_dependency_paths) + +set(_Qt6FbSupportPrivate_MODULE_DEPENDENCIES "Core;Gui") +set(Qt6FbSupportPrivate_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c9b23d1ba2bc2255419e0ef8b3657e36915b83a3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::FbSupportPrivate" for configuration "Debug" +set_property(TARGET Qt6::FbSupportPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::FbSupportPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6FbSupportd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::FbSupportPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::FbSupportPrivate "${_IMPORT_PREFIX}/lib/Qt6FbSupportd.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..122723d83af5ece6bde0a0da9474bde23028f76c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::FbSupportPrivate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::FbSupportPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::FbSupportPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6FbSupport.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::FbSupportPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::FbSupportPrivate "${_IMPORT_PREFIX}/lib/Qt6FbSupport.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..350cc530bcb7f7602cb43b15c30f26ae0b4491ff --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateTargets.cmake @@ -0,0 +1,141 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::FbSupportPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::FbSupportPrivate +add_library(Qt6::FbSupportPrivate STATIC IMPORTED) + +set_target_properties(Qt6::FbSupportPrivate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_FB_SUPPORT_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtFbSupport;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtFbSupport/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtFbSupport/6.8.1/QtFbSupport>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::GuiPrivate;\$" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6fbsupportprivate_metatypes.json>" + _qt_config_module_name "fb_support_private" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_include_name "QtFbSupport" + _qt_module_interface_name "FbSupport" + _qt_package_name "Qt6FbSupportPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-FbSupportPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6FbSupportPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::CorePrivate" "Qt6::GuiPrivate" "Qt6::PlatformModuleInternal" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..58d4bb285f7f848c44259788f46ec6e9f5cedbd9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "FbSupportPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f9c873a6a2562e4383c7320071b9d0db3e742a88 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FbSupportPrivate/Qt6FbSupportPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "FbSupportPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6b6ba9ec7dfc911e7c761e7285fba7b7d4746098 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateAdditionalTargetInfo.cmake @@ -0,0 +1,6 @@ +# Additional target information for Qt6FreetypePrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::FreetypePrivate) + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..068799fcbf3667720469ad41ffd0e773c7779d78 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(FreetypePrivate + __qt_FreetypePrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6FreetypePrivate_FOUND") + set("Qt6FreetypePrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6FreetypePrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6FreetypePrivate) instead. + set(Qt6FreetypePrivate_LIBRARIES "Qt6::FreetypePrivate") + + get_target_property(_Qt6FreetypePrivate_OWN_INCLUDE_DIRS + Qt6::FreetypePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6FreetypePrivate_OWN_INCLUDE_DIRS) + set(_Qt6FreetypePrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::FreetypePrivatePrivate) + get_target_property(_Qt6FreetypePrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::FreetypePrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6FreetypePrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6FreetypePrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6FreetypePrivate_DEFINITIONS + Qt6::FreetypePrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6FreetypePrivate_DEFINITIONS) + set(Qt6FreetypePrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6FreetypePrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6FreetypePrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6FreetypePrivate_COMPILE_DEFINITIONS + Qt6::FreetypePrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6FreetypePrivate_COMPILE_DEFINITIONS) + set(Qt6FreetypePrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6FreetypePrivate_INCLUDE_DIRS + ${_Qt6FreetypePrivate_OWN_INCLUDE_DIRS}) + + set(Qt6FreetypePrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6FreetypePrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6FreetypePrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6FreetypePrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6FreetypePrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6FreetypePrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6FreetypePrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6FreetypePrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6FreetypePrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6FreetypePrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6FreetypePrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6FreetypePrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::FreetypePrivate) + qt_make_features_available(Qt6::FreetypePrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "FreetypePrivate") + + get_target_property(_qt_module_target_type "Qt6::FreetypePrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::FreetypePrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6FreetypePrivate_FOUND FALSE) + if(NOT DEFINED Qt6FreetypePrivate_NOT_FOUND_MESSAGE) + set(Qt6FreetypePrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::FreetypePrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6FreetypePrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5fd387209e6ecc949c645a674ae65e65057d08e6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5dfb094b10767750f2302319088ef874b58ac878 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateTargets.cmake @@ -0,0 +1,123 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::FreetypePrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::FreetypePrivate +add_library(Qt6::FreetypePrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::FreetypePrivate PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "QT_FREETYPE_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtFreetype;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtFreetype/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtFreetype/6.8.1/QtFreetype>" + _qt_config_module_name "freetype_private" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_include_name "QtFreetype" + _qt_module_interface_name "Freetype" + _qt_module_is_3rdparty_header_library "TRUE" + _qt_module_skip_depends_include "TRUE" + _qt_package_name "Qt6FreetypePrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-bundled-3rdparty-module-FreetypePrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6FreetypePrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..efb09d4332b2d1250450b73b7e1bf0421fc851ee --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "FreetypePrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e62cd363c20b63433daa24ec0aac62b350454099 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6FreetypePrivate/Qt6FreetypePrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "FreetypePrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee6cf1ac2e0a6f99e257b65f7bcb3db39b6e4ae2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6Gui +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::Gui) +get_target_property(_qt_imported_location Qt6::Gui IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::Gui IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::Gui IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::Gui IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::Gui IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::Gui IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::Gui" for configuration "Release" +set_property(TARGET Qt6::Gui APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::Gui" for configuration "MinSizeRel" +set_property(TARGET Qt6::Gui APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::Gui PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::GuiPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d003f6dc3f66207ff14927c931340c3ec8be3d71 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6GuiDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiDependencies.cmake") + _qt_internal_suggest_dependency_debugging(Gui + __qt_Gui_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6Gui_FOUND") + set("Qt6Gui_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6Gui_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6Gui) instead. + set(Qt6Gui_LIBRARIES "Qt6::Gui") + + get_target_property(_Qt6Gui_OWN_INCLUDE_DIRS + Qt6::Gui INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Gui_OWN_INCLUDE_DIRS) + set(_Qt6Gui_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::GuiPrivate) + get_target_property(_Qt6Gui_OWN_PRIVATE_INCLUDE_DIRS + Qt6::GuiPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Gui_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6Gui_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6Gui_DEFINITIONS + Qt6::Gui INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Gui_DEFINITIONS) + set(Qt6Gui_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6Gui_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6Gui_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6Gui_COMPILE_DEFINITIONS + Qt6::Gui INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Gui_COMPILE_DEFINITIONS) + set(Qt6Gui_COMPILE_DEFINITIONS "") + endif() + + set(Qt6Gui_INCLUDE_DIRS + ${_Qt6Gui_OWN_INCLUDE_DIRS}) + + set(Qt6Gui_PRIVATE_INCLUDE_DIRS + ${_Qt6Gui_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6Gui_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6Gui${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6Gui${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6Gui_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6Gui${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6Gui${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6Gui_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Gui_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Gui_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6Gui_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::Gui) + qt_make_features_available(Qt6::Gui) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6GuiPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Gui") + + get_target_property(_qt_module_target_type "Qt6::Gui" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::Gui MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6GuiBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6Gui_FOUND FALSE) + if(NOT DEFINED Qt6Gui_NOT_FOUND_MESSAGE) + set(Qt6Gui_NOT_FOUND_MESSAGE + "Target \"Qt6::Gui\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6Gui_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6GuiTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..684de21587d306ce419f9c399f6673d14b6cd085 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5873b3903ed4cc7c4e1829d71b5aa76207ea6b4c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiDependencies.cmake @@ -0,0 +1,48 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6Gui_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_Gui_third_party_deps "WrapVulkanHeaders\;TRUE\;\;\;") +set(__qt_Gui_third_party_package_WrapVulkanHeaders_provided_targets "WrapVulkanHeaders::WrapVulkanHeaders") + +_qt_internal_find_third_party_dependencies("Gui" __qt_Gui_third_party_deps) + +# Find Qt tool package. +set(__qt_Gui_tool_deps "Qt6GuiTools\;6.8.1") +_qt_internal_find_tool_dependencies("Gui" __qt_Gui_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_Gui_target_deps "Qt6Core\;6.8.1") +set(__qt_Gui_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("Gui" __qt_Gui_target_deps + __qt_Gui_find_dependency_paths) + +set(_Qt6Gui_MODULE_DEPENDENCIES "Core") +set(Qt6Gui_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiPlugins.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiPlugins.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1febd98e8e2cf775dd9325f09d9618342199bb57 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiPlugins.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_PLUGIN_INCLUSION OFF) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION) + __qt_internal_include_plugin_packages(Gui) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7d1f9462bf95126062f7b1a38335367ac6aad827 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Gui" for configuration "Debug" +set_property(TARGET Qt6::Gui APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::Gui PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6Guid.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6Guid.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Gui ) +list(APPEND _cmake_import_check_files_for_Qt6::Gui "${_IMPORT_PREFIX}/lib/Qt6Guid.lib" "${_IMPORT_PREFIX}/bin/Qt6Guid.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ff3037236fc98f83056571fce83d64e8ff799c24 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Gui" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::Gui APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::Gui PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6Gui.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6Gui.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Gui ) +list(APPEND _cmake_import_check_files_for_Qt6::Gui "${_IMPORT_PREFIX}/lib/Qt6Gui.lib" "${_IMPORT_PREFIX}/bin/Qt6Gui.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0834fa5b9dc49db13a83d473d18395e8180ffe13 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiTargets.cmake @@ -0,0 +1,170 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Gui Qt6::GuiPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Gui +add_library(Qt6::Gui SHARED IMPORTED) + +set_target_properties(Qt6::Gui PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_GUI_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtGui;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;d3d11;dxgi;dxguid;d3d12;\$" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6gui_metatypes.json>" + MODULE_PLUGIN_TYPES "accessiblebridge;platforms;platforms_darwin;xcbglintegrations;platformthemes;platforminputcontexts;generic;iconengines;imageformats;egldeviceintegrations" + QT_DISABLED_PRIVATE_FEATURES "accessibility_atspi_bridge;directfb;evdev;system_freetype;fontconfig;system_harfbuzz;qqnx_imf;integrityfb;kms;drm_atomic;libinput;integrityhid;libinput_axis_api;libinput_hires_wheel_support;linuxfb;vsp2;vnc;mtdev;vkkhrdisplay;egl_x11;eglfs;eglfs_brcm;eglfs_egldevice;eglfs_gbm;eglfs_vsp2;eglfs_mali;eglfs_viv;eglfs_rcar;eglfs_viv_wl;eglfs_openwfd;eglfs_x11;system_jpeg;system_png;tslib;xcb_glx;xcb_egl_plugin;xcb_native_painting;xrender;xcb_xlib;xcb_sm;system_xcb_xinput;xkbcommon;xkbcommon_x11;xlib;graphicsframecapture" + QT_DISABLED_PUBLIC_FEATURES "accessibility_atspi_bridge;fontconfig;opengles2;opengles3;opengles31;opengles32;metal;openvg;egl;xcb;xcb_glx_plugin;system_textmarkdownreader;wayland" + QT_ENABLED_PRIVATE_FEATURES "directwrite;directwrite3;direct2d;direct2d1_1;freetype;harfbuzz;vkgen;gif;ico;jpeg;png;imageio_text_loading;tuiotouch;multiprocess;raster_64bit;raster_fp" + QT_ENABLED_PUBLIC_FEATURES "freetype;harfbuzz;dynamicgl;opengl;vulkan;ico;sessionmanager;texthtmlparser;textmarkdownreader;textmarkdownwriter;textodfwriter;cssparser;draganddrop;action;cursor;clipboard;wheelevent;tabletevent;im;highdpiscaling;validator;standarditemmodel;filesystemmodel;imageformatplugin;movie;imageformat_bmp;imageformat_ppm;imageformat_xbm;imageformat_xpm;imageformat_png;imageformat_jpeg;image_heuristic_mask;image_text;picture;colornames;pdf;desktopservices;systemtrayicon;accessibility;whatsthis;undocommand;undostack;undogroup" + QT_QMAKE_PRIVATE_CONFIG "" + QT_QMAKE_PUBLIC_CONFIG "" + QT_QMAKE_PUBLIC_QT_CONFIG "" + _qt_config_module_name "gui" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_has_qpa_headers "TRUE" + _qt_module_has_rhi_headers "TRUE" + _qt_module_include_name "QtGui" + _qt_module_interface_name "Gui" + _qt_package_name "Qt6Gui" + _qt_package_version "6.8.1" + _qt_private_module_target_name "GuiPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Gui" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::GuiPrivate +add_library(Qt6::GuiPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::GuiPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtGui/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtGui/6.8.1/QtGui>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::Gui" + _qt_config_module_name "gui_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6Gui" + _qt_package_version "6.8.1" + _qt_public_module_target_name "Gui" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Gui" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6GuiTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Core" "Qt6::CorePrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d2a7c93fb23c491e4b61df19bb9eb83947573acb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Gui;GuiPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..40f807148453892dc48587447b893a89035566c8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6GuiVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Gui;GuiPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..72d2cfbecdc0a9621ede73da775f9a3348153fd8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QGifPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QGifPlugin) +get_target_property(_qt_imported_location Qt6::QGifPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QGifPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QGifPlugin" for configuration "Release" +set_property(TARGET Qt6::QGifPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QGifPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QGifPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QGifPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QGifPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QGifPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f3b7b815fd52708da7960f1f340f3ce9e9f40151 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QGifPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QGifPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QGifPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QGifPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bec68ee6d66a70cddd6cd8c72aa99f331f3ea6ea --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QGifPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d8e3dc055d7cbb3fa38af44e7cc8830cafa4d16f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QGifPlugin" for configuration "Debug" +set_property(TARGET Qt6::QGifPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QGifPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qgifd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QGifPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QGifPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qgifd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1a2b186fee2d749c71e77c2196913a804f0e7364 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QGifPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QGifPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QGifPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qgif.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QGifPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QGifPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qgif.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0755b0320c9e6e3d18fabc40c08144e117f39ee4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QGifPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QGifPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QGifPlugin +add_library(Qt6::QGifPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QGifPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QGifPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QGifPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QGifPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ba295a1c29f7176af84625c49b9b13ccaa7bea93 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QICNSPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QICNSPlugin) +get_target_property(_qt_imported_location Qt6::QICNSPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QICNSPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QICNSPlugin" for configuration "Release" +set_property(TARGET Qt6::QICNSPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QICNSPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QICNSPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QICNSPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QICNSPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QICNSPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c32066c8a0a8ae321866ccbeb4c6d74c2d91e377 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtImageFormats" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QICNSPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QICNSPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QICNSPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QICNSPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9c068ff997db154df479ab3cbce80d8d0c1e311d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QICNSPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..04f61e5e7021c4572b0477f16c3a2da245b2b0f1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QICNSPlugin" for configuration "Debug" +set_property(TARGET Qt6::QICNSPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QICNSPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qicnsd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QICNSPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QICNSPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qicnsd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c6c18052c4c35a3ff86d6eae882dd71a13d0d400 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QICNSPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QICNSPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QICNSPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qicns.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QICNSPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QICNSPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qicns.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ab5daca42f72cab95ec4865b8342aba441caaecb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QICNSPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QICNSPlugin +add_library(Qt6::QICNSPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QICNSPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QICNSPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtimageformats-qt-plugin-QICNSPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtimageformats-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtimageformats-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtimageformats" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QICNSPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..70e759d5da68459434730c0f4c08034f08392bb4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QICOPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QICOPlugin) +get_target_property(_qt_imported_location Qt6::QICOPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QICOPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QICOPlugin" for configuration "Release" +set_property(TARGET Qt6::QICOPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QICOPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QICOPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QICOPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QICOPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QICOPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a49b7777562c51049425fc2b6564b7cfea8ca095 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QICOPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QICOPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QICOPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QICOPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..caa0003d2b60862ebef42b177fe66c77a6780518 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QICOPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6ee6073106710d627e927692b8c8a41e1b4e7e84 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QICOPlugin" for configuration "Debug" +set_property(TARGET Qt6::QICOPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QICOPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qicod.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QICOPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QICOPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qicod.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cd02a3fa49cfa9b1caf94be9a095f3390ca0ae37 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QICOPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QICOPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QICOPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qico.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QICOPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QICOPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qico.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2ca039d230aedecd758afba084680e688bf15f4a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QICOPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QICOPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QICOPlugin +add_library(Qt6::QICOPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QICOPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QICOPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QICOPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QICOPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5249b16b3d3e73f6fdf1b9f427d47363aa672248 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QJpegPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QJpegPlugin) +get_target_property(_qt_imported_location Qt6::QJpegPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QJpegPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QJpegPlugin" for configuration "Release" +set_property(TARGET Qt6::QJpegPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QJpegPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QJpegPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QJpegPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QJpegPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QJpegPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e28ab4c671809893fac84364965a978913bf61da --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QJpegPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QJpegPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QJpegPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QJpegPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bbf74dd786450984c9ebaacf18236a04a3f7a91f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QJpegPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d5545705c9e58ad5ae18288ca52932f35c89b23a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QJpegPlugin" for configuration "Debug" +set_property(TARGET Qt6::QJpegPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QJpegPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qjpegd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QJpegPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QJpegPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qjpegd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..43a04012ac1c06a5c86920a83faaff30b26db168 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QJpegPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QJpegPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QJpegPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qjpeg.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QJpegPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QJpegPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qjpeg.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1c44c4449e121ad05b286f43d25082596b834c56 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QJpegPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QJpegPlugin +add_library(Qt6::QJpegPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QJpegPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QJpegPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QJpegPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QJpegPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1676015289d06dbb690fbe36066bc7d0a8e8ea1a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QMinimalIntegrationPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QMinimalIntegrationPlugin) +get_target_property(_qt_imported_location Qt6::QMinimalIntegrationPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QMinimalIntegrationPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QMinimalIntegrationPlugin" for configuration "Release" +set_property(TARGET Qt6::QMinimalIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QMinimalIntegrationPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QMinimalIntegrationPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QMinimalIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QMinimalIntegrationPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QMinimalIntegrationPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f9388c0048cfbbe0e12b3baede79dd166ffe3a3e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QMinimalIntegrationPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QMinimalIntegrationPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QMinimalIntegrationPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QMinimalIntegrationPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..021f30e71ab64f247524bc8f15e00fc200b936ea --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QMinimalIntegrationPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7f71b40b1efc1d7efdf78a5a885792989d99f178 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QMinimalIntegrationPlugin" for configuration "Debug" +set_property(TARGET Qt6::QMinimalIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QMinimalIntegrationPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/platforms/qminimald.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QMinimalIntegrationPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QMinimalIntegrationPlugin "${_IMPORT_PREFIX}/plugins/platforms/qminimald.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..324368c6e805732167c59454467f7a7f6382589f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QMinimalIntegrationPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QMinimalIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QMinimalIntegrationPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/platforms/qminimal.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QMinimalIntegrationPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QMinimalIntegrationPlugin "${_IMPORT_PREFIX}/plugins/platforms/qminimal.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3624251ef87198d7863319db37f82c5dfbd85a7b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QMinimalIntegrationPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QMinimalIntegrationPlugin +add_library(Qt6::QMinimalIntegrationPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QMinimalIntegrationPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "0" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QMinimalIntegrationPlugin" + QT_PLUGIN_TYPE "platforms" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QMinimalIntegrationPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QMinimalIntegrationPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..36b3202e182f148ebe71b6d11c0ba8d242852c67 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QOffscreenIntegrationPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QOffscreenIntegrationPlugin) +get_target_property(_qt_imported_location Qt6::QOffscreenIntegrationPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QOffscreenIntegrationPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QOffscreenIntegrationPlugin" for configuration "Release" +set_property(TARGET Qt6::QOffscreenIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QOffscreenIntegrationPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QOffscreenIntegrationPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QOffscreenIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QOffscreenIntegrationPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QOffscreenIntegrationPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bde02a31974fe6eb4b7c90fbdcc771a74e3aa7d0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QOffscreenIntegrationPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QOffscreenIntegrationPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QOffscreenIntegrationPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QOffscreenIntegrationPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5ba7115fbc38d9646a029e929f4beeb0ab940b9a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QOffscreenIntegrationPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..21f9789eca357096525c2e9dd459aa21f3d54fe7 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QOffscreenIntegrationPlugin" for configuration "Debug" +set_property(TARGET Qt6::QOffscreenIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QOffscreenIntegrationPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/platforms/qoffscreend.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QOffscreenIntegrationPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QOffscreenIntegrationPlugin "${_IMPORT_PREFIX}/plugins/platforms/qoffscreend.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..145444f85531aae3c50c316bfc35249572f9845c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QOffscreenIntegrationPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QOffscreenIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QOffscreenIntegrationPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/platforms/qoffscreen.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QOffscreenIntegrationPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QOffscreenIntegrationPlugin "${_IMPORT_PREFIX}/plugins/platforms/qoffscreen.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..32c0138b586ce9fbe4b731d43825d6ab765594d8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QOffscreenIntegrationPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QOffscreenIntegrationPlugin +add_library(Qt6::QOffscreenIntegrationPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QOffscreenIntegrationPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "0" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QOffscreenIntegrationPlugin" + QT_PLUGIN_TYPE "platforms" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QOffscreenIntegrationPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QOffscreenIntegrationPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7e8751baed95784c35936d49c33a4635bd0a7a76 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QSvgIconPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QSvgIconPlugin) +get_target_property(_qt_imported_location Qt6::QSvgIconPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QSvgIconPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QSvgIconPlugin" for configuration "Release" +set_property(TARGET Qt6::QSvgIconPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QSvgIconPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QSvgIconPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QSvgIconPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QSvgIconPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QSvgIconPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5e8aee79acd07cb09fdb9c6e7bf927d840d7201e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtSvg" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgIconPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgIconPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgIconPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgIconPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..19d7b8e7cdd0afb2c023a526ee1ba3f0c11bd72b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgIconPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..63ee6081c41398a276799dd7c44e7583f335decb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QSvgIconPlugin" for configuration "Debug" +set_property(TARGET Qt6::QSvgIconPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QSvgIconPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/iconengines/qsvgicond.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QSvgIconPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QSvgIconPlugin "${_IMPORT_PREFIX}/plugins/iconengines/qsvgicond.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..321f0d6b73e9de432eb7d4d18c24103c015c8c5a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QSvgIconPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QSvgIconPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QSvgIconPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/iconengines/qsvgicon.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QSvgIconPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QSvgIconPlugin "${_IMPORT_PREFIX}/plugins/iconengines/qsvgicon.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..003c9d5499d9916d8efb69c94e5e9da3648f1d00 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QSvgIconPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QSvgIconPlugin +add_library(Qt6::QSvgIconPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QSvgIconPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QSvgIconPlugin" + QT_PLUGIN_TYPE "iconengines" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtsvg-qt-plugin-QSvgIconPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtsvg-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtsvg-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtsvg" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgIconPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..639569ed2355dd1b69670dc4288e0e74b152fcc2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QSvgPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QSvgPlugin) +get_target_property(_qt_imported_location Qt6::QSvgPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QSvgPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QSvgPlugin" for configuration "Release" +set_property(TARGET Qt6::QSvgPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QSvgPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QSvgPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QSvgPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QSvgPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QSvgPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4d282c2810b05ab0f1d7d10cace081fe80b99b4f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtSvg" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..74b8d828d9abd69dac6b718c8c908657ab765602 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..efdb3f8c88df570fe01f4e7d1a70ac3f359cbdc2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QSvgPlugin" for configuration "Debug" +set_property(TARGET Qt6::QSvgPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QSvgPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qsvgd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QSvgPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QSvgPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qsvgd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3932004acf4269e0ad7e836f3ec7d6b9d344e98d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QSvgPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QSvgPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QSvgPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qsvg.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QSvgPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QSvgPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qsvg.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..755c2689726addb8b5c20d277e73abdcfdee6381 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QSvgPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QSvgPlugin +add_library(Qt6::QSvgPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QSvgPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QSvgPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtsvg-qt-plugin-QSvgPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtsvg-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtsvg-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtsvg" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QSvgPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..daebae4e42efec5806c1f0b0eb610df5366e0565 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QTgaPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QTgaPlugin) +get_target_property(_qt_imported_location Qt6::QTgaPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QTgaPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QTgaPlugin" for configuration "Release" +set_property(TARGET Qt6::QTgaPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTgaPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QTgaPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QTgaPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTgaPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QTgaPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a1747fc67cf3881496a8645b71b9ce2078caa986 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtImageFormats" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QTgaPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTgaPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTgaPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTgaPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..16a06f2890473bac047b683e02b3a05bace82251 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTgaPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..95229d247682cdd9e43f7f2e9c19fa6aba7d530f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTgaPlugin" for configuration "Debug" +set_property(TARGET Qt6::QTgaPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QTgaPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qtgad.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTgaPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTgaPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qtgad.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fe7600a0f422585070718957fbb1a6b9452269e0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTgaPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QTgaPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QTgaPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qtga.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTgaPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTgaPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qtga.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d4961273c8278506b0b92981e55f55febdfff251 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QTgaPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QTgaPlugin +add_library(Qt6::QTgaPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QTgaPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QTgaPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtimageformats-qt-plugin-QTgaPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtimageformats-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtimageformats-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtimageformats" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QTgaPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c5bbb48bbddefbd3489addcc4c3009353683bb43 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QTiffPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QTiffPlugin) +get_target_property(_qt_imported_location Qt6::QTiffPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QTiffPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QTiffPlugin" for configuration "Release" +set_property(TARGET Qt6::QTiffPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTiffPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QTiffPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QTiffPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTiffPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QTiffPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a03a3770d9e36db08a5442cdfed6c5b767979c16 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtImageFormats" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QTiffPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTiffPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTiffPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTiffPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ae51ce8c64bc28fff1475d548574da05fab88907 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTiffPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bb6bb0ebda824c0a68b3a97cd8a81921ecbd23a1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTiffPlugin" for configuration "Debug" +set_property(TARGET Qt6::QTiffPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QTiffPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qtiffd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTiffPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTiffPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qtiffd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..98e33a652dd24be19b1e1fb99e4229c56461c05a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTiffPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QTiffPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QTiffPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qtiff.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTiffPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTiffPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qtiff.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..671fd25cbb08a6842c6d5177aef1366ac3e16a5f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QTiffPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QTiffPlugin +add_library(Qt6::QTiffPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QTiffPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QTiffPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtimageformats-qt-plugin-QTiffPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtimageformats-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtimageformats-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtimageformats" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QTiffPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7c2a69e2fba111be234a1f6a6845bc4e3d7ada17 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QTuioTouchPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QTuioTouchPlugin) +get_target_property(_qt_imported_location Qt6::QTuioTouchPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QTuioTouchPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QTuioTouchPlugin" for configuration "Release" +set_property(TARGET Qt6::QTuioTouchPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTuioTouchPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QTuioTouchPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QTuioTouchPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTuioTouchPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QTuioTouchPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8c84e5de769e1754f66e05f21aad79e24032e6a4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QTuioTouchPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTuioTouchPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTuioTouchPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTuioTouchPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2627af43abcb60bacd17096396216ae4cc641cca --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTuioTouchPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f21a5fe10cf7eb1dfeb67c8db8d5912f37b35edc --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTuioTouchPlugin" for configuration "Debug" +set_property(TARGET Qt6::QTuioTouchPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QTuioTouchPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/generic/qtuiotouchplugind.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTuioTouchPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTuioTouchPlugin "${_IMPORT_PREFIX}/plugins/generic/qtuiotouchplugind.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..59d7aa8afdbb0df17e300760c964c54f7c181150 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTuioTouchPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QTuioTouchPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QTuioTouchPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/generic/qtuiotouchplugin.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTuioTouchPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTuioTouchPlugin "${_IMPORT_PREFIX}/plugins/generic/qtuiotouchplugin.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0370247f9085237c8c3682a41edef0a9d012dd82 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QTuioTouchPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QTuioTouchPlugin +add_library(Qt6::QTuioTouchPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QTuioTouchPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "0" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QTuioTouchPlugin" + QT_PLUGIN_TYPE "generic" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QTuioTouchPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QTuioTouchPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b8145f8aeea7b8f3c5e2cb57b021f5624d59000c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QWbmpPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QWbmpPlugin) +get_target_property(_qt_imported_location Qt6::QWbmpPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QWbmpPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QWbmpPlugin" for configuration "Release" +set_property(TARGET Qt6::QWbmpPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QWbmpPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QWbmpPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QWbmpPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QWbmpPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QWbmpPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0ad07c83e4e417240defdddc064731e324373d82 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtImageFormats" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QWbmpPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWbmpPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWbmpPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWbmpPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7a761f76628e7ece5e9582e4c838cf6b56e1d069 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWbmpPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee66f799ebd2fbb13be8925c48966658b206be4a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QWbmpPlugin" for configuration "Debug" +set_property(TARGET Qt6::QWbmpPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QWbmpPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qwbmpd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QWbmpPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QWbmpPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qwbmpd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a5bbbcd2f8b10be778bc1e8e892a63ad67d29992 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QWbmpPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QWbmpPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QWbmpPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qwbmp.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QWbmpPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QWbmpPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qwbmp.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cb9cea7d6f0b6e5759c388829048b6deb9e351ab --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QWbmpPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QWbmpPlugin +add_library(Qt6::QWbmpPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QWbmpPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QWbmpPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtimageformats-qt-plugin-QWbmpPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtimageformats-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtimageformats-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtimageformats" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QWbmpPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..32e9e133dfa2d6bc78a015fca249bdbb7b99f29f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QWebpPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QWebpPlugin) +get_target_property(_qt_imported_location Qt6::QWebpPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QWebpPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QWebpPlugin" for configuration "Release" +set_property(TARGET Qt6::QWebpPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QWebpPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QWebpPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QWebpPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QWebpPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QWebpPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f837f5452facea36cafb378323961f682ee97b75 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtImageFormats" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QWebpPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWebpPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWebpPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWebpPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3a2f151ebb2a11bd716605b48bb6f1afe2c56634 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWebpPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..39e7535a63f61359042f99ddf2f8e4644c27960b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QWebpPlugin" for configuration "Debug" +set_property(TARGET Qt6::QWebpPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QWebpPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/imageformats/qwebpd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QWebpPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QWebpPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qwebpd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8ae21059464362bbc052b4e9a0cb5061884c31ce --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QWebpPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QWebpPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QWebpPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/imageformats/qwebp.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QWebpPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QWebpPlugin "${_IMPORT_PREFIX}/plugins/imageformats/qwebp.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..71e502feec79bbd97d09d4830a0792cf96312372 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QWebpPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QWebpPlugin +add_library(Qt6::QWebpPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QWebpPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QWebpPlugin" + QT_PLUGIN_TYPE "imageformats" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtimageformats-qt-plugin-QWebpPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtimageformats-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtimageformats-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtimageformats" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QWebpPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..35892f26ac1e51db2e1e37008e0cd7373eb8aba5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QWindowsDirect2DIntegrationPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QWindowsDirect2DIntegrationPlugin) +get_target_property(_qt_imported_location Qt6::QWindowsDirect2DIntegrationPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QWindowsDirect2DIntegrationPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QWindowsDirect2DIntegrationPlugin" for configuration "Release" +set_property(TARGET Qt6::QWindowsDirect2DIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QWindowsDirect2DIntegrationPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QWindowsDirect2DIntegrationPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QWindowsDirect2DIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QWindowsDirect2DIntegrationPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QWindowsDirect2DIntegrationPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..686d0a7d39b43f3ec65241fc0a872c6e31f3869e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsDirect2DIntegrationPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsDirect2DIntegrationPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsDirect2DIntegrationPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsDirect2DIntegrationPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e2f1967a60b024fbc5e097da03198c3e68eb2a7f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsDirect2DIntegrationPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c8476cc1eb4dc425eb065aa917a1fd4ca0281602 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QWindowsDirect2DIntegrationPlugin" for configuration "Debug" +set_property(TARGET Qt6::QWindowsDirect2DIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QWindowsDirect2DIntegrationPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/platforms/qdirect2dd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QWindowsDirect2DIntegrationPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QWindowsDirect2DIntegrationPlugin "${_IMPORT_PREFIX}/plugins/platforms/qdirect2dd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..24c821a85f34e76dc3dbf703a9cffa234a2067b0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QWindowsDirect2DIntegrationPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QWindowsDirect2DIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QWindowsDirect2DIntegrationPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/platforms/qdirect2d.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QWindowsDirect2DIntegrationPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QWindowsDirect2DIntegrationPlugin "${_IMPORT_PREFIX}/plugins/platforms/qdirect2d.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..16e7008f9d7c15acb35499527c3761f60f925585 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsDirect2DIntegrationPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QWindowsDirect2DIntegrationPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QWindowsDirect2DIntegrationPlugin +add_library(Qt6::QWindowsDirect2DIntegrationPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QWindowsDirect2DIntegrationPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "0" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QWindowsDirect2DIntegrationPlugin" + QT_PLUGIN_TYPE "platforms" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QWindowsDirect2DIntegrationPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsDirect2DIntegrationPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..92c25be0278557292d4b3341dbdbb05459a33cb3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QWindowsIntegrationPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QWindowsIntegrationPlugin) +get_target_property(_qt_imported_location Qt6::QWindowsIntegrationPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QWindowsIntegrationPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QWindowsIntegrationPlugin" for configuration "Release" +set_property(TARGET Qt6::QWindowsIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QWindowsIntegrationPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QWindowsIntegrationPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QWindowsIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QWindowsIntegrationPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QWindowsIntegrationPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bb7b47aa0177b38f3ef245d63dd967539f5f3de1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsIntegrationPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsIntegrationPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsIntegrationPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsIntegrationPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..78a0483c051974e96f4f71af98df6381c006188f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsIntegrationPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7230822a800ffa774b18120763054428debfda1f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QWindowsIntegrationPlugin" for configuration "Debug" +set_property(TARGET Qt6::QWindowsIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QWindowsIntegrationPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/platforms/qwindowsd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QWindowsIntegrationPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QWindowsIntegrationPlugin "${_IMPORT_PREFIX}/plugins/platforms/qwindowsd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6a0696a03de63ae16e386c0830f34c487b5ae0b5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QWindowsIntegrationPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QWindowsIntegrationPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QWindowsIntegrationPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/platforms/qwindows.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QWindowsIntegrationPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QWindowsIntegrationPlugin "${_IMPORT_PREFIX}/plugins/platforms/qwindows.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f18a588879f9bd6d7e63552204387ccccff74ef8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Gui/Qt6QWindowsIntegrationPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QWindowsIntegrationPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QWindowsIntegrationPlugin +add_library(Qt6::QWindowsIntegrationPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QWindowsIntegrationPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Gui" + QT_PLUGIN_CLASS_NAME "QWindowsIntegrationPlugin" + QT_PLUGIN_TYPE "platforms" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QWindowsIntegrationPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QWindowsIntegrationPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f656a4a7b4c4a716d981fcb8c4731d885e53878b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsAdditionalTargetInfo.cmake @@ -0,0 +1,37 @@ +# Additional target information for Qt6GuiTools +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +get_target_property(_qt_imported_location Qt6::qvkgen IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::qvkgen IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::qvkgen" for configuration "Release" +set_property(TARGET Qt6::qvkgen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::qvkgen PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::qvkgen" for configuration "MinSizeRel" +set_property(TARGET Qt6::qvkgen APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::qvkgen PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::qvkgen PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b9cc0f1f0452791c99928cd8bece3ddeef078b11 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfig.cmake @@ -0,0 +1,61 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleToolsConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6GuiToolsDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiToolsDependencies.cmake") +endif() + +# If *Dependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6GuiTools_FOUND") + set("Qt6GuiTools_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6GuiTools_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiToolsTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiToolsAdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiToolsVersionlessTargets.cmake") + endif() +endif() + +foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() + + +if(NOT QT_NO_CREATE_TARGETS AND Qt6GuiTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::qvkgen) +endif() +set(Qt6GuiTools_TARGETS "Qt6::qvkgen") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a4a71aa80d0457437f2a2081cdb1f599a11ccf39 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6GuiToolsConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..93e7b8fe45741c6ef60d1556c39854e2ad1acd30 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersionImpl.cmake @@ -0,0 +1,32 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2bb774091254c09f485a1ae96ac26defcc9b7721 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsDependencies.cmake @@ -0,0 +1,16 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Find "ModuleTools" dependencies, which are other ModuleTools packages. +set(Qt6GuiTools_FOUND FALSE) +set(__qt_GuiTools_tool_deps "Qt6CoreTools\;6.8.1") +foreach(__qt_GuiTools_target_dep ${__qt_GuiTools_tool_deps}) + list(GET __qt_GuiTools_target_dep 0 __qt_GuiTools_pkg) + list(GET __qt_GuiTools_target_dep 1 __qt_GuiTools_version) + + if (NOT ${__qt_GuiTools_pkg}_FOUND) + find_dependency(${__qt_GuiTools_pkg} ${__qt_GuiTools_version}) + endif() +endforeach() + +set(Qt6GuiTools_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0c809c7650339e5c5ec95b84f02dd78c0c7a30da --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets-debug.cmake @@ -0,0 +1,9 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0c594c9941612eca41b9f34be91454eba0260e16 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets-relwithdebinfo.cmake @@ -0,0 +1,18 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::qvkgen" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::qvkgen APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::qvkgen PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/qvkgen.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::qvkgen ) +list(APPEND _cmake_import_check_files_for_Qt6::qvkgen "${_IMPORT_PREFIX}/bin/qvkgen.exe" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c8aeae0c7bba885498fdb02c6eff87043a2bcf6f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets.cmake @@ -0,0 +1,114 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "2.8.3") + message(FATAL_ERROR "CMake >= 2.8.3 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.8.3...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::qvkgen) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::qvkgen +add_executable(Qt6::qvkgen IMPORTED) + +set_target_properties(Qt6::qvkgen PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-tool-qvkgen" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6GuiToolsTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..66f176e7ae37baafc0c736eccb3d55cd43b52d0d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6GuiTools/Qt6GuiToolsVersionlessTargets.cmake @@ -0,0 +1,26 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +foreach(__qt_tool qvkgen) + if(NOT TARGET Qt::${__qt_tool} AND TARGET Qt6::${__qt_tool}) + add_executable(Qt::${__qt_tool} IMPORTED GLOBAL) + + # Check all the usual imported location properties to find one that contains a path. + foreach(__qt_imported_location_config + IMPORTED_LOCATION + IMPORTED_LOCATION_RELEASE + IMPORTED_LOCATION_RELWITHDEBINFO + IMPORTED_LOCATION_MINSIZEREL + IMPORTED_LOCATION_DEBUG) + + get_target_property(__qt_imported_location + Qt6::${__qt_tool} ${__qt_imported_location_config}) + if(__qt_imported_location AND EXISTS "${__qt_imported_location}") + break() + endif() + endforeach() + + set_target_properties(Qt::${__qt_tool} + PROPERTIES IMPORTED_LOCATION "${__qt_imported_location}") + endif() +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..77ef21a97ecc050b36d5a9945f837d6a95e3fb65 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,6 @@ +# Additional target information for Qt6HarfbuzzPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::HarfbuzzPrivate) + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..92aace8ac80aea541cc8cd647ada39288e2167d1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(HarfbuzzPrivate + __qt_HarfbuzzPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6HarfbuzzPrivate_FOUND") + set("Qt6HarfbuzzPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6HarfbuzzPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6HarfbuzzPrivate) instead. + set(Qt6HarfbuzzPrivate_LIBRARIES "Qt6::HarfbuzzPrivate") + + get_target_property(_Qt6HarfbuzzPrivate_OWN_INCLUDE_DIRS + Qt6::HarfbuzzPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6HarfbuzzPrivate_OWN_INCLUDE_DIRS) + set(_Qt6HarfbuzzPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::HarfbuzzPrivatePrivate) + get_target_property(_Qt6HarfbuzzPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::HarfbuzzPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6HarfbuzzPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6HarfbuzzPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6HarfbuzzPrivate_DEFINITIONS + Qt6::HarfbuzzPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6HarfbuzzPrivate_DEFINITIONS) + set(Qt6HarfbuzzPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6HarfbuzzPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6HarfbuzzPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6HarfbuzzPrivate_COMPILE_DEFINITIONS + Qt6::HarfbuzzPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6HarfbuzzPrivate_COMPILE_DEFINITIONS) + set(Qt6HarfbuzzPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6HarfbuzzPrivate_INCLUDE_DIRS + ${_Qt6HarfbuzzPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6HarfbuzzPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6HarfbuzzPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6HarfbuzzPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6HarfbuzzPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6HarfbuzzPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6HarfbuzzPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6HarfbuzzPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6HarfbuzzPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6HarfbuzzPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6HarfbuzzPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6HarfbuzzPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6HarfbuzzPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::HarfbuzzPrivate) + qt_make_features_available(Qt6::HarfbuzzPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "HarfbuzzPrivate") + + get_target_property(_qt_module_target_type "Qt6::HarfbuzzPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::HarfbuzzPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6HarfbuzzPrivate_FOUND FALSE) + if(NOT DEFINED Qt6HarfbuzzPrivate_NOT_FOUND_MESSAGE) + set(Qt6HarfbuzzPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::HarfbuzzPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6HarfbuzzPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..128486173c007f75361ca80a5d738525fcc3b1d9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3d209e5c0eeeb65c007889a652bc9fec6ce8bc33 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateTargets.cmake @@ -0,0 +1,123 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::HarfbuzzPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::HarfbuzzPrivate +add_library(Qt6::HarfbuzzPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::HarfbuzzPrivate PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "QT_HARFBUZZ_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtHarfbuzz;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtHarfbuzz/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtHarfbuzz/6.8.1/QtHarfbuzz>" + _qt_config_module_name "harfbuzz_private" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_include_name "QtHarfbuzz" + _qt_module_interface_name "Harfbuzz" + _qt_module_is_3rdparty_header_library "TRUE" + _qt_module_skip_depends_include "TRUE" + _qt_package_name "Qt6HarfbuzzPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-bundled-3rdparty-module-HarfbuzzPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6HarfbuzzPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1aa4084c3afb8dc05a40afee661b30f4e249269e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "HarfbuzzPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9c381a7217fb0bf0ba6273cdcb2576cb821d69bf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HarfbuzzPrivate/Qt6HarfbuzzPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "HarfbuzzPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..18709b034715765eb1dfae7ecfec2f7ce189a1db --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6Help +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::Help) +get_target_property(_qt_imported_location Qt6::Help IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::Help IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::Help IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::Help IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::Help IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::Help IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::Help" for configuration "Release" +set_property(TARGET Qt6::Help APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::Help" for configuration "MinSizeRel" +set_property(TARGET Qt6::Help APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::Help PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::HelpPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4488951cc2e9e8ad42afdcebf5ba3a1cc6c74919 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6HelpDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpDependencies.cmake") + _qt_internal_suggest_dependency_debugging(Help + __qt_Help_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6Help_FOUND") + set("Qt6Help_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6Help_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6Help) instead. + set(Qt6Help_LIBRARIES "Qt6::Help") + + get_target_property(_Qt6Help_OWN_INCLUDE_DIRS + Qt6::Help INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Help_OWN_INCLUDE_DIRS) + set(_Qt6Help_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::HelpPrivate) + get_target_property(_Qt6Help_OWN_PRIVATE_INCLUDE_DIRS + Qt6::HelpPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Help_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6Help_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6Help_DEFINITIONS + Qt6::Help INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Help_DEFINITIONS) + set(Qt6Help_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6Help_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6Help_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6Help_COMPILE_DEFINITIONS + Qt6::Help INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Help_COMPILE_DEFINITIONS) + set(Qt6Help_COMPILE_DEFINITIONS "") + endif() + + set(Qt6Help_INCLUDE_DIRS + ${_Qt6Help_OWN_INCLUDE_DIRS}) + + set(Qt6Help_PRIVATE_INCLUDE_DIRS + ${_Qt6Help_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6Help_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6Help${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6Help${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6Help_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6Help${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6Help${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6Help_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Help_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Help_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6Help_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::Help) + qt_make_features_available(Qt6::Help) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6HelpPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Help") + + get_target_property(_qt_module_target_type "Qt6::Help" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::Help MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6HelpBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6Help_FOUND FALSE) + if(NOT DEFINED Qt6Help_NOT_FOUND_MESSAGE) + set(Qt6Help_NOT_FOUND_MESSAGE + "Target \"Qt6::Help\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6Help_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6HelpTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a755399d616fac5b47d7b9497b8e76ecaa6dd578 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6HelpConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0639aeed28aebca712994fb4d415e74514ab7944 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6Help_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_Help_third_party_deps "") + +_qt_internal_find_third_party_dependencies("Help" __qt_Help_third_party_deps) + +# Find Qt tool package. +set(__qt_Help_tool_deps "") +_qt_internal_find_tool_dependencies("Help" __qt_Help_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_Help_target_deps "Qt6Core\;6.8.1;Qt6Gui\;6.8.1;Qt6Sql\;6.8.1;Qt6Widgets\;6.8.1") +set(__qt_Help_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("Help" __qt_Help_target_deps + __qt_Help_find_dependency_paths) + +set(_Qt6Help_MODULE_DEPENDENCIES "Core;Gui;Sql;Widgets") +set(Qt6Help_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpPlugins.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpPlugins.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d25703673f88b6404c41fbf26a4ccf9c1e7a99c2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpPlugins.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_PLUGIN_INCLUSION OFF) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION) + __qt_internal_include_plugin_packages(Help) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2b154010e14069b3ce9e714e82eef4720ee4e59a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Help" for configuration "Debug" +set_property(TARGET Qt6::Help APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::Help PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6Helpd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6Helpd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Help ) +list(APPEND _cmake_import_check_files_for_Qt6::Help "${_IMPORT_PREFIX}/lib/Qt6Helpd.lib" "${_IMPORT_PREFIX}/bin/Qt6Helpd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bb08437717009075811da66c51776859847d1bf9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Help" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::Help APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::Help PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6Help.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6Help.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Help ) +list(APPEND _cmake_import_check_files_for_Qt6::Help "${_IMPORT_PREFIX}/lib/Qt6Help.lib" "${_IMPORT_PREFIX}/bin/Qt6Help.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4d84ae9e4412430ca5f7157f065650f43e9cb1cf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpTargets.cmake @@ -0,0 +1,145 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Help Qt6::HelpPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Help +add_library(Qt6::Help SHARED IMPORTED) + +set_target_properties(Qt6::Help PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_HELP_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtHelp;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::Gui;Qt6::Sql;Qt6::Widgets" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6help_metatypes.json>" + MODULE_PLUGIN_TYPES "help" + _qt_config_module_name "help" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtHelp" + _qt_module_interface_name "Help" + _qt_package_name "Qt6Help" + _qt_package_version "6.8.1" + _qt_private_module_target_name "HelpPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-module-Help" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Create imported target Qt6::HelpPrivate +add_library(Qt6::HelpPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::HelpPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtHelp/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtHelp/6.8.1/QtHelp>" + INTERFACE_LINK_LIBRARIES "Qt6::Help" + _qt_config_module_name "help_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6Help" + _qt_package_version "6.8.1" + _qt_public_module_target_name "Help" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-module-Help" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6HelpTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ae2670f368527fa6e24d50ab29c69067364af3c0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Help;HelpPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0e7e3a9c59f01d85ad24e61592d1b360734cc49a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6HelpVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Help;HelpPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f0610e0be86f17baf69bfb9e4e7cf6dc4667af19 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QHelpEnginePlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QHelpEnginePlugin) +get_target_property(_qt_imported_location Qt6::QHelpEnginePlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QHelpEnginePlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QHelpEnginePlugin" for configuration "Release" +set_property(TARGET Qt6::QHelpEnginePlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QHelpEnginePlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QHelpEnginePlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QHelpEnginePlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QHelpEnginePlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QHelpEnginePlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8e3ddd868d8acd69bea9b8df13b60fe1814bffa9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtTools" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QHelpEnginePluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QHelpEnginePluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QHelpEnginePluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QHelpEnginePluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..87b0827b8b15bd9198f36b8b0e7b1dd90c9a3680 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QHelpEnginePluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..887cabfa47732ca7d2df79b25d5d36deec50f27c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QHelpEnginePlugin" for configuration "Debug" +set_property(TARGET Qt6::QHelpEnginePlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QHelpEnginePlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/help/helpplugind.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QHelpEnginePlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QHelpEnginePlugin "${_IMPORT_PREFIX}/plugins/help/helpplugind.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..33fde41612794822ea2dd60dc5d0fc50aad4fb46 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QHelpEnginePlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QHelpEnginePlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QHelpEnginePlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/help/helpplugin.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QHelpEnginePlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QHelpEnginePlugin "${_IMPORT_PREFIX}/plugins/help/helpplugin.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..55dd6e74615a84b54444904861da772bc09eb963 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Help/Qt6QHelpEnginePluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QHelpEnginePlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QHelpEnginePlugin +add_library(Qt6::QHelpEnginePlugin MODULE IMPORTED) + +set_target_properties(Qt6::QHelpEnginePlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Help" + QT_PLUGIN_CLASS_NAME "QHelpEnginePlugin" + QT_PLUGIN_TYPE "help" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-plugin-QHelpEnginePlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QHelpEnginePluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HostInfo/Qt6HostInfoConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HostInfo/Qt6HostInfoConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..08baa7338a8ba683cb7955bcaaf0899ee5136cdd --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6HostInfo/Qt6HostInfoConfig.cmake @@ -0,0 +1,32 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtHostInfoConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +#################################################################################### + +set(QT6_HOST_INFO_BINDIR "bin") +set(QT6_HOST_INFO_INCLUDEDIR "include") +set(QT6_HOST_INFO_LIBDIR "lib") +set(QT6_HOST_INFO_MKSPECSDIR "mkspecs") +set(QT6_HOST_INFO_ARCHDATADIR ".") +set(QT6_HOST_INFO_PLUGINSDIR "plugins") +set(QT6_HOST_INFO_LIBEXECDIR "bin") +set(QT6_HOST_INFO_QMLDIR "qml") +set(QT6_HOST_INFO_DATADIR ".") +set(QT6_HOST_INFO_DOCDIR "doc") +set(QT6_HOST_INFO_TRANSLATIONSDIR "translations") +set(QT6_HOST_INFO_SYSCONFDIR "etc/xdg") +set(QT6_HOST_INFO_EXAMPLESDIR "examples") +set(QT6_HOST_INFO_TESTSDIR "tests") +set(QT6_HOST_INFO_DESCRIPTIONSDIR "modules") +set(QT6_HOST_INFO_QMAKE_MKSPEC "win32-msvc") +set(QT6_HOST_INFO_ARCH "x86_64") +set(QT6_HOST_INFO_SUBARCHS "") +set(QT6_HOST_INFO_BUILDABI "x86_64-little_endian-lp64") +set(QT6_HOST_INFO_IS_SHARED_LIBS_BUILD "ON") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..24ec308e1d174eea376fc22c2cbe960993cff0d9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,6 @@ +# Additional target information for Qt6JpegPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::JpegPrivate) + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..422124a5dfdb1437225cad55f1f038c4527fab54 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(JpegPrivate + __qt_JpegPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6JpegPrivate_FOUND") + set("Qt6JpegPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6JpegPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6JpegPrivate) instead. + set(Qt6JpegPrivate_LIBRARIES "Qt6::JpegPrivate") + + get_target_property(_Qt6JpegPrivate_OWN_INCLUDE_DIRS + Qt6::JpegPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6JpegPrivate_OWN_INCLUDE_DIRS) + set(_Qt6JpegPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::JpegPrivatePrivate) + get_target_property(_Qt6JpegPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::JpegPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6JpegPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6JpegPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6JpegPrivate_DEFINITIONS + Qt6::JpegPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6JpegPrivate_DEFINITIONS) + set(Qt6JpegPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6JpegPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6JpegPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6JpegPrivate_COMPILE_DEFINITIONS + Qt6::JpegPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6JpegPrivate_COMPILE_DEFINITIONS) + set(Qt6JpegPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6JpegPrivate_INCLUDE_DIRS + ${_Qt6JpegPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6JpegPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6JpegPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6JpegPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6JpegPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6JpegPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6JpegPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6JpegPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6JpegPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6JpegPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6JpegPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6JpegPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6JpegPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::JpegPrivate) + qt_make_features_available(Qt6::JpegPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "JpegPrivate") + + get_target_property(_qt_module_target_type "Qt6::JpegPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::JpegPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6JpegPrivate_FOUND FALSE) + if(NOT DEFINED Qt6JpegPrivate_NOT_FOUND_MESSAGE) + set(Qt6JpegPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::JpegPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6JpegPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2459b047e23042b184e5a62a614fbfe5e29c7b5d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b58c8cfab72d3a1641398ce8a4dff00edfc76a31 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateTargets.cmake @@ -0,0 +1,124 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::JpegPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::JpegPrivate +add_library(Qt6::JpegPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::JpegPrivate PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "QT_JPEG_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtJpeg;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtJpeg/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtJpeg/6.8.1/QtJpeg>" + _qt_config_module_name "jpeg_private" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtJpeg" + _qt_module_interface_name "Jpeg" + _qt_module_is_3rdparty_header_library "TRUE" + _qt_module_skip_depends_include "TRUE" + _qt_package_name "Qt6JpegPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-bundled-3rdparty-module-JpegPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6JpegPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c59ca4f10e034e759617d2aba3afac8b40370c86 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "JpegPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e5fd6a4523ca2f0efb1ffaa7c29c0a107b92e3ff --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6JpegPrivate/Qt6JpegPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "JpegPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0d3ac9d7e226f69c6b14ff9c5a8939fc69eb4645 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6LabsAnimation +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsAnimation) +get_target_property(_qt_imported_location Qt6::LabsAnimation IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::LabsAnimation IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::LabsAnimation IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::LabsAnimation IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::LabsAnimation IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::LabsAnimation IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::LabsAnimation" for configuration "Release" +set_property(TARGET Qt6::LabsAnimation APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::LabsAnimation" for configuration "MinSizeRel" +set_property(TARGET Qt6::LabsAnimation APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::LabsAnimation PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsAnimationPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4cb653d89417b3339027715536868a59cbe7e40b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationDependencies.cmake") + _qt_internal_suggest_dependency_debugging(LabsAnimation + __qt_LabsAnimation_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6LabsAnimation_FOUND") + set("Qt6LabsAnimation_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6LabsAnimation_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6LabsAnimation) instead. + set(Qt6LabsAnimation_LIBRARIES "Qt6::LabsAnimation") + + get_target_property(_Qt6LabsAnimation_OWN_INCLUDE_DIRS + Qt6::LabsAnimation INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsAnimation_OWN_INCLUDE_DIRS) + set(_Qt6LabsAnimation_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::LabsAnimationPrivate) + get_target_property(_Qt6LabsAnimation_OWN_PRIVATE_INCLUDE_DIRS + Qt6::LabsAnimationPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsAnimation_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6LabsAnimation_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6LabsAnimation_DEFINITIONS + Qt6::LabsAnimation INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsAnimation_DEFINITIONS) + set(Qt6LabsAnimation_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6LabsAnimation_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6LabsAnimation_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6LabsAnimation_COMPILE_DEFINITIONS + Qt6::LabsAnimation INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsAnimation_COMPILE_DEFINITIONS) + set(Qt6LabsAnimation_COMPILE_DEFINITIONS "") + endif() + + set(Qt6LabsAnimation_INCLUDE_DIRS + ${_Qt6LabsAnimation_OWN_INCLUDE_DIRS}) + + set(Qt6LabsAnimation_PRIVATE_INCLUDE_DIRS + ${_Qt6LabsAnimation_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6LabsAnimation_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6LabsAnimation${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6LabsAnimation${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6LabsAnimation_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6LabsAnimation${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6LabsAnimation${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6LabsAnimation_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsAnimation_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsAnimation_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6LabsAnimation_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::LabsAnimation) + qt_make_features_available(Qt6::LabsAnimation) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "LabsAnimation") + + get_target_property(_qt_module_target_type "Qt6::LabsAnimation" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::LabsAnimation MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6LabsAnimation_FOUND FALSE) + if(NOT DEFINED Qt6LabsAnimation_NOT_FOUND_MESSAGE) + set(Qt6LabsAnimation_NOT_FOUND_MESSAGE + "Target \"Qt6::LabsAnimation\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6LabsAnimation_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..477dd33b578df2cd35ca2383489bb485fb4caf25 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..294e6253da4a016c5315e2c9f79c8264f49e7e70 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6LabsAnimation_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_LabsAnimation_third_party_deps "") + +_qt_internal_find_third_party_dependencies("LabsAnimation" __qt_LabsAnimation_third_party_deps) + +# Find Qt tool package. +set(__qt_LabsAnimation_tool_deps "") +_qt_internal_find_tool_dependencies("LabsAnimation" __qt_LabsAnimation_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_LabsAnimation_target_deps "Qt6Qml\;6.8.1;Qt6Quick\;6.8.1") +set(__qt_LabsAnimation_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("LabsAnimation" __qt_LabsAnimation_target_deps + __qt_LabsAnimation_find_dependency_paths) + +set(_Qt6LabsAnimation_MODULE_DEPENDENCIES "Qml;Quick") +set(Qt6LabsAnimation_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..86548a971244a21f7a42dc6ec4907c7013e14417 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets-debug.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsAnimation" for configuration "Debug" +set_property(TARGET Qt6::LabsAnimation APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::LabsAnimation PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6LabsAnimationd.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_DEBUG "Qt6::Qml" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6LabsAnimationd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsAnimation ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsAnimation "${_IMPORT_PREFIX}/lib/Qt6LabsAnimationd.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsAnimationd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a907be8d8c84d7e6d9592e1220f75d0b0e473d9b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets-relwithdebinfo.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsAnimation" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::LabsAnimation APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::LabsAnimation PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6LabsAnimation.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO "Qt6::Qml" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6LabsAnimation.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsAnimation ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsAnimation "${_IMPORT_PREFIX}/lib/Qt6LabsAnimation.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsAnimation.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..50e53ef96cb47652b90b285c62a2e4ced42dbe4a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationTargets.cmake @@ -0,0 +1,162 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::LabsAnimation Qt6::LabsAnimationPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::LabsAnimation +add_library(Qt6::LabsAnimation SHARED IMPORTED) + +set_target_properties(Qt6::LabsAnimation PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_LABSANIMATION_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtLabsAnimation;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::QmlPrivate;Qt6::QuickPrivate" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6labsanimation_metatypes.json>" + _qt_config_module_name "labsanimation" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtLabsAnimation" + _qt_module_interface_name "LabsAnimation" + _qt_package_name "Qt6LabsAnimation" + _qt_package_version "6.8.1" + _qt_private_module_target_name "LabsAnimationPrivate" + _qt_qml_module_installed_plugin_target "Qt6::labsanimationplugin" + _qt_qml_module_plugin_target "labsanimationplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsAnimation" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::LabsAnimationPrivate +add_library(Qt6::LabsAnimationPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::LabsAnimationPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsAnimation/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsAnimation/6.8.1/QtLabsAnimation>" + INTERFACE_LINK_LIBRARIES "Qt6::LabsAnimation" + _qt_config_module_name "labsanimation_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6LabsAnimation" + _qt_package_version "6.8.1" + _qt_public_module_target_name "LabsAnimation" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsAnimation" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsAnimationTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::QmlPrivate" "Qt6::QuickPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..635601415b0b397a531667ec2555d1e83a3ae0f4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsAnimation;LabsAnimationPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c0f7671eb69f0349235da622c1a31324844b2135 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsAnimation/Qt6LabsAnimationVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsAnimation;LabsAnimationPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..df7cba6c52352ada2adaf0d3e056dbda0ad00e5f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6LabsFolderListModel +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsFolderListModel) +get_target_property(_qt_imported_location Qt6::LabsFolderListModel IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::LabsFolderListModel IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::LabsFolderListModel IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::LabsFolderListModel IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::LabsFolderListModel IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::LabsFolderListModel IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::LabsFolderListModel" for configuration "Release" +set_property(TARGET Qt6::LabsFolderListModel APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::LabsFolderListModel" for configuration "MinSizeRel" +set_property(TARGET Qt6::LabsFolderListModel APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::LabsFolderListModel PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsFolderListModelPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d98551f6c1dfa8d85f9df55f69544caf36e752dc --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelDependencies.cmake") + _qt_internal_suggest_dependency_debugging(LabsFolderListModel + __qt_LabsFolderListModel_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6LabsFolderListModel_FOUND") + set("Qt6LabsFolderListModel_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6LabsFolderListModel_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6LabsFolderListModel) instead. + set(Qt6LabsFolderListModel_LIBRARIES "Qt6::LabsFolderListModel") + + get_target_property(_Qt6LabsFolderListModel_OWN_INCLUDE_DIRS + Qt6::LabsFolderListModel INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsFolderListModel_OWN_INCLUDE_DIRS) + set(_Qt6LabsFolderListModel_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::LabsFolderListModelPrivate) + get_target_property(_Qt6LabsFolderListModel_OWN_PRIVATE_INCLUDE_DIRS + Qt6::LabsFolderListModelPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsFolderListModel_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6LabsFolderListModel_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6LabsFolderListModel_DEFINITIONS + Qt6::LabsFolderListModel INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsFolderListModel_DEFINITIONS) + set(Qt6LabsFolderListModel_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6LabsFolderListModel_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6LabsFolderListModel_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6LabsFolderListModel_COMPILE_DEFINITIONS + Qt6::LabsFolderListModel INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsFolderListModel_COMPILE_DEFINITIONS) + set(Qt6LabsFolderListModel_COMPILE_DEFINITIONS "") + endif() + + set(Qt6LabsFolderListModel_INCLUDE_DIRS + ${_Qt6LabsFolderListModel_OWN_INCLUDE_DIRS}) + + set(Qt6LabsFolderListModel_PRIVATE_INCLUDE_DIRS + ${_Qt6LabsFolderListModel_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6LabsFolderListModel_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6LabsFolderListModel${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6LabsFolderListModel${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6LabsFolderListModel_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6LabsFolderListModel${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6LabsFolderListModel${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6LabsFolderListModel_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsFolderListModel_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsFolderListModel_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6LabsFolderListModel_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::LabsFolderListModel) + qt_make_features_available(Qt6::LabsFolderListModel) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "LabsFolderListModel") + + get_target_property(_qt_module_target_type "Qt6::LabsFolderListModel" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::LabsFolderListModel MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6LabsFolderListModel_FOUND FALSE) + if(NOT DEFINED Qt6LabsFolderListModel_NOT_FOUND_MESSAGE) + set(Qt6LabsFolderListModel_NOT_FOUND_MESSAGE + "Target \"Qt6::LabsFolderListModel\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6LabsFolderListModel_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d34475d201a5beea8d5c28ff8103735aa0511e3a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..14d7e0fe5f9f682ecfe6eca6094f002ebcbc438c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6LabsFolderListModel_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_LabsFolderListModel_third_party_deps "") + +_qt_internal_find_third_party_dependencies("LabsFolderListModel" __qt_LabsFolderListModel_third_party_deps) + +# Find Qt tool package. +set(__qt_LabsFolderListModel_tool_deps "") +_qt_internal_find_tool_dependencies("LabsFolderListModel" __qt_LabsFolderListModel_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_LabsFolderListModel_target_deps "Qt6Core\;6.8.1;Qt6Qml\;6.8.1;Qt6QmlModels\;6.8.1") +set(__qt_LabsFolderListModel_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("LabsFolderListModel" __qt_LabsFolderListModel_target_deps + __qt_LabsFolderListModel_find_dependency_paths) + +set(_Qt6LabsFolderListModel_MODULE_DEPENDENCIES "Core;Qml;QmlModels") +set(Qt6LabsFolderListModel_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ddd1d9ecf49068db8238768ad5d1d023ccc14cf2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets-debug.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsFolderListModel" for configuration "Debug" +set_property(TARGET Qt6::LabsFolderListModel APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::LabsFolderListModel PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6LabsFolderListModeld.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_DEBUG "Qt6::Qml" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6LabsFolderListModeld.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsFolderListModel ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsFolderListModel "${_IMPORT_PREFIX}/lib/Qt6LabsFolderListModeld.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsFolderListModeld.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0b3dab203f67d6029fbcb044477f0db2f6bc2649 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets-relwithdebinfo.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsFolderListModel" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::LabsFolderListModel APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::LabsFolderListModel PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6LabsFolderListModel.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO "Qt6::Qml" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6LabsFolderListModel.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsFolderListModel ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsFolderListModel "${_IMPORT_PREFIX}/lib/Qt6LabsFolderListModel.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsFolderListModel.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5b5744de00e4344a8689aff772fc919e7447a87c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelTargets.cmake @@ -0,0 +1,162 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::LabsFolderListModel Qt6::LabsFolderListModelPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::LabsFolderListModel +add_library(Qt6::LabsFolderListModel SHARED IMPORTED) + +set_target_properties(Qt6::LabsFolderListModel PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_LABSFOLDERLISTMODEL_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtLabsFolderListModel;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::QmlPrivate;Qt6::QmlModelsPrivate" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6labsfolderlistmodel_metatypes.json>" + _qt_config_module_name "labsfolderlistmodel" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtLabsFolderListModel" + _qt_module_interface_name "LabsFolderListModel" + _qt_package_name "Qt6LabsFolderListModel" + _qt_package_version "6.8.1" + _qt_private_module_target_name "LabsFolderListModelPrivate" + _qt_qml_module_installed_plugin_target "Qt6::qmlfolderlistmodelplugin" + _qt_qml_module_plugin_target "qmlfolderlistmodelplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsFolderListModel" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::LabsFolderListModelPrivate +add_library(Qt6::LabsFolderListModelPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::LabsFolderListModelPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsFolderListModel/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsFolderListModel/6.8.1/QtLabsFolderListModel>" + INTERFACE_LINK_LIBRARIES "Qt6::LabsFolderListModel" + _qt_config_module_name "labsfolderlistmodel_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6LabsFolderListModel" + _qt_package_version "6.8.1" + _qt_public_module_target_name "LabsFolderListModel" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsFolderListModel" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsFolderListModelTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::QmlPrivate" "Qt6::QmlModelsPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..be7aa1245f879c7b268030bea8c1e8d5b4c7170b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsFolderListModel;LabsFolderListModelPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..57956cc3d6bff30cf9e61c2addbd6a05fc344def --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsFolderListModel/Qt6LabsFolderListModelVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsFolderListModel;LabsFolderListModelPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4531a7140b33de16c32157d8e946eb2ac5c19807 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6LabsPlatform +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsPlatform) +get_target_property(_qt_imported_location Qt6::LabsPlatform IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::LabsPlatform IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::LabsPlatform IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::LabsPlatform IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::LabsPlatform IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::LabsPlatform IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::LabsPlatform" for configuration "Release" +set_property(TARGET Qt6::LabsPlatform APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::LabsPlatform" for configuration "MinSizeRel" +set_property(TARGET Qt6::LabsPlatform APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::LabsPlatform PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsPlatformPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..897d2459d1e1627c6ed70600a6ad4a32df5cbcaa --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformDependencies.cmake") + _qt_internal_suggest_dependency_debugging(LabsPlatform + __qt_LabsPlatform_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6LabsPlatform_FOUND") + set("Qt6LabsPlatform_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6LabsPlatform_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6LabsPlatform) instead. + set(Qt6LabsPlatform_LIBRARIES "Qt6::LabsPlatform") + + get_target_property(_Qt6LabsPlatform_OWN_INCLUDE_DIRS + Qt6::LabsPlatform INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsPlatform_OWN_INCLUDE_DIRS) + set(_Qt6LabsPlatform_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::LabsPlatformPrivate) + get_target_property(_Qt6LabsPlatform_OWN_PRIVATE_INCLUDE_DIRS + Qt6::LabsPlatformPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsPlatform_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6LabsPlatform_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6LabsPlatform_DEFINITIONS + Qt6::LabsPlatform INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsPlatform_DEFINITIONS) + set(Qt6LabsPlatform_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6LabsPlatform_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6LabsPlatform_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6LabsPlatform_COMPILE_DEFINITIONS + Qt6::LabsPlatform INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsPlatform_COMPILE_DEFINITIONS) + set(Qt6LabsPlatform_COMPILE_DEFINITIONS "") + endif() + + set(Qt6LabsPlatform_INCLUDE_DIRS + ${_Qt6LabsPlatform_OWN_INCLUDE_DIRS}) + + set(Qt6LabsPlatform_PRIVATE_INCLUDE_DIRS + ${_Qt6LabsPlatform_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6LabsPlatform_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6LabsPlatform${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6LabsPlatform${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6LabsPlatform_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6LabsPlatform${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6LabsPlatform${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6LabsPlatform_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsPlatform_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsPlatform_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6LabsPlatform_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::LabsPlatform) + qt_make_features_available(Qt6::LabsPlatform) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "LabsPlatform") + + get_target_property(_qt_module_target_type "Qt6::LabsPlatform" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::LabsPlatform MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6LabsPlatform_FOUND FALSE) + if(NOT DEFINED Qt6LabsPlatform_NOT_FOUND_MESSAGE) + set(Qt6LabsPlatform_NOT_FOUND_MESSAGE + "Target \"Qt6::LabsPlatform\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6LabsPlatform_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..85cc0896c21a213f99e07838ba58d8661241c26d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fc5583015bab11dcd7a8a3eca288cc294c7606e9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6LabsPlatform_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_LabsPlatform_third_party_deps "") + +_qt_internal_find_third_party_dependencies("LabsPlatform" __qt_LabsPlatform_third_party_deps) + +# Find Qt tool package. +set(__qt_LabsPlatform_tool_deps "") +_qt_internal_find_tool_dependencies("LabsPlatform" __qt_LabsPlatform_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_LabsPlatform_target_deps "Qt6Core\;6.8.1;Qt6Gui\;6.8.1;Qt6Qml\;6.8.1;Qt6Quick\;6.8.1;Qt6QuickTemplates2\;6.8.1;Qt6Widgets\;6.8.1") +set(__qt_LabsPlatform_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("LabsPlatform" __qt_LabsPlatform_target_deps + __qt_LabsPlatform_find_dependency_paths) + +set(_Qt6LabsPlatform_MODULE_DEPENDENCIES "Core;Gui;Qml;Quick;QuickTemplates2;Widgets") +set(Qt6LabsPlatform_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d6da187d89fa5a127917c842b14b9e435c75253e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets-debug.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsPlatform" for configuration "Debug" +set_property(TARGET Qt6::LabsPlatform APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::LabsPlatform PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6LabsPlatformd.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_DEBUG "Qt6::Qml;Qt6::Widgets" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6LabsPlatformd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsPlatform ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsPlatform "${_IMPORT_PREFIX}/lib/Qt6LabsPlatformd.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsPlatformd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..21af39eb2c75529712dc8afbbeb31e4813e657fe --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets-relwithdebinfo.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsPlatform" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::LabsPlatform APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::LabsPlatform PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6LabsPlatform.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO "Qt6::Qml;Qt6::Widgets" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6LabsPlatform.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsPlatform ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsPlatform "${_IMPORT_PREFIX}/lib/Qt6LabsPlatform.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsPlatform.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b70950e5cd9092a6998a34aa698cabf44a011309 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformTargets.cmake @@ -0,0 +1,145 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::LabsPlatform Qt6::LabsPlatformPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::LabsPlatform +add_library(Qt6::LabsPlatform SHARED IMPORTED) + +set_target_properties(Qt6::LabsPlatform PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_LABSPLATFORM_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtLabsPlatform;${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6labsplatform_metatypes.json>" + _qt_config_module_name "labsplatform" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtLabsPlatform" + _qt_module_interface_name "LabsPlatform" + _qt_package_name "Qt6LabsPlatform" + _qt_package_version "6.8.1" + _qt_private_module_target_name "LabsPlatformPrivate" + _qt_qml_module_installed_plugin_target "Qt6::LabsPlatformplugin" + _qt_qml_module_plugin_target "LabsPlatformplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsPlatform" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::LabsPlatformPrivate +add_library(Qt6::LabsPlatformPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::LabsPlatformPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsPlatform/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsPlatform/6.8.1/QtLabsPlatform>" + INTERFACE_LINK_LIBRARIES "Qt6::LabsPlatform" + _qt_config_module_name "labsplatform_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6LabsPlatform" + _qt_package_version "6.8.1" + _qt_public_module_target_name "LabsPlatform" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsPlatform" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsPlatformTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3107c273d7e40809a6aeafeb42f312a26c7312db --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsPlatform;LabsPlatformPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6215052a423ad165cc11e6d600fe955c7d5c99c2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsPlatform/Qt6LabsPlatformVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsPlatform;LabsPlatformPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c6ff61cff034e0e1cbfb67896abcea96def73b06 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6LabsQmlModels +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsQmlModels) +get_target_property(_qt_imported_location Qt6::LabsQmlModels IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::LabsQmlModels IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::LabsQmlModels IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::LabsQmlModels IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::LabsQmlModels IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::LabsQmlModels IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::LabsQmlModels" for configuration "Release" +set_property(TARGET Qt6::LabsQmlModels APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::LabsQmlModels" for configuration "MinSizeRel" +set_property(TARGET Qt6::LabsQmlModels APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::LabsQmlModels PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsQmlModelsPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f3caca122074aaef437cd451d7641c67facaced6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsDependencies.cmake") + _qt_internal_suggest_dependency_debugging(LabsQmlModels + __qt_LabsQmlModels_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6LabsQmlModels_FOUND") + set("Qt6LabsQmlModels_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6LabsQmlModels_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6LabsQmlModels) instead. + set(Qt6LabsQmlModels_LIBRARIES "Qt6::LabsQmlModels") + + get_target_property(_Qt6LabsQmlModels_OWN_INCLUDE_DIRS + Qt6::LabsQmlModels INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsQmlModels_OWN_INCLUDE_DIRS) + set(_Qt6LabsQmlModels_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::LabsQmlModelsPrivate) + get_target_property(_Qt6LabsQmlModels_OWN_PRIVATE_INCLUDE_DIRS + Qt6::LabsQmlModelsPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsQmlModels_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6LabsQmlModels_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6LabsQmlModels_DEFINITIONS + Qt6::LabsQmlModels INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsQmlModels_DEFINITIONS) + set(Qt6LabsQmlModels_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6LabsQmlModels_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6LabsQmlModels_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6LabsQmlModels_COMPILE_DEFINITIONS + Qt6::LabsQmlModels INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsQmlModels_COMPILE_DEFINITIONS) + set(Qt6LabsQmlModels_COMPILE_DEFINITIONS "") + endif() + + set(Qt6LabsQmlModels_INCLUDE_DIRS + ${_Qt6LabsQmlModels_OWN_INCLUDE_DIRS}) + + set(Qt6LabsQmlModels_PRIVATE_INCLUDE_DIRS + ${_Qt6LabsQmlModels_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6LabsQmlModels_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6LabsQmlModels${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6LabsQmlModels${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6LabsQmlModels_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6LabsQmlModels${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6LabsQmlModels${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6LabsQmlModels_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsQmlModels_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsQmlModels_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6LabsQmlModels_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::LabsQmlModels) + qt_make_features_available(Qt6::LabsQmlModels) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "LabsQmlModels") + + get_target_property(_qt_module_target_type "Qt6::LabsQmlModels" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::LabsQmlModels MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6LabsQmlModels_FOUND FALSE) + if(NOT DEFINED Qt6LabsQmlModels_NOT_FOUND_MESSAGE) + set(Qt6LabsQmlModels_NOT_FOUND_MESSAGE + "Target \"Qt6::LabsQmlModels\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6LabsQmlModels_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ae5f2ea7d838787637251e73095fd90071f4da36 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fc596b3079e1ed01d6c414fed4b7c003c6458199 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6LabsQmlModels_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_LabsQmlModels_third_party_deps "") + +_qt_internal_find_third_party_dependencies("LabsQmlModels" __qt_LabsQmlModels_third_party_deps) + +# Find Qt tool package. +set(__qt_LabsQmlModels_tool_deps "") +_qt_internal_find_tool_dependencies("LabsQmlModels" __qt_LabsQmlModels_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_LabsQmlModels_target_deps "Qt6QmlModels\;6.8.1;Qt6Qml\;6.8.1") +set(__qt_LabsQmlModels_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("LabsQmlModels" __qt_LabsQmlModels_target_deps + __qt_LabsQmlModels_find_dependency_paths) + +set(_Qt6LabsQmlModels_MODULE_DEPENDENCIES "QmlModels;Qml") +set(Qt6LabsQmlModels_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9d070fe1c1f2552da61e1fd6e87319869bb008a8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets-debug.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsQmlModels" for configuration "Debug" +set_property(TARGET Qt6::LabsQmlModels APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::LabsQmlModels PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6LabsQmlModelsd.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_DEBUG "Qt6::Qml" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6LabsQmlModelsd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsQmlModels ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsQmlModels "${_IMPORT_PREFIX}/lib/Qt6LabsQmlModelsd.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsQmlModelsd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a4578fa27e26726dccee50c67a4ca4814c4d26d3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets-relwithdebinfo.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsQmlModels" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::LabsQmlModels APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::LabsQmlModels PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6LabsQmlModels.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO "Qt6::Qml" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6LabsQmlModels.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsQmlModels ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsQmlModels "${_IMPORT_PREFIX}/lib/Qt6LabsQmlModels.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsQmlModels.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..735c11b0c8c52a4f81c4cfd6ea1cb55d7c5063f8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsTargets.cmake @@ -0,0 +1,162 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::LabsQmlModels Qt6::LabsQmlModelsPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::LabsQmlModels +add_library(Qt6::LabsQmlModels SHARED IMPORTED) + +set_target_properties(Qt6::LabsQmlModels PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_LABSQMLMODELS_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtLabsQmlModels;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::QmlModelsPrivate;Qt6::QmlPrivate" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6labsqmlmodels_metatypes.json>" + _qt_config_module_name "labsqmlmodels" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtLabsQmlModels" + _qt_module_interface_name "LabsQmlModels" + _qt_package_name "Qt6LabsQmlModels" + _qt_package_version "6.8.1" + _qt_private_module_target_name "LabsQmlModelsPrivate" + _qt_qml_module_installed_plugin_target "Qt6::labsmodelsplugin" + _qt_qml_module_plugin_target "labsmodelsplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsQmlModels" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::LabsQmlModelsPrivate +add_library(Qt6::LabsQmlModelsPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::LabsQmlModelsPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsQmlModels/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsQmlModels/6.8.1/QtLabsQmlModels>" + INTERFACE_LINK_LIBRARIES "Qt6::LabsQmlModels" + _qt_config_module_name "labsqmlmodels_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6LabsQmlModels" + _qt_package_version "6.8.1" + _qt_public_module_target_name "LabsQmlModels" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsQmlModels" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsQmlModelsTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::QmlModelsPrivate" "Qt6::QmlPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3ae6da8949d05d21d47529b60ee5a7d4e4482e44 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsQmlModels;LabsQmlModelsPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bd0d5774d23957619587fe1160a85bb41183329c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsQmlModels/Qt6LabsQmlModelsVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsQmlModels;LabsQmlModelsPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d1c92efd579bd2194af6857ddfa853d64178b43a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6LabsSettings +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsSettings) +get_target_property(_qt_imported_location Qt6::LabsSettings IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::LabsSettings IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::LabsSettings IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::LabsSettings IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::LabsSettings IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::LabsSettings IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::LabsSettings" for configuration "Release" +set_property(TARGET Qt6::LabsSettings APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::LabsSettings" for configuration "MinSizeRel" +set_property(TARGET Qt6::LabsSettings APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::LabsSettings PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsSettingsPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7d1c760770724599cb616f336c6f640e9b6280d3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsDependencies.cmake") + _qt_internal_suggest_dependency_debugging(LabsSettings + __qt_LabsSettings_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6LabsSettings_FOUND") + set("Qt6LabsSettings_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6LabsSettings_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6LabsSettings) instead. + set(Qt6LabsSettings_LIBRARIES "Qt6::LabsSettings") + + get_target_property(_Qt6LabsSettings_OWN_INCLUDE_DIRS + Qt6::LabsSettings INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsSettings_OWN_INCLUDE_DIRS) + set(_Qt6LabsSettings_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::LabsSettingsPrivate) + get_target_property(_Qt6LabsSettings_OWN_PRIVATE_INCLUDE_DIRS + Qt6::LabsSettingsPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsSettings_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6LabsSettings_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6LabsSettings_DEFINITIONS + Qt6::LabsSettings INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsSettings_DEFINITIONS) + set(Qt6LabsSettings_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6LabsSettings_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6LabsSettings_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6LabsSettings_COMPILE_DEFINITIONS + Qt6::LabsSettings INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsSettings_COMPILE_DEFINITIONS) + set(Qt6LabsSettings_COMPILE_DEFINITIONS "") + endif() + + set(Qt6LabsSettings_INCLUDE_DIRS + ${_Qt6LabsSettings_OWN_INCLUDE_DIRS}) + + set(Qt6LabsSettings_PRIVATE_INCLUDE_DIRS + ${_Qt6LabsSettings_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6LabsSettings_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6LabsSettings${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6LabsSettings${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6LabsSettings_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6LabsSettings${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6LabsSettings${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6LabsSettings_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsSettings_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsSettings_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6LabsSettings_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::LabsSettings) + qt_make_features_available(Qt6::LabsSettings) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "LabsSettings") + + get_target_property(_qt_module_target_type "Qt6::LabsSettings" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::LabsSettings MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6LabsSettings_FOUND FALSE) + if(NOT DEFINED Qt6LabsSettings_NOT_FOUND_MESSAGE) + set(Qt6LabsSettings_NOT_FOUND_MESSAGE + "Target \"Qt6::LabsSettings\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6LabsSettings_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..02fddc477f23b5334fa94ef4157b1a294bb188af --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..92ad5e05cc9d2f69998295c995a6b9dc9a469e4c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6LabsSettings_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_LabsSettings_third_party_deps "") + +_qt_internal_find_third_party_dependencies("LabsSettings" __qt_LabsSettings_third_party_deps) + +# Find Qt tool package. +set(__qt_LabsSettings_tool_deps "") +_qt_internal_find_tool_dependencies("LabsSettings" __qt_LabsSettings_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_LabsSettings_target_deps "Qt6Core\;6.8.1;Qt6Qml\;6.8.1") +set(__qt_LabsSettings_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("LabsSettings" __qt_LabsSettings_target_deps + __qt_LabsSettings_find_dependency_paths) + +set(_Qt6LabsSettings_MODULE_DEPENDENCIES "Core;Qml") +set(Qt6LabsSettings_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6e2abfb84e62c95074ad20dbd88774f2df1f7c06 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsSettings" for configuration "Debug" +set_property(TARGET Qt6::LabsSettings APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::LabsSettings PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6LabsSettingsd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6LabsSettingsd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsSettings ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsSettings "${_IMPORT_PREFIX}/lib/Qt6LabsSettingsd.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsSettingsd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e5456059cec1c7d346062592ffea12c8dd308f69 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsSettings" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::LabsSettings APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::LabsSettings PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6LabsSettings.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6LabsSettings.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsSettings ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsSettings "${_IMPORT_PREFIX}/lib/Qt6LabsSettings.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsSettings.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..60bdfcbbb61b1410c319c4d045b1abe8730c0345 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsTargets.cmake @@ -0,0 +1,162 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::LabsSettings Qt6::LabsSettingsPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::LabsSettings +add_library(Qt6::LabsSettings SHARED IMPORTED) + +set_target_properties(Qt6::LabsSettings PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_LABSSETTINGS_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtLabsSettings;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::Qml" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6labssettings_metatypes.json>" + _qt_config_module_name "labssettings" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtLabsSettings" + _qt_module_interface_name "LabsSettings" + _qt_package_name "Qt6LabsSettings" + _qt_package_version "6.8.1" + _qt_private_module_target_name "LabsSettingsPrivate" + _qt_qml_module_installed_plugin_target "Qt6::qmlsettingsplugin" + _qt_qml_module_plugin_target "qmlsettingsplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsSettings" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::LabsSettingsPrivate +add_library(Qt6::LabsSettingsPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::LabsSettingsPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsSettings/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsSettings/6.8.1/QtLabsSettings>" + INTERFACE_LINK_LIBRARIES "Qt6::LabsSettings" + _qt_config_module_name "labssettings_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6LabsSettings" + _qt_package_version "6.8.1" + _qt_public_module_target_name "LabsSettings" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsSettings" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSettingsTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Qml" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..35a765f8dee53d2f851624b18703f223b87cc9c9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsSettings;LabsSettingsPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..70917aaa77735759d68bfb9c1ef985d13bc62d1c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSettings/Qt6LabsSettingsVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsSettings;LabsSettingsPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ae4933acfde1ebf6504288e7dc608c2a169faf0b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6LabsSharedImage +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsSharedImage) +get_target_property(_qt_imported_location Qt6::LabsSharedImage IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::LabsSharedImage IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::LabsSharedImage IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::LabsSharedImage IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::LabsSharedImage IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::LabsSharedImage IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::LabsSharedImage" for configuration "Release" +set_property(TARGET Qt6::LabsSharedImage APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::LabsSharedImage" for configuration "MinSizeRel" +set_property(TARGET Qt6::LabsSharedImage APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::LabsSharedImage PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsSharedImagePrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2908df629da867a3d31d8ff83c1160a07b06124a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageDependencies.cmake") + _qt_internal_suggest_dependency_debugging(LabsSharedImage + __qt_LabsSharedImage_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6LabsSharedImage_FOUND") + set("Qt6LabsSharedImage_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6LabsSharedImage_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6LabsSharedImage) instead. + set(Qt6LabsSharedImage_LIBRARIES "Qt6::LabsSharedImage") + + get_target_property(_Qt6LabsSharedImage_OWN_INCLUDE_DIRS + Qt6::LabsSharedImage INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsSharedImage_OWN_INCLUDE_DIRS) + set(_Qt6LabsSharedImage_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::LabsSharedImagePrivate) + get_target_property(_Qt6LabsSharedImage_OWN_PRIVATE_INCLUDE_DIRS + Qt6::LabsSharedImagePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsSharedImage_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6LabsSharedImage_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6LabsSharedImage_DEFINITIONS + Qt6::LabsSharedImage INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsSharedImage_DEFINITIONS) + set(Qt6LabsSharedImage_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6LabsSharedImage_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6LabsSharedImage_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6LabsSharedImage_COMPILE_DEFINITIONS + Qt6::LabsSharedImage INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsSharedImage_COMPILE_DEFINITIONS) + set(Qt6LabsSharedImage_COMPILE_DEFINITIONS "") + endif() + + set(Qt6LabsSharedImage_INCLUDE_DIRS + ${_Qt6LabsSharedImage_OWN_INCLUDE_DIRS}) + + set(Qt6LabsSharedImage_PRIVATE_INCLUDE_DIRS + ${_Qt6LabsSharedImage_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6LabsSharedImage_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6LabsSharedImage${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6LabsSharedImage${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6LabsSharedImage_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6LabsSharedImage${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6LabsSharedImage${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6LabsSharedImage_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsSharedImage_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsSharedImage_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6LabsSharedImage_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::LabsSharedImage) + qt_make_features_available(Qt6::LabsSharedImage) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImagePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImagePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "LabsSharedImage") + + get_target_property(_qt_module_target_type "Qt6::LabsSharedImage" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::LabsSharedImage MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6LabsSharedImage_FOUND FALSE) + if(NOT DEFINED Qt6LabsSharedImage_NOT_FOUND_MESSAGE) + set(Qt6LabsSharedImage_NOT_FOUND_MESSAGE + "Target \"Qt6::LabsSharedImage\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6LabsSharedImage_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d3bdca82fd2026b84a9ac52c0f7ad08eefc6daf4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..471f460f8703b40a93f0fecc5b8a36641e3ede64 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6LabsSharedImage_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_LabsSharedImage_third_party_deps "") + +_qt_internal_find_third_party_dependencies("LabsSharedImage" __qt_LabsSharedImage_third_party_deps) + +# Find Qt tool package. +set(__qt_LabsSharedImage_tool_deps "") +_qt_internal_find_tool_dependencies("LabsSharedImage" __qt_LabsSharedImage_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_LabsSharedImage_target_deps "Qt6Core\;6.8.1;Qt6Gui\;6.8.1;Qt6Quick\;6.8.1") +set(__qt_LabsSharedImage_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("LabsSharedImage" __qt_LabsSharedImage_target_deps + __qt_LabsSharedImage_find_dependency_paths) + +set(_Qt6LabsSharedImage_MODULE_DEPENDENCIES "Core;Gui;Quick") +set(Qt6LabsSharedImage_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b8e1443dfffe15f5f2d0cc15dd674a271b18e08d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets-debug.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsSharedImage" for configuration "Debug" +set_property(TARGET Qt6::LabsSharedImage APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::LabsSharedImage PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6LabsSharedImaged.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_DEBUG "Qt6::Qml" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6LabsSharedImaged.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsSharedImage ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsSharedImage "${_IMPORT_PREFIX}/lib/Qt6LabsSharedImaged.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsSharedImaged.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2188af58ac01d2f3a5ffd6d7ea04863bc2751686 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets-relwithdebinfo.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsSharedImage" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::LabsSharedImage APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::LabsSharedImage PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6LabsSharedImage.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO "Qt6::Qml" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6LabsSharedImage.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsSharedImage ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsSharedImage "${_IMPORT_PREFIX}/lib/Qt6LabsSharedImage.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsSharedImage.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6a90a0e67290e098b4c1b6d5ab2d244e55e36aff --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageTargets.cmake @@ -0,0 +1,162 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::LabsSharedImage Qt6::LabsSharedImagePrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::LabsSharedImage +add_library(Qt6::LabsSharedImage SHARED IMPORTED) + +set_target_properties(Qt6::LabsSharedImage PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_LABSSHAREDIMAGE_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtLabsSharedImage;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::GuiPrivate;Qt6::QuickPrivate" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6labssharedimage_metatypes.json>" + _qt_config_module_name "labssharedimage" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtLabsSharedImage" + _qt_module_interface_name "LabsSharedImage" + _qt_package_name "Qt6LabsSharedImage" + _qt_package_version "6.8.1" + _qt_private_module_target_name "LabsSharedImagePrivate" + _qt_qml_module_installed_plugin_target "Qt6::sharedimageplugin" + _qt_qml_module_plugin_target "sharedimageplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsSharedImage" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::LabsSharedImagePrivate +add_library(Qt6::LabsSharedImagePrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::LabsSharedImagePrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsSharedImage/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsSharedImage/6.8.1/QtLabsSharedImage>" + INTERFACE_LINK_LIBRARIES "Qt6::LabsSharedImage" + _qt_config_module_name "labssharedimage_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6LabsSharedImage" + _qt_package_version "6.8.1" + _qt_public_module_target_name "LabsSharedImage" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsSharedImage" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsSharedImageTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::QuickPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e888b03e2ae3295c90c014b2ddfb853e86d6149a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsSharedImage;LabsSharedImagePrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d0165aa19b35a497a2e78c843ca398b4e23e6d43 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsSharedImage/Qt6LabsSharedImageVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsSharedImage;LabsSharedImagePrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e0704d3bea35274144ce2e1703b57e611253ed6d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6LabsWavefrontMesh +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsWavefrontMesh) +get_target_property(_qt_imported_location Qt6::LabsWavefrontMesh IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::LabsWavefrontMesh IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::LabsWavefrontMesh IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::LabsWavefrontMesh IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::LabsWavefrontMesh IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::LabsWavefrontMesh IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::LabsWavefrontMesh" for configuration "Release" +set_property(TARGET Qt6::LabsWavefrontMesh APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::LabsWavefrontMesh" for configuration "MinSizeRel" +set_property(TARGET Qt6::LabsWavefrontMesh APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::LabsWavefrontMesh PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::LabsWavefrontMeshPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ba969a23a325b9665a1fd86e375b74caceda38d1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshDependencies.cmake") + _qt_internal_suggest_dependency_debugging(LabsWavefrontMesh + __qt_LabsWavefrontMesh_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6LabsWavefrontMesh_FOUND") + set("Qt6LabsWavefrontMesh_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6LabsWavefrontMesh_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6LabsWavefrontMesh) instead. + set(Qt6LabsWavefrontMesh_LIBRARIES "Qt6::LabsWavefrontMesh") + + get_target_property(_Qt6LabsWavefrontMesh_OWN_INCLUDE_DIRS + Qt6::LabsWavefrontMesh INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsWavefrontMesh_OWN_INCLUDE_DIRS) + set(_Qt6LabsWavefrontMesh_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::LabsWavefrontMeshPrivate) + get_target_property(_Qt6LabsWavefrontMesh_OWN_PRIVATE_INCLUDE_DIRS + Qt6::LabsWavefrontMeshPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6LabsWavefrontMesh_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6LabsWavefrontMesh_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6LabsWavefrontMesh_DEFINITIONS + Qt6::LabsWavefrontMesh INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsWavefrontMesh_DEFINITIONS) + set(Qt6LabsWavefrontMesh_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6LabsWavefrontMesh_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6LabsWavefrontMesh_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6LabsWavefrontMesh_COMPILE_DEFINITIONS + Qt6::LabsWavefrontMesh INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6LabsWavefrontMesh_COMPILE_DEFINITIONS) + set(Qt6LabsWavefrontMesh_COMPILE_DEFINITIONS "") + endif() + + set(Qt6LabsWavefrontMesh_INCLUDE_DIRS + ${_Qt6LabsWavefrontMesh_OWN_INCLUDE_DIRS}) + + set(Qt6LabsWavefrontMesh_PRIVATE_INCLUDE_DIRS + ${_Qt6LabsWavefrontMesh_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6LabsWavefrontMesh_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6LabsWavefrontMesh${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6LabsWavefrontMesh${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6LabsWavefrontMesh_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6LabsWavefrontMesh${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6LabsWavefrontMesh${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6LabsWavefrontMesh_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsWavefrontMesh_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6LabsWavefrontMesh_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6LabsWavefrontMesh_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::LabsWavefrontMesh) + qt_make_features_available(Qt6::LabsWavefrontMesh) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "LabsWavefrontMesh") + + get_target_property(_qt_module_target_type "Qt6::LabsWavefrontMesh" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::LabsWavefrontMesh MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6LabsWavefrontMesh_FOUND FALSE) + if(NOT DEFINED Qt6LabsWavefrontMesh_NOT_FOUND_MESSAGE) + set(Qt6LabsWavefrontMesh_NOT_FOUND_MESSAGE + "Target \"Qt6::LabsWavefrontMesh\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6LabsWavefrontMesh_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..17215f5ce63eb4401a1aa05eccdfe313ebbe1d35 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3f825bef3b487c133b7d2773a59054bb0ebdca7a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6LabsWavefrontMesh_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_LabsWavefrontMesh_third_party_deps "") + +_qt_internal_find_third_party_dependencies("LabsWavefrontMesh" __qt_LabsWavefrontMesh_third_party_deps) + +# Find Qt tool package. +set(__qt_LabsWavefrontMesh_tool_deps "") +_qt_internal_find_tool_dependencies("LabsWavefrontMesh" __qt_LabsWavefrontMesh_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_LabsWavefrontMesh_target_deps "Qt6Core\;6.8.1;Qt6Gui\;6.8.1;Qt6Quick\;6.8.1") +set(__qt_LabsWavefrontMesh_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("LabsWavefrontMesh" __qt_LabsWavefrontMesh_target_deps + __qt_LabsWavefrontMesh_find_dependency_paths) + +set(_Qt6LabsWavefrontMesh_MODULE_DEPENDENCIES "Core;Gui;Quick") +set(Qt6LabsWavefrontMesh_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6be78a4970043ae7a8a162affd895e67da20450e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets-debug.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsWavefrontMesh" for configuration "Debug" +set_property(TARGET Qt6::LabsWavefrontMesh APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::LabsWavefrontMesh PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6LabsWavefrontMeshd.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_DEBUG "Qt6::Qml" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6LabsWavefrontMeshd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsWavefrontMesh ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsWavefrontMesh "${_IMPORT_PREFIX}/lib/Qt6LabsWavefrontMeshd.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsWavefrontMeshd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b5104d2d8c8172d2f6e0aacdc91eea5a5e9cf6b1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets-relwithdebinfo.cmake @@ -0,0 +1,20 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::LabsWavefrontMesh" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::LabsWavefrontMesh APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::LabsWavefrontMesh PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6LabsWavefrontMesh.lib" + IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO "Qt6::Qml" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6LabsWavefrontMesh.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::LabsWavefrontMesh ) +list(APPEND _cmake_import_check_files_for_Qt6::LabsWavefrontMesh "${_IMPORT_PREFIX}/lib/Qt6LabsWavefrontMesh.lib" "${_IMPORT_PREFIX}/bin/Qt6LabsWavefrontMesh.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..45925ef5516d62a72d46323cddf49739610946e0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshTargets.cmake @@ -0,0 +1,162 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::LabsWavefrontMesh Qt6::LabsWavefrontMeshPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::LabsWavefrontMesh +add_library(Qt6::LabsWavefrontMesh SHARED IMPORTED) + +set_target_properties(Qt6::LabsWavefrontMesh PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_LABSWAVEFRONTMESH_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtLabsWavefrontMesh;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::GuiPrivate;Qt6::QuickPrivate" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6labswavefrontmesh_metatypes.json>" + _qt_config_module_name "labswavefrontmesh" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtLabsWavefrontMesh" + _qt_module_interface_name "LabsWavefrontMesh" + _qt_package_name "Qt6LabsWavefrontMesh" + _qt_package_version "6.8.1" + _qt_private_module_target_name "LabsWavefrontMeshPrivate" + _qt_qml_module_installed_plugin_target "Qt6::qmlwavefrontmeshplugin" + _qt_qml_module_plugin_target "qmlwavefrontmeshplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsWavefrontMesh" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::LabsWavefrontMeshPrivate +add_library(Qt6::LabsWavefrontMeshPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::LabsWavefrontMeshPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsWavefrontMesh/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtLabsWavefrontMesh/6.8.1/QtLabsWavefrontMesh>" + INTERFACE_LINK_LIBRARIES "Qt6::LabsWavefrontMesh" + _qt_config_module_name "labswavefrontmesh_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6LabsWavefrontMesh" + _qt_package_version "6.8.1" + _qt_public_module_target_name "LabsWavefrontMesh" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-LabsWavefrontMesh" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LabsWavefrontMeshTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::QuickPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b094464753fdfc2b4ce0e39beaedd4281d3b9f06 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsWavefrontMesh;LabsWavefrontMeshPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b5fafe79d77ccfdc766d4ed4f090c89c0ff31727 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LabsWavefrontMesh/Qt6LabsWavefrontMeshVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "LabsWavefrontMesh;LabsWavefrontMeshPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e2860aa71d8788f3861035aad910703b7e232928 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistAdditionalTargetInfo.cmake @@ -0,0 +1,6 @@ +# Additional target information for Qt6Linguist +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::Linguist) + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1c38fafe76f570cd8d12686ad94c1cda23fccc61 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistDependencies.cmake") + _qt_internal_suggest_dependency_debugging(Linguist + __qt_Linguist_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6Linguist_FOUND") + set("Qt6Linguist_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6Linguist_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6Linguist) instead. + set(Qt6Linguist_LIBRARIES "Qt6::Linguist") + + get_target_property(_Qt6Linguist_OWN_INCLUDE_DIRS + Qt6::Linguist INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Linguist_OWN_INCLUDE_DIRS) + set(_Qt6Linguist_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::LinguistPrivate) + get_target_property(_Qt6Linguist_OWN_PRIVATE_INCLUDE_DIRS + Qt6::LinguistPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Linguist_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6Linguist_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6Linguist_DEFINITIONS + Qt6::Linguist INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Linguist_DEFINITIONS) + set(Qt6Linguist_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6Linguist_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6Linguist_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6Linguist_COMPILE_DEFINITIONS + Qt6::Linguist INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Linguist_COMPILE_DEFINITIONS) + set(Qt6Linguist_COMPILE_DEFINITIONS "") + endif() + + set(Qt6Linguist_INCLUDE_DIRS + ${_Qt6Linguist_OWN_INCLUDE_DIRS}) + + set(Qt6Linguist_PRIVATE_INCLUDE_DIRS + ${_Qt6Linguist_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6Linguist_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6Linguist${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6Linguist${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6Linguist_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6Linguist${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6Linguist${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6Linguist_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Linguist_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Linguist_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6Linguist_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::Linguist) + qt_make_features_available(Qt6::Linguist) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Linguist") + + get_target_property(_qt_module_target_type "Qt6::Linguist" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::Linguist MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6Linguist_FOUND FALSE) + if(NOT DEFINED Qt6Linguist_NOT_FOUND_MESSAGE) + set(Qt6Linguist_NOT_FOUND_MESSAGE + "Target \"Qt6::Linguist\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6Linguist_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b15dd38cb071c5b248369991b4f6bf940a0f2ae1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..99f52f7899dd0836fc43f77c694bc98ee0982e4a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6Linguist_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_Linguist_third_party_deps "") + +_qt_internal_find_third_party_dependencies("Linguist" __qt_Linguist_third_party_deps) + +# Find Qt tool package. +set(__qt_Linguist_tool_deps "Qt6LinguistTools\;6.8.1") +_qt_internal_find_tool_dependencies("Linguist" __qt_Linguist_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_Linguist_target_deps "") +set(__qt_Linguist_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("Linguist" __qt_Linguist_target_deps + __qt_Linguist_find_dependency_paths) + +set(_Qt6Linguist_MODULE_DEPENDENCIES "") +set(Qt6Linguist_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..94628902bf05c3fce568445118205c1d4fe9e2a4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistTargets.cmake @@ -0,0 +1,119 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Linguist) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Linguist +add_library(Qt6::Linguist INTERFACE IMPORTED) + +set_target_properties(Qt6::Linguist PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "QT_LINGUIST_LIB" + _qt_config_module_name "linguist" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "OFF" + _qt_module_interface_name "Linguist" + _qt_package_name "Qt6Linguist" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-module-Linguist" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..feb56cfccbfb36dba3b19e4233bfc88e715fe870 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Linguist") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e9068edacd2e8584bee37c61d14561b1e80342cb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Linguist/Qt6LinguistVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Linguist") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/GenerateLUpdateProject.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/GenerateLUpdateProject.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fc83898e45c9525b6dde5c4ebabc0e30fea793ae --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/GenerateLUpdateProject.cmake @@ -0,0 +1,164 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Generate an lupdate project file in JSON format. +# +# This file is to be used in CMake script mode with the following variables set: +# +# IN_FILE: .cmake file that sets lupdate_* variables +# OUT_FILE: lupdate project .json file + +cmake_minimum_required(VERSION 3.16) + +include("${IN_FILE}") + +# Converts a CMake list into a string containing a JSON array +# a,b,c -> [ "a", "b", "c" ] +function(list_to_json_array srcList jsonList) + set(quotedList "") + foreach(entry ${srcList}) + list(APPEND quotedList "\"${entry}\"") + endforeach() + list(JOIN quotedList ", " joinedList) + set(${jsonList} "[ ${joinedList} ]" PARENT_SCOPE) +endfunction() + +# Remove all nonexistent files from ARGN and store the result in out_var. +# filter_nonexistent_files(existing_files foo.txt bar.cpp) +# -> foo.txt (if foo.txt exists and bar.cpp does not) +function(filter_nonexistent_files out_var) + # Filter out non-existent (generated) source files + set(existing_sources "") + foreach(path IN LISTS ARGN) + if(EXISTS "${path}") + list(APPEND existing_sources "${path}") + endif() + endforeach() + set("${out_var}" "${existing_sources}" PARENT_SCOPE) +endfunction() + +# Remove source files that are unsuitable input for lupdate. +# filter_unsuitable_lupdate_input(sources main.cpp foo_de.qm bar.qml whatever_metatypes.json) +# -> main.cpp bar.qml +function(filter_unsuitable_lupdate_input out_var) + set(result ${ARGN}) + list(FILTER result EXCLUDE REGEX "\\.(qm|json)$") + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + +# Remove files from SOURCES that are in EXCLUDED_DIR. +# filter_files_in_directory(existing_files +# EXCLUDED_DIR .../target_autogen +# SOURCES .../src/foo.ui .../target_autogen/include/ui_foo.h) +# -> .../src/foo.ui +function(filter_files_in_directory out_var) + set(no_value_options "") + set(single_value_options EXCLUDED_DIR) + set(multi_value_options SOURCES) + cmake_parse_arguments(PARSE_ARGV 1 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + set(result "") + foreach(source_file IN LISTS arg_SOURCES) + file(RELATIVE_PATH relative_path "${arg_EXCLUDED_DIR}" "${source_file}") + if(IS_ABSOLUTE "${relative_path}" OR (relative_path MATCHES "^\\.\\.")) + list(APPEND result "${source_file}") + endif() + endforeach() + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + +function(prepare_json_sources out_var) + set(no_value_options "") + set(single_value_options AUTOGEN_DIR) + set(multi_value_options SOURCES) + cmake_parse_arguments(PARSE_ARGV 1 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + filter_nonexistent_files(sources ${arg_SOURCES}) + filter_unsuitable_lupdate_input(sources ${sources}) + if(DEFINED arg_AUTOGEN_DIR) + filter_files_in_directory(sources EXCLUDED_DIR ${arg_AUTOGEN_DIR} SOURCES ${sources}) + endif() + list_to_json_array("${sources}" result) + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + +get_filename_component(project_root "${lupdate_project_file}" DIRECTORY) + +# Set up a list of all path variables +set(path_variables sources include_paths translations) +if(lupdate_subproject_count GREATER 0) + foreach(i RANGE 1 ${lupdate_subproject_count}) + list(APPEND path_variables + subproject${i}_include_paths + subproject${i}_sources + subproject${i}_excluded + ) + endforeach() +endif() + +# Remove duplicates in include paths +# Once we require CMake 3.27, replace this with $. +foreach(path_var IN LISTS path_variables) + if(path_var MATCHES "_include_paths$") + list(REMOVE_DUPLICATES lupdate_${path_var}) + endif() +endforeach() + +# Make relative paths absolute to the project root +foreach(path_var IN LISTS path_variables) + set(absolute_${path_var} "") + foreach(path IN LISTS lupdate_${path_var}) + if(path STREQUAL "") + continue() + endif() + if(NOT IS_ABSOLUTE "${path}") + if(path_var MATCHES "^subproject[0-9]+_") + set(base_dir "${lupdate_${CMAKE_MATCH_0}source_dir}") + else() + set(base_dir "${project_root}") + endif() + get_filename_component(path "${path}" ABSOLUTE BASE_DIR "${base_dir}") + endif() + list(APPEND absolute_${path_var} "${path}") + endforeach() +endforeach() + +prepare_json_sources(json_sources SOURCES ${absolute_sources}) +list_to_json_array("${absolute_include_paths}" json_include_paths) +list_to_json_array("${absolute_translations}" json_translations) + +set(content "{ + \"projectFile\": \"${lupdate_project_file}\", + \"includePaths\": ${json_include_paths}, + \"sources\": ${json_sources}, + \"translations\": ${json_translations}, + \"subProjects\": [ +") +if(lupdate_subproject_count GREATER 0) + foreach(i RANGE 1 ${lupdate_subproject_count}) + prepare_json_sources(json_sources + AUTOGEN_DIR ${lupdate_subproject${i}_autogen_dir} + SOURCES ${absolute_subproject${i}_sources} + ) + list_to_json_array("${absolute_subproject${i}_include_paths}" json_include_paths) + list_to_json_array("${absolute_subproject${i}_excluded}" json_sources_exclusions) + string(APPEND content " { + \"projectFile\": \"${lupdate_subproject${i}_source_dir}/CMakeLists.txt\", + \"includePaths\": ${json_include_paths}, + \"sources\": ${json_sources}, + \"excluded\": ${json_sources_exclusions} + }") + if(i LESS lupdate_subproject_count) + string(APPEND content ",") + endif() + string(APPEND content "\n") + endforeach() +endif() +string(APPEND content " ] +} +") +file(WRITE "${OUT_FILE}" "${content}") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d9e4c97059a845458fc4af1c98c7e4fab7d538be --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsAdditionalTargetInfo.cmake @@ -0,0 +1,142 @@ +# Additional target information for Qt6LinguistTools +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +get_target_property(_qt_imported_location Qt6::lconvert IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::lconvert IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::lconvert" for configuration "Release" +set_property(TARGET Qt6::lconvert APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::lconvert PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::lconvert" for configuration "MinSizeRel" +set_property(TARGET Qt6::lconvert APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::lconvert PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::lconvert PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::lprodump IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::lprodump IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::lprodump" for configuration "Release" +set_property(TARGET Qt6::lprodump APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::lprodump PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::lprodump" for configuration "MinSizeRel" +set_property(TARGET Qt6::lprodump APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::lprodump PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::lprodump PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::lrelease IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::lrelease IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::lrelease" for configuration "Release" +set_property(TARGET Qt6::lrelease APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::lrelease PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::lrelease" for configuration "MinSizeRel" +set_property(TARGET Qt6::lrelease APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::lrelease PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::lrelease PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::lrelease-pro IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::lrelease-pro IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::lrelease-pro" for configuration "Release" +set_property(TARGET Qt6::lrelease-pro APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::lrelease-pro PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::lrelease-pro" for configuration "MinSizeRel" +set_property(TARGET Qt6::lrelease-pro APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::lrelease-pro PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::lrelease-pro PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::lupdate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::lupdate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::lupdate" for configuration "Release" +set_property(TARGET Qt6::lupdate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::lupdate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::lupdate" for configuration "MinSizeRel" +set_property(TARGET Qt6::lupdate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::lupdate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::lupdate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +get_target_property(_qt_imported_location Qt6::lupdate-pro IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::lupdate-pro IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::lupdate-pro" for configuration "Release" +set_property(TARGET Qt6::lupdate-pro APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::lupdate-pro PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::lupdate-pro" for configuration "MinSizeRel" +set_property(TARGET Qt6::lupdate-pro APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::lupdate-pro PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::lupdate-pro PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..12817c47a89ce1d812d5a5d3b2f0b9369265b9a9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfig.cmake @@ -0,0 +1,81 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleToolsConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsDependencies.cmake") +endif() + +# If *Dependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6LinguistTools_FOUND") + set("Qt6LinguistTools_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6LinguistTools_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsAdditionalTargetInfo.cmake") + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsVersionlessTargets.cmake") + endif() +endif() + +foreach(extra_cmake_include Qt6LinguistToolsMacros.cmake) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") +endforeach() + + +if(NOT QT_NO_CREATE_TARGETS AND Qt6LinguistTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::lconvert) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6LinguistTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::lprodump) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6LinguistTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::lrelease) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6LinguistTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::lrelease-pro) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6LinguistTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::lupdate) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND Qt6LinguistTools_FOUND) + __qt_internal_promote_target_to_global(Qt6::lupdate-pro) +endif() +set(Qt6LinguistTools_TARGETS "Qt6::lconvert;Qt6::lprodump;Qt6::lrelease;Qt6::lrelease-pro;Qt6::lupdate;Qt6::lupdate-pro") diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..51e32ef1a4c34e2a7334659b9b023d54efaadd9a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..93e7b8fe45741c6ef60d1556c39854e2ad1acd30 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsConfigVersionImpl.cmake @@ -0,0 +1,32 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cc04cfba1fb4c5f4e3c28c86ef68cdfce75a21fb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsDependencies.cmake @@ -0,0 +1,16 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Find "ModuleTools" dependencies, which are other ModuleTools packages. +set(Qt6LinguistTools_FOUND FALSE) +set(__qt_LinguistTools_tool_deps "") +foreach(__qt_LinguistTools_target_dep ${__qt_LinguistTools_tool_deps}) + list(GET __qt_LinguistTools_target_dep 0 __qt_LinguistTools_pkg) + list(GET __qt_LinguistTools_target_dep 1 __qt_LinguistTools_version) + + if (NOT ${__qt_LinguistTools_pkg}_FOUND) + find_dependency(${__qt_LinguistTools_pkg} ${__qt_LinguistTools_version}) + endif() +endforeach() + +set(Qt6LinguistTools_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsMacros.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsMacros.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1fb3c254f8b57e7d2f2340650280d7338d1c38fb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsMacros.cmake @@ -0,0 +1,840 @@ +# Copyright (C) 2020 The Qt Company Ltd. +# Copyright 2005-2011 Kitware, Inc. +# SPDX-License-Identifier: BSD-3-Clause + +include(CMakeParseArguments) + +function(qt6_create_translation _qm_files) + set(options) + set(oneValueArgs) + set(multiValueArgs OPTIONS) + + cmake_parse_arguments(_LUPDATE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + set(_lupdate_files ${_LUPDATE_UNPARSED_ARGUMENTS}) + set(_lupdate_options ${_LUPDATE_OPTIONS}) + + list(FIND _lupdate_options "-extensions" _extensions_index) + if(_extensions_index GREATER -1) + math(EXPR _extensions_index "${_extensions_index} + 1") + list(GET _lupdate_options ${_extensions_index} _extensions_list) + string(REPLACE "," ";" _extensions_list "${_extensions_list}") + list(TRANSFORM _extensions_list STRIP) + list(TRANSFORM _extensions_list REPLACE "^\\." "") + list(TRANSFORM _extensions_list PREPEND "*.") + else() + set(_extensions_list "*.java;*.jui;*.ui;*.c;*.c++;*.cc;*.cpp;*.cxx;*.ch;*.h;*.h++;*.hh;*.hpp;*.hxx;*.js;*.qs;*.qml;*.qrc") + endif() + set(_my_sources) + set(_my_tsfiles) + foreach(_file ${_lupdate_files}) + get_filename_component(_ext ${_file} EXT) + get_filename_component(_abs_FILE ${_file} ABSOLUTE) + if(_ext MATCHES "ts") + list(APPEND _my_tsfiles ${_abs_FILE}) + else() + list(APPEND _my_sources ${_abs_FILE}) + endif() + endforeach() + set(stamp_file_dir "${CMAKE_CURRENT_BINARY_DIR}/.lupdate") + if(NOT EXISTS "${stamp_file_dir}") + file(MAKE_DIRECTORY "${stamp_file_dir}") + endif() + set(stamp_files "") + foreach(_ts_file ${_my_tsfiles}) + get_filename_component(_ts_name ${_ts_file} NAME) + if(_my_sources) + # make a list file to call lupdate on, so we don't make our commands too + # long for some systems + set(_ts_lst_file "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_ts_name}_lst_file") + set(_lst_file_srcs) + set(_dependencies) + foreach(_lst_file_src ${_my_sources}) + set(_lst_file_srcs "${_lst_file_src}\n${_lst_file_srcs}") + if(IS_DIRECTORY ${_lst_file_src}) + list(TRANSFORM _extensions_list PREPEND "${_lst_file_src}/" OUTPUT_VARIABLE _directory_glob) + file(GLOB_RECURSE _directory_contents CONFIGURE_DEPENDS ${_directory_glob}) + list(APPEND _dependencies ${_directory_contents}) + else() + list(APPEND _dependencies "${_lst_file_src}") + endif() + endforeach() + + get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES) + foreach(_pro_include ${_inc_DIRS}) + get_filename_component(_abs_include "${_pro_include}" ABSOLUTE) + set(_lst_file_srcs "-I${_pro_include}\n${_lst_file_srcs}") + endforeach() + + file(WRITE ${_ts_lst_file} "${_lst_file_srcs}") + endif() + file(RELATIVE_PATH _ts_relative_path ${CMAKE_CURRENT_SOURCE_DIR} ${_ts_file}) + string(REPLACE "../" "__/" _ts_relative_path "${_ts_relative_path}") + set(stamp_file "${stamp_file_dir}/${_ts_relative_path}.stamp") + list(APPEND stamp_files ${stamp_file}) + get_filename_component(full_stamp_file_dir "${stamp_file}" DIRECTORY) + if(NOT EXISTS "${full_stamp_file_dir}") + file(MAKE_DIRECTORY "${full_stamp_file_dir}") + endif() + add_custom_command(OUTPUT ${stamp_file} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::lupdate + ARGS ${_lupdate_options} "@${_ts_lst_file}" -ts ${_ts_file} + COMMAND ${CMAKE_COMMAND} -E touch "${stamp_file}" + DEPENDS ${_dependencies} + VERBATIM) + endforeach() + qt6_add_translation(${_qm_files} ${_my_tsfiles} __QT_INTERNAL_TIMESTAMP_FILES ${stamp_files}) + set(${_qm_files} ${${_qm_files}} PARENT_SCOPE) +endfunction() + +function(qt6_add_translation _qm_files) + set(options) + set(oneValueArgs) + set(multiValueArgs OPTIONS __QT_INTERNAL_TIMESTAMP_FILES) + + cmake_parse_arguments(_LRELEASE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + set(_lrelease_files ${_LRELEASE_UNPARSED_ARGUMENTS}) + + set(idx 0) + foreach(_current_FILE ${_lrelease_files}) + get_filename_component(_abs_FILE ${_current_FILE} ABSOLUTE) + get_filename_component(qm ${_abs_FILE} NAME) + # everything before the last dot has to be considered the file name (including other dots) + string(REGEX REPLACE "\\.[^.]*$" "" FILE_NAME ${qm}) + get_source_file_property(output_location ${_abs_FILE} OUTPUT_LOCATION) + if(output_location) + file(MAKE_DIRECTORY "${output_location}") + set(qm "${output_location}/${FILE_NAME}.qm") + else() + set(qm "${CMAKE_CURRENT_BINARY_DIR}/${FILE_NAME}.qm") + endif() + + if(_LRELEASE___QT_INTERNAL_TIMESTAMP_FILES) + list(GET _LRELEASE___QT_INTERNAL_TIMESTAMP_FILES ${idx} qm_dep) + math(EXPR idx "${idx} + 1") + else() + set(qm_dep "${_abs_FILE}") + endif() + + add_custom_command(OUTPUT ${qm} + COMMAND ${QT_CMAKE_EXPORT_NAMESPACE}::lrelease + ARGS ${_LRELEASE_OPTIONS} ${_abs_FILE} -qm ${qm} + DEPENDS ${qm_dep} VERBATIM + ) + list(APPEND ${_qm_files} ${qm}) + endforeach() + set(${_qm_files} ${${_qm_files}} PARENT_SCOPE) +endfunction() + +function(_qt_internal_collect_translation_source_targets out_var dir) + set(result "") + get_property(excluded DIRECTORY "${dir}" PROPERTY QT_EXCLUDE_FROM_TRANSLATION) + if(NOT excluded) + get_property(subdirs DIRECTORY "${dir}" PROPERTY SUBDIRECTORIES) + foreach(subdir IN LISTS subdirs) + _qt_internal_collect_translation_source_targets(subresult "${subdir}") + list(APPEND result ${subresult}) + endforeach() + get_property(dir_targets DIRECTORY "${dir}" PROPERTY BUILDSYSTEM_TARGETS) + foreach(target IN LISTS dir_targets) + get_target_property(target_type ${target} TYPE) + if(CMAKE_VERSION VERSION_LESS "3.19" AND target_type STREQUAL "INTERFACE_LIBRARY") + # Skip INTERFACE libraries with CMake < 3.19 to avoid an error about + # QT_EXCLUDE_FROM_TRANSLATION not being whitelisted. + continue() + endif() + get_target_property(excluded ${target} QT_EXCLUDE_FROM_TRANSLATION) + if(NOT excluded AND NOT target_type STREQUAL "UTILITY") + list(APPEND result ${target}) + endif() + endforeach() + endif() + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + +function(qt6_collect_translation_source_targets out_var) + set(no_value_options "") + set(single_value_options DIRECTORY) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 1 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + set(dir "${arg_DIRECTORY}") + if(dir STREQUAL "") + set(dir "${CMAKE_CURRENT_SOURCE_DIR}") + endif() + + _qt_internal_collect_translation_source_targets(result "${dir}") + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + +# Makes the paths in the unparsed arguments absolute and stores them in out_var. +function(qt_internal_make_paths_absolute out_var) + set(result "") + foreach(path IN LISTS ARGN) + get_filename_component(abs_path "${path}" ABSOLUTE) + list(APPEND result "${abs_path}") + endforeach() + set("${out_var}" "${result}" PARENT_SCOPE) +endfunction() + +# If the given TS_FILE does not exist, write an initial .ts file that can be read by lrelease and +# updated by lupdate. +function(_qt_internal_ensure_ts_file) + set(no_value_options "") + set(single_value_options TS_FILE) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + if(EXISTS "${arg_TS_FILE}") + return() + endif() + + set(content + [[ + + +\n") + file(WRITE "${arg_TS_FILE}" "${content}") +endfunction() + +# Needed to locate Qt6LupdateProject.json.in file inside functions +set(_Qt6_LINGUIST_TOOLS_DIR ${CMAKE_CURRENT_LIST_DIR} CACHE INTERNAL "") + +function(qt6_add_lupdate) + set(options + NO_GLOBAL_TARGET) + set(oneValueArgs + PLURALS_TS_FILE + LUPDATE_TARGET) + set(multiValueArgs + SOURCE_TARGETS + TS_FILES + SOURCES + INCLUDE_DIRECTORIES + OPTIONS) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + # Set up the list of targets. Support the old command signature that takes one target as first + # argument. + set(targets "${arg_SOURCE_TARGETS}") + if("${targets}" STREQUAL "") + list(POP_FRONT arg_UNPARSED_ARGUMENTS target) + if(TARGET "${target}") + list(APPEND targets ${target}) + endif() + unset(target) + endif() + + if("${targets}" STREQUAL "" AND "${arg_SOURCES}" STREQUAL "") + message(FATAL_ERROR "No SOURCE_TARGETS nor SOURCES were given.") + endif() + + # Set up the name of the custom target. + set(lupdate_target "${arg_LUPDATE_TARGET}") + if("${lupdate_target}" STREQUAL "") + set(lupdate_target "${PROJECT_NAME}_lupdate") + set(lupdate_target_orig "${lupdate_target}") + set(n 1) + while(TARGET "${lupdate_target}") + set(lupdate_target "${lupdate_target_orig}${n}") + math(EXPR n "${n} + 1") + endwhile() + endif() + + set(includePaths "") + set(sources "") + list(LENGTH targets targets_length) + + if(arg_INCLUDE_DIRECTORIES) + qt_internal_make_paths_absolute(additionalIncludePaths "${arg_INCLUDE_DIRECTORIES}") + endif() + if(arg_SOURCES) + qt_internal_make_paths_absolute(additionalSources "${arg_SOURCES}") + endif() + + set(lupdate_work_dir "${CMAKE_CURRENT_BINARY_DIR}/.lupdate") + qt_internal_make_paths_absolute(ts_files "${arg_TS_FILES}") + set(plurals_ts_file "") + set(raw_plurals_ts_file "") + if(NOT "${arg_PLURALS_TS_FILE}" STREQUAL "") + qt_internal_make_paths_absolute(plurals_ts_file "${arg_PLURALS_TS_FILE}") + _qt_internal_ensure_ts_file(TS_FILE "${plurals_ts_file}") + get_filename_component(raw_plurals_ts_file "${plurals_ts_file}" NAME) + string(PREPEND raw_plurals_ts_file "${lupdate_work_dir}/") + list(APPEND ts_files "${raw_plurals_ts_file}") + endif() + + set(lupdate_project_base "${lupdate_work_dir}/${lupdate_target}_project") + set(lupdate_project_cmake "${lupdate_project_base}") + get_property(multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(multi_config) + string(APPEND lupdate_project_cmake ".$") + endif() + string(APPEND lupdate_project_cmake ".cmake") + set(lupdate_project_json "${lupdate_project_base}.json") + set(content "set(lupdate_project_file \"${CMAKE_CURRENT_LIST_FILE}\") +set(lupdate_translations \"${ts_files}\") +set(lupdate_include_paths \"${additionalIncludePaths}\") +set(lupdate_sources \"${additionalSources}\") +set(lupdate_subproject_count ${targets_length}) +") + set(exclude_ts "\\.ts$") + set(n 1) + foreach(target IN LISTS targets) + set(includePaths "$") + set(sources "$,EXCLUDE,${exclude_ts}>") + set(excluded "$") + set(autogen_build_dir_genex "$") + set(default_autogen_build_dir "$/${target}_autogen") + set(autogen_dir "$,${autogen_build_dir_genex},${default_autogen_build_dir}>") + string(APPEND content " +set(lupdate_subproject${n}_source_dir \"$\") +set(lupdate_subproject${n}_include_paths \"${includePaths}\") +set(lupdate_subproject${n}_sources \"${sources}\") +set(lupdate_subproject${n}_excluded \"${excluded}\") +set(lupdate_subproject${n}_autogen_dir \"${autogen_dir}\") +") + math(EXPR n "${n} + 1") + endforeach() + file(GENERATE OUTPUT "${lupdate_project_cmake}" CONTENT "${content}") + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + set(lupdate_command + COMMAND + "${tool_wrapper}" + $) + set(prepare_native_ts_command "") + set(finish_native_ts_command "") + if(NOT plurals_ts_file STREQUAL "") + # Copy the existing .ts file to preserve already translated strings. + set(prepare_native_ts_command + COMMAND + "${CMAKE_COMMAND}" -E copy "${plurals_ts_file}" "${raw_plurals_ts_file}" + ) + + # Filter out the non-numerus forms with lconvert. + set(finish_native_ts_command + COMMAND + "${tool_wrapper}" + $ + -pluralonly + -i "${raw_plurals_ts_file}" + -o "${plurals_ts_file}" + ) + endif() + add_custom_target(${lupdate_target} + COMMAND "${CMAKE_COMMAND}" "-DIN_FILE=${lupdate_project_cmake}" + "-DOUT_FILE=${lupdate_project_json}" + -P "${_Qt6_LINGUIST_TOOLS_DIR}/GenerateLUpdateProject.cmake" + ${prepare_native_ts_command} + ${lupdate_command} -project "${lupdate_project_json}" ${arg_OPTIONS} + ${finish_native_ts_command} + DEPENDS ${QT_CMAKE_EXPORT_NAMESPACE}::lupdate + VERBATIM) + + if(NOT DEFINED QT_GLOBAL_LUPDATE_TARGET) + set(QT_GLOBAL_LUPDATE_TARGET update_translations) + endif() + + if(NOT arg_NO_GLOBAL_TARGET) + _qt_internal_add_phony_target(${QT_GLOBAL_LUPDATE_TARGET} + WARNING_VARIABLE QT_NO_GLOBAL_LUPDATE_TARGET_CREATION_WARNING + ) + _qt_internal_add_phony_target_dependencies(${QT_GLOBAL_LUPDATE_TARGET} + ${lupdate_target} + ) + endif() +endfunction() + +function(_qt_internal_store_languages_from_ts_files_in_targets targets ts_files) + if(NOT APPLE) + return() + endif() + set(supported_languages "") + foreach(ts_file IN LISTS ts_files) + execute_process(COMMAND /usr/bin/xmllint --xpath "string(/TS/@language)" ${ts_file} + OUTPUT_STRIP_TRAILING_WHITESPACE + OUTPUT_VARIABLE language_code + ERROR_VARIABLE xmllint_error) + if(NOT language_code OR xmllint_error) + message(WARNING "Failed to resolve language code for ${ts_file}. " + "Please update CFBundleLocalizations in your Info.plist manually.") + endif() + endforeach() + foreach(target IN LISTS targets) + set_property(TARGET "${target}" APPEND PROPERTY + _qt_apple_supported_languages "${supported_languages}" + ) + endforeach() +endfunction() + +# Store in ${out_var} the file path to the .qm file that will be generated from the given .ts file. +function(_qt_internal_generated_qm_file_path out_var ts_file default_out_dir) + get_filename_component(qm ${ts_file} NAME_WLE) + string(APPEND qm ".qm") + get_source_file_property(output_location ${ts_file} OUTPUT_LOCATION) + if(output_location) + if(NOT IS_ABSOLUTE "${output_location}") + get_filename_component(output_location "${output_location}" ABSOLUTE + BASE_DIR "${default_out_dir}") + endif() + string(PREPEND qm "${output_location}/") + else() + string(PREPEND qm "${default_out_dir}/") + endif() + set("${out_var}" "${qm}" PARENT_SCOPE) +endfunction() + +function(qt6_add_lrelease) + set(options + NO_TARGET_DEPENDENCY ### Qt7: remove together with legacy signature + EXCLUDE_FROM_ALL + NO_GLOBAL_TARGET) + set(oneValueArgs + __QT_INTERNAL_DEFAULT_QM_OUT_DIR + LRELEASE_TARGET + QM_FILES_OUTPUT_VARIABLE) + set(multiValueArgs + TS_FILES + OPTIONS) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + qt_internal_make_paths_absolute(ts_files "${arg_TS_FILES}") + + # Support the old command signature that takes one target as first argument. + set(legacy_signature_used FALSE) + set(legacy_target "") + list(LENGTH arg_UNPARSED_ARGUMENTS unparsed_arguments_count) + if(unparsed_arguments_count GREATER 0) + list(POP_FRONT arg_UNPARSED_ARGUMENTS legacy_target) + if(TARGET "${legacy_target}") + set(legacy_signature_used TRUE) + else() + set(legacy_target "") + endif() + endif() + + # Set up the driving target. + set(lrelease_target "${arg_LRELEASE_TARGET}") + if("${lrelease_target}" STREQUAL "") + set(lrelease_target "${PROJECT_NAME}_lrelease") + set(lrelease_target_orig "${lrelease_target}") + set(n 1) + while(TARGET "${lrelease_target}") + set(lrelease_target "${lrelease_target_orig}${n}") + math(EXPR n "${n} + 1") + endwhile() + endif() + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + set(lrelease_command + COMMAND + "${tool_wrapper}" + $) + + set(default_qm_out_dir "${CMAKE_CURRENT_BINARY_DIR}") + if(NOT "${arg___QT_INTERNAL_DEFAULT_QM_OUT_DIR}" STREQUAL "") + set(default_qm_out_dir "${arg___QT_INTERNAL_DEFAULT_QM_OUT_DIR}") + endif() + + set(qm_files "") + foreach(ts_file ${ts_files}) + if(NOT EXISTS "${ts_file}") + _qt_internal_ensure_ts_file(TS_FILE "${ts_file}") + endif() + + _qt_internal_generated_qm_file_path(qm "${ts_file}" "${default_qm_out_dir}") + get_filename_component(qm_dir "${qm}" DIRECTORY) + add_custom_command(OUTPUT ${qm} + COMMAND "${CMAKE_COMMAND}" -E make_directory "${qm_dir}" + ${lrelease_command} ${arg_OPTIONS} ${ts_file} -qm ${qm} + DEPENDS ${QT_CMAKE_EXPORT_NAMESPACE}::lrelease "${ts_file}" + VERBATIM) + list(APPEND qm_files "${qm}") + + # QTBUG-103470: Save the target responsible for driving the build of the custom command + # into an internal source file property. It will be added as a dependency for targets + # created by _qt_internal_process_resource, to avoid the Xcode issue of not allowing + # multiple targets depending on the output, without having a common target ancestor. + set(scope_args "") + if(legacy_signature_used AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${legacy_target}) + endif() + set_source_files_properties("${qm}" ${scope_args} PROPERTIES + _qt_resource_target_dependency "${lrelease_target}" + ) + endforeach() + + if(legacy_signature_used) + _qt_internal_store_languages_from_ts_files_in_targets("${legacy_target}" "${ts_files}") + endif() + + if(legacy_signature_used) + add_custom_target(${lrelease_target} DEPENDS ${qm_files}) + if(NOT arg_NO_TARGET_DEPENDENCY) + add_dependencies(${legacy_target} ${lrelease_target}) + endif() + else() + set(maybe_all ALL) + if(arg_EXCLUDE_FROM_ALL) + set(maybe_all "") + endif() + add_custom_target(${lrelease_target} ${maybe_all} DEPENDS ${qm_files}) + endif() + + if(NOT DEFINED QT_GLOBAL_LRELEASE_TARGET) + set(QT_GLOBAL_LRELEASE_TARGET release_translations) + endif() + + if(NOT arg_NO_GLOBAL_TARGET) + if(NOT TARGET ${QT_GLOBAL_LRELEASE_TARGET}) + add_custom_target(${QT_GLOBAL_LRELEASE_TARGET}) + endif() + add_dependencies(${QT_GLOBAL_LRELEASE_TARGET} ${lrelease_target}) + endif() + + if(NOT "${arg_QM_FILES_OUTPUT_VARIABLE}" STREQUAL "") + set("${arg_QM_FILES_OUTPUT_VARIABLE}" "${qm_files}" PARENT_SCOPE) + endif() +endfunction() + +function(qt6_add_translations) + set(options + IMMEDIATE_CALL + NO_GENERATE_PLURALS_TS_FILE) + set(oneValueArgs + __QT_INTERNAL_DEFAULT_QM_OUT_DIR + LUPDATE_TARGET + LRELEASE_TARGET + TS_FILES_OUTPUT_VARIABLE + QM_FILES_OUTPUT_VARIABLE + RESOURCE_PREFIX + OUTPUT_TARGETS) + set(multiValueArgs + TARGETS + SOURCE_TARGETS + TS_FILES + TS_FILE_BASE + TS_FILE_DIR + PLURALS_TS_FILE + SOURCES + INCLUDE_DIRECTORIES + LUPDATE_OPTIONS + LRELEASE_OPTIONS) + cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + set(targets "${arg_TARGETS}") + if(NOT "${arg_UNPARSED_ARGUMENTS}" STREQUAL "") + list(POP_FRONT arg_UNPARSED_ARGUMENTS target) + list(PREPEND targets "${target}") + unset(target) + set(arg_TARGETS ${targets}) # to forward this argument + endif() + if(targets STREQUAL "") + message(FATAL_ERROR "No targets provided.") + endif() + if(DEFINED arg_RESOURCE_PREFIX AND DEFINED arg_QM_FILES_OUTPUT_VARIABLE) + message(FATAL_ERROR "QM_FILES_OUTPUT_VARIABLE cannot be specified " + "together with RESOURCE_PREFIX.") + endif() + if(DEFINED arg_QM_FILES_OUTPUT_VARIABLE AND DEFINED arg_OUTPUT_TARGETS) + message(FATAL_ERROR "OUTPUT_TARGETS cannot be specified " + "together with QM_FILES_OUTPUT_VARIABLE.") + endif() + if(NOT DEFINED arg_RESOURCE_PREFIX AND NOT DEFINED arg_QM_FILES_OUTPUT_VARIABLE) + set(arg_RESOURCE_PREFIX "/i18n") + endif() + + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args DIRECTORY ${PROJECT_SOURCE_DIR}) + endif() + + # Determine the .ts file paths if necessary. This must happen before function deferral. + if(NOT DEFINED arg_TS_FILES) + if(NOT DEFINED arg_TS_FILE_DIR) + set(arg_TS_FILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") + endif() + if(NOT DEFINED arg_TS_FILE_BASE) + set(arg_TS_FILE_BASE "${PROJECT_NAME}") + string(REPLACE " " "-" arg_TS_FILE_BASE "${arg_TS_FILE_BASE}") + endif() + set(arg_TS_FILES "") + foreach(lang IN LISTS QT_I18N_TRANSLATED_LANGUAGES) + set(ts_file "${arg_TS_FILE_DIR}/${arg_TS_FILE_BASE}_${lang}.ts") + list(APPEND arg_TS_FILES "${ts_file}") + set_source_files_properties(${ts_file} ${scope_args} PROPERTIES + _qt_i18n_translated_language ${lang} + ) + endforeach() + + # Default the source language to "en" in case the user doesn't use + # qt_standard_project_setup. + set(source_lang en) + if(NOT "${QT_I18N_SOURCE_LANGUAGE}" STREQUAL "") + set(source_lang ${QT_I18N_SOURCE_LANGUAGE}) + endif() + + # Determine the path to the plurals-only .ts file if necessary. + if(NOT arg_NO_GENERATE_PLURALS_TS_FILE + AND NOT DEFINED arg_PLURALS_TS_FILE + AND NOT "${source_lang}" IN_LIST QT_I18N_TRANSLATED_LANGUAGES) + set(arg_PLURALS_TS_FILE + "${arg_TS_FILE_DIR}/${arg_TS_FILE_BASE}_${source_lang}.ts") + set_source_files_properties(${arg_PLURALS_TS_FILE} ${scope_args} PROPERTIES + _qt_i18n_translated_language ${source_lang} + ) + endif() + endif() + + # Store all .ts file paths in a user-specified variable. + if(DEFINED arg_TS_FILES_OUTPUT_VARIABLE) + set("${arg_TS_FILES_OUTPUT_VARIABLE}" ${arg_PLURALS_TS_FILE} ${arg_TS_FILES} PARENT_SCOPE) + endif() + + # Defer the actual function call if SOURCE_TARGETS was not given and an immediate call was not + # requested. + set(source_targets "${arg_SOURCE_TARGETS}") + if(source_targets STREQUAL "" AND NOT arg_IMMEDIATE_CALL) + if(DEFINED arg_OUTPUT_TARGETS) + # We don't have the infrastructure to predict the resource target names. + message(FATAL_ERROR "Deferring qt6_add_translations is not supported with " + "OUTPUT_TARGETS. Pass IMMEDIATE_CALL or specify SOURCE_TARGETS.") + endif() + if(CMAKE_VERSION VERSION_LESS "3.19") + message(WARNING + "qt6_add_translations cannot defer function calls with this CMake version. " + "Only targets created prior to the qt6_add_translations call are used for i18n. " + "To avoid this warning, make sure this command is called at the end of the " + "top-level directory scope and pass the IMMEDIATE_CALL keyword. " + "Alternatively, upgrade to CMake 3.19 or newer." + ) + qt6_add_translations(IMMEDIATE_CALL ${ARGV}) + else() + # Predict the names of generated .qm files. + if(DEFINED arg_QM_FILES_OUTPUT_VARIABLE) + set(qm_files "") + foreach(ts_file IN LISTS arg_TS_FILES arg_PLURALS_TS_FILE) + _qt_internal_generated_qm_file_path(qm_file "${ts_file}" + "${CMAKE_CURRENT_BINARY_DIR}") + list(APPEND qm_files "${qm_file}") + endforeach() + set("${arg_QM_FILES_OUTPUT_VARIABLE}" "${qm_files}" PARENT_SCOPE) + endif() + + # Forward options. + set(forwarded_args + IMMEDIATE_CALL + __QT_INTERNAL_DEFAULT_QM_OUT_DIR "${CMAKE_CURRENT_BINARY_DIR}" + ) + foreach(keyword IN LISTS options) + if(arg_${keyword}) + list(APPEND forwarded_args ${keyword}) + endif() + endforeach() + + # Forward one-value and multi-value arguments. + # Filter path variables. We will forward those separately. + set(to_forward ${oneValueArgs} ${multiValueArgs}) + set(path_variables + TS_FILES + PLURALS_TS_FILE + SOURCES + INCLUDE_DIRECTORIES + ) + set(ignored_variables + TS_FILE_BASE + TS_FILE_DIR + TS_FILES_OUTPUT_VARIABLE + ) + list(REMOVE_ITEM to_forward ${path_variables} ${ignored_variables}) + foreach(keyword IN LISTS to_forward) + if(DEFINED arg_${keyword}) + list(APPEND forwarded_args ${keyword} ${arg_${keyword}}) + endif() + endforeach() + + # Make variables that specify paths absolute. + # Relative paths are considered to be relative to the current source dir. + foreach(var IN LISTS path_variables) + qt_internal_make_paths_absolute(absolute_paths ${arg_${var}}) + if(NOT "${absolute_paths}" STREQUAL "") + list(APPEND forwarded_args ${var} ${absolute_paths}) + endif() + endforeach() + + # The project-level CMakeLists.txt might miss a call to find_package(Qt6 COMPONENTS Core + # LinguistTools). Then, subsequent function calls like qt_add_resources will fail. To + # remedy this, pull the packages in. + cmake_language(EVAL CODE + "cmake_language(DEFER + DIRECTORY \"${PROJECT_SOURCE_DIR}\" + CALL find_package Qt6 COMPONENTS Core LinguistTools)") + + # Schedule this command to be called at the end of the project's source dir. + cmake_language(EVAL CODE + "cmake_language(DEFER + DIRECTORY \"${PROJECT_SOURCE_DIR}\" + CALL qt6_add_translations ${forwarded_args})") + endif() + return() + endif() + + if(source_targets STREQUAL "") + qt6_collect_translation_source_targets(source_targets) + endif() + qt6_add_lupdate( + SOURCE_TARGETS "${source_targets}" + LUPDATE_TARGET "${arg_LUPDATE_TARGET}" + TS_FILES "${arg_TS_FILES}" + PLURALS_TS_FILE "${arg_PLURALS_TS_FILE}" + SOURCES "${arg_SOURCES}" + INCLUDE_DIRECTORIES "${arg_INCLUDE_DIRECTORIES}" + OPTIONS "${arg_LUPDATE_OPTIONS}" + ) + qt6_add_lrelease( + LRELEASE_TARGET "${arg_LRELEASE_TARGET}" + TS_FILES "${arg_TS_FILES}" ${arg_PLURALS_TS_FILE} + QM_FILES_OUTPUT_VARIABLE qm_files + OPTIONS "${arg_LRELEASE_OPTIONS}" + __QT_INTERNAL_DEFAULT_QM_OUT_DIR "${arg___QT_INTERNAL_DEFAULT_QM_OUT_DIR}" + ) + + # Make the .ts files visible in IDEs. + set(all_ts_files ${arg_TS_FILES} ${arg_PLURALS_TS_FILE}) + foreach(target IN LISTS targets) + foreach(ts_file IN LISTS all_ts_files) + _qt_internal_expose_source_file_to_ide(${target} ${ts_file}) + endforeach() + endforeach() + + if("${QT_I18N_TRANSLATED_LANGUAGES}" STREQUAL "") + _qt_internal_store_languages_from_ts_files_in_targets("${targets}" "${arg_TS_FILES}") + endif() + + # Mark .qm files as GENERATED, so that calling _qt_internal_expose_deferred_files_to_ide + # doesn't cause an error at generation time saying "Cannot find source file:" when + # qt6_add_lrelease is called from a subdirectory different than the target. + # The issue happend when the user project called cmake_minimum_required(VERSION) + # with a version less than 3.20 or set the CMP0118 policy value to OLD. + set(scope_args "") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${targets}) + endif() + set_source_files_properties(${qm_files} + ${scope_args} + PROPERTIES GENERATED TRUE + ) + + if(NOT "${arg_RESOURCE_PREFIX}" STREQUAL "") + set(accumulated_out_targets "") + foreach(target IN LISTS targets) + get_target_property(target_binary_dir ${target} BINARY_DIR) + qt6_add_resources(${target} "${target}_translations" + PREFIX "${arg_RESOURCE_PREFIX}" + BASE "${target_binary_dir}" + OUTPUT_TARGETS out_targets + FILES ${qm_files}) + list(APPEND accumulated_out_targets ${out_targets}) + endforeach() + if(DEFINED arg_OUTPUT_TARGETS) + set("${arg_OUTPUT_TARGETS}" "${accumulated_out_targets}" PARENT_SCOPE) + endif() + endif() + if(NOT "${arg_QM_FILES_OUTPUT_VARIABLE}" STREQUAL "") + set("${arg_QM_FILES_OUTPUT_VARIABLE}" "${qm_files}" PARENT_SCOPE) + endif() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_create_translation _qm_files) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_create_translation("${_qm_files}" ${ARGN}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_create_translation("${_qm_files}" ${ARGN}) + endif() + set("${_qm_files}" "${${_qm_files}}" PARENT_SCOPE) + endfunction() + function(qt_add_translation _qm_files) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_add_translation("${_qm_files}" ${ARGN}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_translation("${_qm_files}" ${ARGN}) + endif() + set("${_qm_files}" "${${_qm_files}}" PARENT_SCOPE) + endfunction() + function(qt_collect_translation_source_targets out_var) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_collect_translation_source_targets("${out_var}" ${ARGN}) + else() + message(FATAL_ERROR "qt_collect_translation_source_targets() is only available in Qt 6.") + endif() + set("${out_var}" "${${out_var}}" PARENT_SCOPE) + endfunction() + function(qt_add_lupdate) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_lupdate(${ARGN}) + else() + message(FATAL_ERROR "qt_add_lupdate() is only available in Qt 6.") + endif() + endfunction() + function(qt_add_lrelease) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_lrelease(${ARGN}) + cmake_parse_arguments(PARSE_ARGV 1 arg "" "QM_FILES_OUTPUT_VARIABLE" "") + if(arg_QM_FILES_OUTPUT_VARIABLE) + set(${arg_QM_FILES_OUTPUT_VARIABLE} ${${arg_QM_FILES_OUTPUT_VARIABLE}} PARENT_SCOPE) + endif() + else() + message(FATAL_ERROR "qt_add_lrelease() is only available in Qt 6.") + endif() + endfunction() + function(qt_add_translations) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_add_translations(${ARGN}) + + set(no_value_options "") + set(single_value_options + TS_FILES_OUTPUT_VARIABLE + QM_FILES_OUTPUT_VARIABLE + ) + set(multi_value_options + OUTPUT_TARGETS + ) + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${${arg_OUTPUT_TARGETS}} PARENT_SCOPE) + endif() + if(arg_TS_FILES_OUTPUT_VARIABLE) + set(${arg_TS_FILES_OUTPUT_VARIABLE} ${${arg_TS_FILES_OUTPUT_VARIABLE}} PARENT_SCOPE) + endif() + if(arg_QM_FILES_OUTPUT_VARIABLE) + set(${arg_QM_FILES_OUTPUT_VARIABLE} ${${arg_QM_FILES_OUTPUT_VARIABLE}} PARENT_SCOPE) + endif() + else() + message(FATAL_ERROR "qt_add_translations() is only available in Qt 6.") + endif() + endfunction() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0c809c7650339e5c5ec95b84f02dd78c0c7a30da --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets-debug.cmake @@ -0,0 +1,9 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2692570963c6f53bc0dda25d96486f8e91bc124c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets-relwithdebinfo.cmake @@ -0,0 +1,63 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::lconvert" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::lconvert APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::lconvert PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/lconvert.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::lconvert ) +list(APPEND _cmake_import_check_files_for_Qt6::lconvert "${_IMPORT_PREFIX}/bin/lconvert.exe" ) + +# Import target "Qt6::lprodump" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::lprodump APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::lprodump PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/lprodump.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::lprodump ) +list(APPEND _cmake_import_check_files_for_Qt6::lprodump "${_IMPORT_PREFIX}/bin/lprodump.exe" ) + +# Import target "Qt6::lrelease" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::lrelease APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::lrelease PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/lrelease.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::lrelease ) +list(APPEND _cmake_import_check_files_for_Qt6::lrelease "${_IMPORT_PREFIX}/bin/lrelease.exe" ) + +# Import target "Qt6::lrelease-pro" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::lrelease-pro APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::lrelease-pro PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/lrelease-pro.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::lrelease-pro ) +list(APPEND _cmake_import_check_files_for_Qt6::lrelease-pro "${_IMPORT_PREFIX}/bin/lrelease-pro.exe" ) + +# Import target "Qt6::lupdate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::lupdate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::lupdate PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/lupdate.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::lupdate ) +list(APPEND _cmake_import_check_files_for_Qt6::lupdate "${_IMPORT_PREFIX}/bin/lupdate.exe" ) + +# Import target "Qt6::lupdate-pro" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::lupdate-pro APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::lupdate-pro PROPERTIES + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/lupdate-pro.exe" + ) + +list(APPEND _cmake_import_check_targets Qt6::lupdate-pro ) +list(APPEND _cmake_import_check_files_for_Qt6::lupdate-pro "${_IMPORT_PREFIX}/bin/lupdate-pro.exe" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dc770d9bbfa2319d38d21e8a9104a34b4669ac33 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsTargets.cmake @@ -0,0 +1,189 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "2.8.3") + message(FATAL_ERROR "CMake >= 2.8.3 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.8.3...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::lconvert Qt6::lprodump Qt6::lrelease Qt6::lrelease-pro Qt6::lupdate Qt6::lupdate-pro) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::lconvert +add_executable(Qt6::lconvert IMPORTED) + +set_target_properties(Qt6::lconvert PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-tool-lconvert" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Create imported target Qt6::lprodump +add_executable(Qt6::lprodump IMPORTED) + +set_target_properties(Qt6::lprodump PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-tool-lprodump" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Create imported target Qt6::lrelease +add_executable(Qt6::lrelease IMPORTED) + +set_target_properties(Qt6::lrelease PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-tool-lrelease" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Create imported target Qt6::lrelease-pro +add_executable(Qt6::lrelease-pro IMPORTED) + +set_target_properties(Qt6::lrelease-pro PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-tool-lrelease-pro" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Create imported target Qt6::lupdate +add_executable(Qt6::lupdate IMPORTED) + +set_target_properties(Qt6::lupdate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-tool-lupdate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Create imported target Qt6::lupdate-pro +add_executable(Qt6::lupdate-pro IMPORTED) + +set_target_properties(Qt6::lupdate-pro PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + INTERFACE_QT_MAJOR_VERSION "6" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-tool-lupdate-pro" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6LinguistToolsTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6b6a51eb05087e70982f9c0164f97373eb4c08ad --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6LinguistTools/Qt6LinguistToolsVersionlessTargets.cmake @@ -0,0 +1,26 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +foreach(__qt_tool lconvert;lprodump;lrelease;lrelease-pro;lupdate;lupdate-pro) + if(NOT TARGET Qt::${__qt_tool} AND TARGET Qt6::${__qt_tool}) + add_executable(Qt::${__qt_tool} IMPORTED GLOBAL) + + # Check all the usual imported location properties to find one that contains a path. + foreach(__qt_imported_location_config + IMPORTED_LOCATION + IMPORTED_LOCATION_RELEASE + IMPORTED_LOCATION_RELWITHDEBINFO + IMPORTED_LOCATION_MINSIZEREL + IMPORTED_LOCATION_DEBUG) + + get_target_property(__qt_imported_location + Qt6::${__qt_tool} ${__qt_imported_location_config}) + if(__qt_imported_location AND EXISTS "${__qt_imported_location}") + break() + endif() + endforeach() + + set_target_properties(Qt::${__qt_tool} + PROPERTIES IMPORTED_LOCATION "${__qt_imported_location}") + endif() +endforeach() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ae2578b84587ff350df9fcffe17fd551340734f1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6Network +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::Network) +get_target_property(_qt_imported_location Qt6::Network IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::Network IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::Network IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::Network IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::Network IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::Network IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::Network" for configuration "Release" +set_property(TARGET Qt6::Network APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::Network" for configuration "MinSizeRel" +set_property(TARGET Qt6::Network APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::Network PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::NetworkPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..42a0fd7a04b57b9101e222a3595985ed701a014f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkDependencies.cmake") + _qt_internal_suggest_dependency_debugging(Network + __qt_Network_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6Network_FOUND") + set("Qt6Network_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6Network_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6Network) instead. + set(Qt6Network_LIBRARIES "Qt6::Network") + + get_target_property(_Qt6Network_OWN_INCLUDE_DIRS + Qt6::Network INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Network_OWN_INCLUDE_DIRS) + set(_Qt6Network_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::NetworkPrivate) + get_target_property(_Qt6Network_OWN_PRIVATE_INCLUDE_DIRS + Qt6::NetworkPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Network_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6Network_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6Network_DEFINITIONS + Qt6::Network INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Network_DEFINITIONS) + set(Qt6Network_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6Network_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6Network_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6Network_COMPILE_DEFINITIONS + Qt6::Network INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Network_COMPILE_DEFINITIONS) + set(Qt6Network_COMPILE_DEFINITIONS "") + endif() + + set(Qt6Network_INCLUDE_DIRS + ${_Qt6Network_OWN_INCLUDE_DIRS}) + + set(Qt6Network_PRIVATE_INCLUDE_DIRS + ${_Qt6Network_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6Network_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6Network${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6Network${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6Network_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6Network${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6Network${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6Network_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Network_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Network_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6Network_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::Network) + qt_make_features_available(Qt6::Network) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Network") + + get_target_property(_qt_module_target_type "Qt6::Network" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::Network MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6Network_FOUND FALSE) + if(NOT DEFINED Qt6Network_NOT_FOUND_MESSAGE) + set(Qt6Network_NOT_FOUND_MESSAGE + "Target \"Qt6::Network\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6Network_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c0caa1b563d25d8a2578b944c0abc86e34ce8a26 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b00ef7bfe7885bc0576603e74cf941e385b574f1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6Network_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_Network_third_party_deps "") + +_qt_internal_find_third_party_dependencies("Network" __qt_Network_third_party_deps) + +# Find Qt tool package. +set(__qt_Network_tool_deps "") +_qt_internal_find_tool_dependencies("Network" __qt_Network_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_Network_target_deps "Qt6Core\;6.8.1") +set(__qt_Network_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("Network" __qt_Network_target_deps + __qt_Network_find_dependency_paths) + +set(_Qt6Network_MODULE_DEPENDENCIES "Core") +set(Qt6Network_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkPlugins.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkPlugins.cmake new file mode 100644 index 0000000000000000000000000000000000000000..94150b81c123d8779c81201c8c6a6bbdc0bbe21e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkPlugins.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_PLUGIN_INCLUSION OFF) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION) + __qt_internal_include_plugin_packages(Network) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a43d2d53d4fdb60b16d1aae87f05d1770b3a04d6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Network" for configuration "Debug" +set_property(TARGET Qt6::Network APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::Network PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6Networkd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6Networkd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Network ) +list(APPEND _cmake_import_check_files_for_Qt6::Network "${_IMPORT_PREFIX}/lib/Qt6Networkd.lib" "${_IMPORT_PREFIX}/bin/Qt6Networkd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d5708b16536c74d36709e94a26cb7fb6e829c6b2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Network" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::Network APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::Network PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6Network.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6Network.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Network ) +list(APPEND _cmake_import_check_files_for_Qt6::Network "${_IMPORT_PREFIX}/lib/Qt6Network.lib" "${_IMPORT_PREFIX}/bin/Qt6Network.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bef0467bd26a9e4d5a5fe544f426b97d663ebf67 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkTargets.cmake @@ -0,0 +1,168 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Network Qt6::NetworkPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Network +add_library(Qt6::Network SHARED IMPORTED) + +set_target_properties(Qt6::Network PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_NETWORK_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtNetwork;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;ws2_32" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6network_metatypes.json>" + MODULE_PLUGIN_TYPES "networkaccess;networkinformation;tls" + QT_DISABLED_PRIVATE_FEATURES "libresolv;libproxy;linux_netlink;res_setservers;publicsuffix_system" + QT_DISABLED_PUBLIC_FEATURES "getifaddrs;ipv6ifname;securetransport;sctp;brotli;gssapi" + QT_ENABLED_PRIVATE_FEATURES "system_proxies;networklistmanager;publicsuffix_qt" + QT_ENABLED_PUBLIC_FEATURES "schannel;ssl;dtls;ocsp;http;udpsocket;networkproxy;socks5;networkinterface;networkdiskcache;localserver;dnslookup;sspi;topleveldomain" + QT_QMAKE_PRIVATE_CONFIG "" + QT_QMAKE_PUBLIC_CONFIG "" + QT_QMAKE_PUBLIC_QT_CONFIG "" + _qt_config_module_name "network" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtNetwork" + _qt_module_interface_name "Network" + _qt_package_name "Qt6Network" + _qt_package_version "6.8.1" + _qt_private_module_target_name "NetworkPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Network" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::NetworkPrivate +add_library(Qt6::NetworkPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::NetworkPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtNetwork/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtNetwork/6.8.1/QtNetwork>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::Network" + _qt_config_module_name "network_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6Network" + _qt_package_version "6.8.1" + _qt_public_module_target_name "Network" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-Network" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6NetworkTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Core" "Qt6::CorePrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e2586d8d2b482998489752c45d227ce7a63345d4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Network;NetworkPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e53e0ef438967011c875863b134b5e73c027f0be --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6NetworkVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Network;NetworkPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4aeebe43cc56be5bf0a5bf58033067ed8381a5f5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QNLMNIPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QNLMNIPlugin) +get_target_property(_qt_imported_location Qt6::QNLMNIPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QNLMNIPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QNLMNIPlugin" for configuration "Release" +set_property(TARGET Qt6::QNLMNIPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QNLMNIPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QNLMNIPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QNLMNIPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QNLMNIPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QNLMNIPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a75dba858e0231e8a8491a816e1e9124647bf3b8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QNLMNIPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QNLMNIPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QNLMNIPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QNLMNIPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ded8337831ae3e52b4ff1fda61df3cb9ab3878c4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QNLMNIPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1bf9b47f24104816f07fc01a041752fadf3cfb52 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QNLMNIPlugin" for configuration "Debug" +set_property(TARGET Qt6::QNLMNIPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QNLMNIPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/networkinformation/qnetworklistmanagerd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QNLMNIPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QNLMNIPlugin "${_IMPORT_PREFIX}/plugins/networkinformation/qnetworklistmanagerd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..eb769c34658fdf0a98be28c1c3d05445773aabf3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QNLMNIPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QNLMNIPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QNLMNIPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/networkinformation/qnetworklistmanager.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QNLMNIPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QNLMNIPlugin "${_IMPORT_PREFIX}/plugins/networkinformation/qnetworklistmanager.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e0a91e4f18ce3ce1f1bd627b584eaecbb0de0fb6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QNLMNIPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QNLMNIPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QNLMNIPlugin +add_library(Qt6::QNLMNIPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QNLMNIPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Network" + QT_PLUGIN_CLASS_NAME "QNetworkListManagerNetworkInformationBackendFactory" + QT_PLUGIN_TYPE "networkinformation" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QNLMNIPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QNLMNIPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..79e07b7f8ca6eb13b57c3f54e3bb5f825f671264 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QSchannelBackendPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QSchannelBackendPlugin) +get_target_property(_qt_imported_location Qt6::QSchannelBackendPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QSchannelBackendPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QSchannelBackendPlugin" for configuration "Release" +set_property(TARGET Qt6::QSchannelBackendPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QSchannelBackendPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QSchannelBackendPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QSchannelBackendPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QSchannelBackendPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QSchannelBackendPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4574a2860232cc174d64a3312d6e2e211b242153 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QSchannelBackendPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSchannelBackendPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSchannelBackendPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSchannelBackendPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..bd40dfb53bbc92f81c51dbe2bf11585663ba9d27 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QSchannelBackendPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c48de8d896a9947b7c0902926ac2636d04814374 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QSchannelBackendPlugin" for configuration "Debug" +set_property(TARGET Qt6::QSchannelBackendPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QSchannelBackendPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/tls/qschannelbackendd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QSchannelBackendPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QSchannelBackendPlugin "${_IMPORT_PREFIX}/plugins/tls/qschannelbackendd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e9b744564aca0abf87b4f8d73709f93b28336f16 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QSchannelBackendPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QSchannelBackendPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QSchannelBackendPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/tls/qschannelbackend.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QSchannelBackendPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QSchannelBackendPlugin "${_IMPORT_PREFIX}/plugins/tls/qschannelbackend.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee1952a55aeb7820b9bf5f050876b58c87e7e5cf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QSchannelBackendPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QSchannelBackendPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QSchannelBackendPlugin +add_library(Qt6::QSchannelBackendPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QSchannelBackendPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Network" + QT_PLUGIN_CLASS_NAME "QSchannelBackend" + QT_PLUGIN_TYPE "tls" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QSchannelBackendPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QSchannelBackendPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..783c305789b2f66127ea51f2763157559cf95697 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QTlsBackendCertOnlyPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QTlsBackendCertOnlyPlugin) +get_target_property(_qt_imported_location Qt6::QTlsBackendCertOnlyPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QTlsBackendCertOnlyPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QTlsBackendCertOnlyPlugin" for configuration "Release" +set_property(TARGET Qt6::QTlsBackendCertOnlyPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTlsBackendCertOnlyPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QTlsBackendCertOnlyPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QTlsBackendCertOnlyPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTlsBackendCertOnlyPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QTlsBackendCertOnlyPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..36454f740b67b5348e0d3df024105a62372f158c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendCertOnlyPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendCertOnlyPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendCertOnlyPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendCertOnlyPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee4ae2c54107856111478ac2d742b4f76793c65a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendCertOnlyPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b3ef5d0537e5a9f20beea9935e0dc987cc61aa04 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTlsBackendCertOnlyPlugin" for configuration "Debug" +set_property(TARGET Qt6::QTlsBackendCertOnlyPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QTlsBackendCertOnlyPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/tls/qcertonlybackendd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTlsBackendCertOnlyPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTlsBackendCertOnlyPlugin "${_IMPORT_PREFIX}/plugins/tls/qcertonlybackendd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..08ce2616aed5492a2fa06e8560bcd69efdeba62c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTlsBackendCertOnlyPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QTlsBackendCertOnlyPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QTlsBackendCertOnlyPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/tls/qcertonlybackend.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTlsBackendCertOnlyPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTlsBackendCertOnlyPlugin "${_IMPORT_PREFIX}/plugins/tls/qcertonlybackend.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f102858235c967c4c5c00ff267f29da004b5c1c9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QTlsBackendCertOnlyPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QTlsBackendCertOnlyPlugin +add_library(Qt6::QTlsBackendCertOnlyPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QTlsBackendCertOnlyPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "0" + QT_MODULE "Network" + QT_PLUGIN_CLASS_NAME "QTlsBackendCertOnly" + QT_PLUGIN_TYPE "tls" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QTlsBackendCertOnlyPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendCertOnlyPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d15df7932ada184ce87b99aa08d566de159dd17e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QTlsBackendOpenSSLPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QTlsBackendOpenSSLPlugin) +get_target_property(_qt_imported_location Qt6::QTlsBackendOpenSSLPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QTlsBackendOpenSSLPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QTlsBackendOpenSSLPlugin" for configuration "Release" +set_property(TARGET Qt6::QTlsBackendOpenSSLPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTlsBackendOpenSSLPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QTlsBackendOpenSSLPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QTlsBackendOpenSSLPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTlsBackendOpenSSLPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QTlsBackendOpenSSLPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..26dde55cc7d4e670102a1cf7246a5482d78e1b1a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtBase" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendOpenSSLPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendOpenSSLPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendOpenSSLPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendOpenSSLPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..142032961b8efa1b67cc7743c16c5284c4296121 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendOpenSSLPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d78390153355d638a755e6b0c42e19d271a7e8b1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTlsBackendOpenSSLPlugin" for configuration "Debug" +set_property(TARGET Qt6::QTlsBackendOpenSSLPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QTlsBackendOpenSSLPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/tls/qopensslbackendd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTlsBackendOpenSSLPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTlsBackendOpenSSLPlugin "${_IMPORT_PREFIX}/plugins/tls/qopensslbackendd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2003d81e20c271b6a757ed214a12b042c22e7eb0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTlsBackendOpenSSLPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QTlsBackendOpenSSLPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QTlsBackendOpenSSLPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/tls/qopensslbackend.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTlsBackendOpenSSLPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTlsBackendOpenSSLPlugin "${_IMPORT_PREFIX}/plugins/tls/qopensslbackend.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..789a6cbdacd612c3bdc34b85ca4d3241847ed365 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QTlsBackendOpenSSLPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QTlsBackendOpenSSLPlugin +add_library(Qt6::QTlsBackendOpenSSLPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QTlsBackendOpenSSLPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Network" + QT_PLUGIN_CLASS_NAME "QTlsBackendOpenSSL" + QT_PLUGIN_TYPE "tls" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-plugin-QTlsBackendOpenSSLPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QTlsBackendOpenSSLPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..44910eca2faea3fe6279de5d9d1fa424edc693cd --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6OpenGL +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::OpenGL) +get_target_property(_qt_imported_location Qt6::OpenGL IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::OpenGL IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::OpenGL IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::OpenGL IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::OpenGL IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::OpenGL IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::OpenGL" for configuration "Release" +set_property(TARGET Qt6::OpenGL APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::OpenGL" for configuration "MinSizeRel" +set_property(TARGET Qt6::OpenGL APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::OpenGL PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::OpenGLPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f502f2d067523b447e8c1e53e9b9cf47c814e06c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLDependencies.cmake") + _qt_internal_suggest_dependency_debugging(OpenGL + __qt_OpenGL_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6OpenGL_FOUND") + set("Qt6OpenGL_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6OpenGL_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6OpenGL) instead. + set(Qt6OpenGL_LIBRARIES "Qt6::OpenGL") + + get_target_property(_Qt6OpenGL_OWN_INCLUDE_DIRS + Qt6::OpenGL INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6OpenGL_OWN_INCLUDE_DIRS) + set(_Qt6OpenGL_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::OpenGLPrivate) + get_target_property(_Qt6OpenGL_OWN_PRIVATE_INCLUDE_DIRS + Qt6::OpenGLPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6OpenGL_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6OpenGL_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6OpenGL_DEFINITIONS + Qt6::OpenGL INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6OpenGL_DEFINITIONS) + set(Qt6OpenGL_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6OpenGL_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6OpenGL_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6OpenGL_COMPILE_DEFINITIONS + Qt6::OpenGL INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6OpenGL_COMPILE_DEFINITIONS) + set(Qt6OpenGL_COMPILE_DEFINITIONS "") + endif() + + set(Qt6OpenGL_INCLUDE_DIRS + ${_Qt6OpenGL_OWN_INCLUDE_DIRS}) + + set(Qt6OpenGL_PRIVATE_INCLUDE_DIRS + ${_Qt6OpenGL_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6OpenGL_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6OpenGL${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6OpenGL${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6OpenGL_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6OpenGL${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6OpenGL${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6OpenGL_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6OpenGL_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6OpenGL_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6OpenGL_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::OpenGL) + qt_make_features_available(Qt6::OpenGL) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "OpenGL") + + get_target_property(_qt_module_target_type "Qt6::OpenGL" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::OpenGL MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6OpenGL_FOUND FALSE) + if(NOT DEFINED Qt6OpenGL_NOT_FOUND_MESSAGE) + set(Qt6OpenGL_NOT_FOUND_MESSAGE + "Target \"Qt6::OpenGL\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6OpenGL_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..101a7a70b97428e3ae446e42a7211ae2bceb9774 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f4290418cf4415fbeb8e80bc886495e0c10ee89c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLDependencies.cmake @@ -0,0 +1,48 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6OpenGL_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_OpenGL_third_party_deps "WrapVulkanHeaders\;TRUE\;\;\;") +set(__qt_OpenGL_third_party_package_WrapVulkanHeaders_provided_targets "WrapVulkanHeaders::WrapVulkanHeaders") + +_qt_internal_find_third_party_dependencies("OpenGL" __qt_OpenGL_third_party_deps) + +# Find Qt tool package. +set(__qt_OpenGL_tool_deps "") +_qt_internal_find_tool_dependencies("OpenGL" __qt_OpenGL_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_OpenGL_target_deps "Qt6Core\;6.8.1;Qt6Gui\;6.8.1") +set(__qt_OpenGL_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("OpenGL" __qt_OpenGL_target_deps + __qt_OpenGL_find_dependency_paths) + +set(_Qt6OpenGL_MODULE_DEPENDENCIES "Core;Gui") +set(Qt6OpenGL_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c154c8fa96314fe1432d0e24b5e127bfead1a386 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::OpenGL" for configuration "Debug" +set_property(TARGET Qt6::OpenGL APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::OpenGL PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6OpenGLd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6OpenGLd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::OpenGL ) +list(APPEND _cmake_import_check_files_for_Qt6::OpenGL "${_IMPORT_PREFIX}/lib/Qt6OpenGLd.lib" "${_IMPORT_PREFIX}/bin/Qt6OpenGLd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a5633c1e14c4f65fde1b74aabb82dbd36823cf2c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::OpenGL" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::OpenGL APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::OpenGL PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6OpenGL.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6OpenGL.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::OpenGL ) +list(APPEND _cmake_import_check_files_for_Qt6::OpenGL "${_IMPORT_PREFIX}/lib/Qt6OpenGL.lib" "${_IMPORT_PREFIX}/bin/Qt6OpenGL.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5247ed349a2776414f02c823bb552ed0eaec1bc6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLTargets.cmake @@ -0,0 +1,160 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::OpenGL Qt6::OpenGLPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::OpenGL +add_library(Qt6::OpenGL SHARED IMPORTED) + +set_target_properties(Qt6::OpenGL PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_OPENGL_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtOpenGL;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::Gui;\$" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6opengl_metatypes.json>" + _qt_config_module_name "opengl" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtOpenGL" + _qt_module_interface_name "OpenGL" + _qt_package_name "Qt6OpenGL" + _qt_package_version "6.8.1" + _qt_private_module_target_name "OpenGLPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-OpenGL" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::OpenGLPrivate +add_library(Qt6::OpenGLPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::OpenGLPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtOpenGL/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtOpenGL/6.8.1/QtOpenGL>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::GuiPrivate;Qt6::OpenGL" + _qt_config_module_name "opengl_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6OpenGL" + _qt_package_version "6.8.1" + _qt_public_module_target_name "OpenGL" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-OpenGL" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Core" "Qt6::Gui" "Qt6::CorePrivate" "Qt6::GuiPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7d5af8b82a3b46ab374ed58d53316cd39dbaee76 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "OpenGL;OpenGLPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b9da6b4d6a3a1898e68041d0650e4ad2d7673340 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGL/Qt6OpenGLVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "OpenGL;OpenGLPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8dd9ec08307f2ad8999ea331fe2a7d7db525ad73 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6OpenGLWidgets +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::OpenGLWidgets) +get_target_property(_qt_imported_location Qt6::OpenGLWidgets IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::OpenGLWidgets IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::OpenGLWidgets IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::OpenGLWidgets IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::OpenGLWidgets IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::OpenGLWidgets IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::OpenGLWidgets" for configuration "Release" +set_property(TARGET Qt6::OpenGLWidgets APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::OpenGLWidgets" for configuration "MinSizeRel" +set_property(TARGET Qt6::OpenGLWidgets APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::OpenGLWidgets PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::OpenGLWidgetsPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..aa018161b487f65dddcc80b16bcbe87d4e4475b0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsDependencies.cmake") + _qt_internal_suggest_dependency_debugging(OpenGLWidgets + __qt_OpenGLWidgets_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6OpenGLWidgets_FOUND") + set("Qt6OpenGLWidgets_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6OpenGLWidgets_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6OpenGLWidgets) instead. + set(Qt6OpenGLWidgets_LIBRARIES "Qt6::OpenGLWidgets") + + get_target_property(_Qt6OpenGLWidgets_OWN_INCLUDE_DIRS + Qt6::OpenGLWidgets INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6OpenGLWidgets_OWN_INCLUDE_DIRS) + set(_Qt6OpenGLWidgets_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::OpenGLWidgetsPrivate) + get_target_property(_Qt6OpenGLWidgets_OWN_PRIVATE_INCLUDE_DIRS + Qt6::OpenGLWidgetsPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6OpenGLWidgets_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6OpenGLWidgets_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6OpenGLWidgets_DEFINITIONS + Qt6::OpenGLWidgets INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6OpenGLWidgets_DEFINITIONS) + set(Qt6OpenGLWidgets_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6OpenGLWidgets_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6OpenGLWidgets_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6OpenGLWidgets_COMPILE_DEFINITIONS + Qt6::OpenGLWidgets INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6OpenGLWidgets_COMPILE_DEFINITIONS) + set(Qt6OpenGLWidgets_COMPILE_DEFINITIONS "") + endif() + + set(Qt6OpenGLWidgets_INCLUDE_DIRS + ${_Qt6OpenGLWidgets_OWN_INCLUDE_DIRS}) + + set(Qt6OpenGLWidgets_PRIVATE_INCLUDE_DIRS + ${_Qt6OpenGLWidgets_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6OpenGLWidgets_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6OpenGLWidgets${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6OpenGLWidgets${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6OpenGLWidgets_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6OpenGLWidgets${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6OpenGLWidgets${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6OpenGLWidgets_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6OpenGLWidgets_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6OpenGLWidgets_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6OpenGLWidgets_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::OpenGLWidgets) + qt_make_features_available(Qt6::OpenGLWidgets) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "OpenGLWidgets") + + get_target_property(_qt_module_target_type "Qt6::OpenGLWidgets" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::OpenGLWidgets MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6OpenGLWidgets_FOUND FALSE) + if(NOT DEFINED Qt6OpenGLWidgets_NOT_FOUND_MESSAGE) + set(Qt6OpenGLWidgets_NOT_FOUND_MESSAGE + "Target \"Qt6::OpenGLWidgets\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6OpenGLWidgets_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1939a7a71ccd8a5c14f61f5564b5b507e9b9a6b4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ca8975e9b4a7a22185fc66509d979c03ecf5bb70 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6OpenGLWidgets_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_OpenGLWidgets_third_party_deps "") + +_qt_internal_find_third_party_dependencies("OpenGLWidgets" __qt_OpenGLWidgets_third_party_deps) + +# Find Qt tool package. +set(__qt_OpenGLWidgets_tool_deps "") +_qt_internal_find_tool_dependencies("OpenGLWidgets" __qt_OpenGLWidgets_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_OpenGLWidgets_target_deps "Qt6OpenGL\;6.8.1;Qt6Widgets\;6.8.1") +set(__qt_OpenGLWidgets_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("OpenGLWidgets" __qt_OpenGLWidgets_target_deps + __qt_OpenGLWidgets_find_dependency_paths) + +set(_Qt6OpenGLWidgets_MODULE_DEPENDENCIES "OpenGL;Widgets") +set(Qt6OpenGLWidgets_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c918ba0070cac0e6b7b2fe031264f579b2007a55 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::OpenGLWidgets" for configuration "Debug" +set_property(TARGET Qt6::OpenGLWidgets APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::OpenGLWidgets PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6OpenGLWidgetsd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6OpenGLWidgetsd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::OpenGLWidgets ) +list(APPEND _cmake_import_check_files_for_Qt6::OpenGLWidgets "${_IMPORT_PREFIX}/lib/Qt6OpenGLWidgetsd.lib" "${_IMPORT_PREFIX}/bin/Qt6OpenGLWidgetsd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..267c7960b80438f4771c3ed369f4f104a96f5535 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::OpenGLWidgets" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::OpenGLWidgets APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::OpenGLWidgets PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6OpenGLWidgets.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6OpenGLWidgets.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::OpenGLWidgets ) +list(APPEND _cmake_import_check_files_for_Qt6::OpenGLWidgets "${_IMPORT_PREFIX}/lib/Qt6OpenGLWidgets.lib" "${_IMPORT_PREFIX}/bin/Qt6OpenGLWidgets.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..27cce21c016a8a9cec54305adc3124bfb150cc27 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsTargets.cmake @@ -0,0 +1,159 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::OpenGLWidgets Qt6::OpenGLWidgetsPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::OpenGLWidgets +add_library(Qt6::OpenGLWidgets SHARED IMPORTED) + +set_target_properties(Qt6::OpenGLWidgets PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_OPENGLWIDGETS_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtOpenGLWidgets;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::OpenGL;Qt6::Widgets" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6openglwidgets_metatypes.json>" + _qt_config_module_name "openglwidgets" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtOpenGLWidgets" + _qt_module_interface_name "OpenGLWidgets" + _qt_package_name "Qt6OpenGLWidgets" + _qt_package_version "6.8.1" + _qt_private_module_target_name "OpenGLWidgetsPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-OpenGLWidgets" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::OpenGLWidgetsPrivate +add_library(Qt6::OpenGLWidgetsPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::OpenGLWidgetsPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtOpenGLWidgets/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtOpenGLWidgets/6.8.1/QtOpenGLWidgets>" + INTERFACE_LINK_LIBRARIES "Qt6::OpenGLWidgets" + _qt_config_module_name "openglwidgets_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6OpenGLWidgets" + _qt_package_version "6.8.1" + _qt_public_module_target_name "OpenGLWidgets" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-OpenGLWidgets" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6OpenGLWidgetsTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::OpenGL" "Qt6::Widgets" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..eb0056148d1ef035bf766bb01639e83ee1b7068e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "OpenGLWidgets;OpenGLWidgetsPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..041d54769a9a810be75f59e1c2509c3f8a32f189 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6OpenGLWidgets/Qt6OpenGLWidgetsVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "OpenGLWidgets;OpenGLWidgetsPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e94aeec4c81c5c679b7834cd9d9dc68e6ed67de9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6PacketProtocolPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::PacketProtocolPrivate) +get_target_property(_qt_imported_location Qt6::PacketProtocolPrivate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::PacketProtocolPrivate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::PacketProtocolPrivate" for configuration "Release" +set_property(TARGET Qt6::PacketProtocolPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::PacketProtocolPrivate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::PacketProtocolPrivate" for configuration "MinSizeRel" +set_property(TARGET Qt6::PacketProtocolPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::PacketProtocolPrivate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::PacketProtocolPrivate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..748d2a066477d824ab1bc2312c6d014db2b43763 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(PacketProtocolPrivate + __qt_PacketProtocolPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6PacketProtocolPrivate_FOUND") + set("Qt6PacketProtocolPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6PacketProtocolPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6PacketProtocolPrivate) instead. + set(Qt6PacketProtocolPrivate_LIBRARIES "Qt6::PacketProtocolPrivate") + + get_target_property(_Qt6PacketProtocolPrivate_OWN_INCLUDE_DIRS + Qt6::PacketProtocolPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6PacketProtocolPrivate_OWN_INCLUDE_DIRS) + set(_Qt6PacketProtocolPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::PacketProtocolPrivatePrivate) + get_target_property(_Qt6PacketProtocolPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::PacketProtocolPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6PacketProtocolPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6PacketProtocolPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6PacketProtocolPrivate_DEFINITIONS + Qt6::PacketProtocolPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6PacketProtocolPrivate_DEFINITIONS) + set(Qt6PacketProtocolPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6PacketProtocolPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6PacketProtocolPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6PacketProtocolPrivate_COMPILE_DEFINITIONS + Qt6::PacketProtocolPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6PacketProtocolPrivate_COMPILE_DEFINITIONS) + set(Qt6PacketProtocolPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6PacketProtocolPrivate_INCLUDE_DIRS + ${_Qt6PacketProtocolPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6PacketProtocolPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6PacketProtocolPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6PacketProtocolPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6PacketProtocolPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6PacketProtocolPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6PacketProtocolPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6PacketProtocolPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6PacketProtocolPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6PacketProtocolPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6PacketProtocolPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6PacketProtocolPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6PacketProtocolPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::PacketProtocolPrivate) + qt_make_features_available(Qt6::PacketProtocolPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "PacketProtocolPrivate") + + get_target_property(_qt_module_target_type "Qt6::PacketProtocolPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::PacketProtocolPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6PacketProtocolPrivate_FOUND FALSE) + if(NOT DEFINED Qt6PacketProtocolPrivate_NOT_FOUND_MESSAGE) + set(Qt6PacketProtocolPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::PacketProtocolPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6PacketProtocolPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e8e8a97477dd0cab3d68613a761a6cc6fdbf8d7b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..06e85db6ffb7b7073e7d6c212b72e0ea9fd243a8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6PacketProtocolPrivate_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_PacketProtocolPrivate_third_party_deps "") + +_qt_internal_find_third_party_dependencies("PacketProtocolPrivate" __qt_PacketProtocolPrivate_third_party_deps) + +# Find Qt tool package. +set(__qt_PacketProtocolPrivate_tool_deps "") +_qt_internal_find_tool_dependencies("PacketProtocolPrivate" __qt_PacketProtocolPrivate_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_PacketProtocolPrivate_target_deps "Qt6Core\;6.8.1") +set(__qt_PacketProtocolPrivate_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("PacketProtocolPrivate" __qt_PacketProtocolPrivate_target_deps + __qt_PacketProtocolPrivate_find_dependency_paths) + +set(_Qt6PacketProtocolPrivate_MODULE_DEPENDENCIES "Core") +set(Qt6PacketProtocolPrivate_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2c5ef429017b063bd23cfe2441ea433b8e9d9002 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::PacketProtocolPrivate" for configuration "Debug" +set_property(TARGET Qt6::PacketProtocolPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::PacketProtocolPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6PacketProtocold.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::PacketProtocolPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::PacketProtocolPrivate "${_IMPORT_PREFIX}/lib/Qt6PacketProtocold.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ad97443248b69603f5deedc5a3cc36a03f9bcb63 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::PacketProtocolPrivate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::PacketProtocolPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::PacketProtocolPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6PacketProtocol.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::PacketProtocolPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::PacketProtocolPrivate "${_IMPORT_PREFIX}/lib/Qt6PacketProtocol.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..126e8ce2728f457e5289ffdb5f9cdb64c4e491bd --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateTargets.cmake @@ -0,0 +1,125 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::PacketProtocolPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::PacketProtocolPrivate +add_library(Qt6::PacketProtocolPrivate STATIC IMPORTED) + +set_target_properties(Qt6::PacketProtocolPrivate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_PACKETPROTOCOL_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtPacketProtocol;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtPacketProtocol/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtPacketProtocol/6.8.1/QtPacketProtocol>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;\$" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6packetprotocolprivate_metatypes.json>" + _qt_config_module_name "packetprotocol_private" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_include_name "QtPacketProtocol" + _qt_module_interface_name "PacketProtocol" + _qt_package_name "Qt6PacketProtocolPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-PacketProtocolPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6PacketProtocolPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..837d5d5ed7dc8777fb5f2a023d8818869b451ded --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "PacketProtocolPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..02fc000769b9ce92d26ee31d38f7dae9ba1a3472 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PacketProtocolPrivate/Qt6PacketProtocolPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "PacketProtocolPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..62cf5fd45c04749d4d3a252f502dcd1129b8baef --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,6 @@ +# Additional target information for Qt6PngPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::PngPrivate) + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4950aa6e3e0cd10fd6ad87660a80d208222f5a0b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(PngPrivate + __qt_PngPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6PngPrivate_FOUND") + set("Qt6PngPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6PngPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6PngPrivate) instead. + set(Qt6PngPrivate_LIBRARIES "Qt6::PngPrivate") + + get_target_property(_Qt6PngPrivate_OWN_INCLUDE_DIRS + Qt6::PngPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6PngPrivate_OWN_INCLUDE_DIRS) + set(_Qt6PngPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::PngPrivatePrivate) + get_target_property(_Qt6PngPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::PngPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6PngPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6PngPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6PngPrivate_DEFINITIONS + Qt6::PngPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6PngPrivate_DEFINITIONS) + set(Qt6PngPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6PngPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6PngPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6PngPrivate_COMPILE_DEFINITIONS + Qt6::PngPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6PngPrivate_COMPILE_DEFINITIONS) + set(Qt6PngPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6PngPrivate_INCLUDE_DIRS + ${_Qt6PngPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6PngPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6PngPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6PngPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6PngPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6PngPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6PngPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6PngPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6PngPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6PngPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6PngPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6PngPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6PngPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::PngPrivate) + qt_make_features_available(Qt6::PngPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "PngPrivate") + + get_target_property(_qt_module_target_type "Qt6::PngPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::PngPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6PngPrivate_FOUND FALSE) + if(NOT DEFINED Qt6PngPrivate_NOT_FOUND_MESSAGE) + set(Qt6PngPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::PngPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6PngPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..50ca6710049105d2789dc25c2cb92fa1a73adb8b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..52cba1218f4b1685fa79e5e9e6a595e662516f40 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateTargets.cmake @@ -0,0 +1,124 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::PngPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::PngPrivate +add_library(Qt6::PngPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::PngPrivate PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "QT_PNG_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtPng;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtPng/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtPng/6.8.1/QtPng>" + _qt_config_module_name "png_private" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtPng" + _qt_module_interface_name "Png" + _qt_module_is_3rdparty_header_library "TRUE" + _qt_module_skip_depends_include "TRUE" + _qt_package_name "Qt6PngPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-bundled-3rdparty-module-PngPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6PngPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fd9dc189aed6cd33075d506039f6f2a31661c144 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "PngPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..df245183916e6059f8152394f032e18c6a9cb421 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PngPrivate/Qt6PngPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "PngPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5410e03bccbfd3b0657d0b100237a582148bac3c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6PrintSupport +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::PrintSupport) +get_target_property(_qt_imported_location Qt6::PrintSupport IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::PrintSupport IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::PrintSupport IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::PrintSupport IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::PrintSupport IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::PrintSupport IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::PrintSupport" for configuration "Release" +set_property(TARGET Qt6::PrintSupport APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::PrintSupport" for configuration "MinSizeRel" +set_property(TARGET Qt6::PrintSupport APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::PrintSupport PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::PrintSupportPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..278a310c78f6d0a2be949dbc41d69b625933ba17 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportDependencies.cmake") + _qt_internal_suggest_dependency_debugging(PrintSupport + __qt_PrintSupport_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6PrintSupport_FOUND") + set("Qt6PrintSupport_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6PrintSupport_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6PrintSupport) instead. + set(Qt6PrintSupport_LIBRARIES "Qt6::PrintSupport") + + get_target_property(_Qt6PrintSupport_OWN_INCLUDE_DIRS + Qt6::PrintSupport INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6PrintSupport_OWN_INCLUDE_DIRS) + set(_Qt6PrintSupport_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::PrintSupportPrivate) + get_target_property(_Qt6PrintSupport_OWN_PRIVATE_INCLUDE_DIRS + Qt6::PrintSupportPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6PrintSupport_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6PrintSupport_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6PrintSupport_DEFINITIONS + Qt6::PrintSupport INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6PrintSupport_DEFINITIONS) + set(Qt6PrintSupport_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6PrintSupport_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6PrintSupport_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6PrintSupport_COMPILE_DEFINITIONS + Qt6::PrintSupport INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6PrintSupport_COMPILE_DEFINITIONS) + set(Qt6PrintSupport_COMPILE_DEFINITIONS "") + endif() + + set(Qt6PrintSupport_INCLUDE_DIRS + ${_Qt6PrintSupport_OWN_INCLUDE_DIRS}) + + set(Qt6PrintSupport_PRIVATE_INCLUDE_DIRS + ${_Qt6PrintSupport_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6PrintSupport_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6PrintSupport${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6PrintSupport${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6PrintSupport_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6PrintSupport${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6PrintSupport${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6PrintSupport_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6PrintSupport_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6PrintSupport_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6PrintSupport_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::PrintSupport) + qt_make_features_available(Qt6::PrintSupport) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "PrintSupport") + + get_target_property(_qt_module_target_type "Qt6::PrintSupport" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::PrintSupport MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6PrintSupport_FOUND FALSE) + if(NOT DEFINED Qt6PrintSupport_NOT_FOUND_MESSAGE) + set(Qt6PrintSupport_NOT_FOUND_MESSAGE + "Target \"Qt6::PrintSupport\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6PrintSupport_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7079a9426a070f976498907c2a0179b55df24757 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..41caa5a98cb21526ebde10de988fe74c7f3716c9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6PrintSupport_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_PrintSupport_third_party_deps "") + +_qt_internal_find_third_party_dependencies("PrintSupport" __qt_PrintSupport_third_party_deps) + +# Find Qt tool package. +set(__qt_PrintSupport_tool_deps "") +_qt_internal_find_tool_dependencies("PrintSupport" __qt_PrintSupport_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_PrintSupport_target_deps "Qt6Core\;6.8.1;Qt6Gui\;6.8.1;Qt6Widgets\;6.8.1") +set(__qt_PrintSupport_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("PrintSupport" __qt_PrintSupport_target_deps + __qt_PrintSupport_find_dependency_paths) + +set(_Qt6PrintSupport_MODULE_DEPENDENCIES "Core;Gui;Widgets") +set(Qt6PrintSupport_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportPlugins.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportPlugins.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7e464e570a88284c0d7099d700a5d909ac6c2a0e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportPlugins.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_PLUGIN_INCLUSION OFF) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION) + __qt_internal_include_plugin_packages(PrintSupport) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a41946702dd76aef2e3f7d4baf84479f28ea2b11 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::PrintSupport" for configuration "Debug" +set_property(TARGET Qt6::PrintSupport APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::PrintSupport PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6PrintSupportd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6PrintSupportd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::PrintSupport ) +list(APPEND _cmake_import_check_files_for_Qt6::PrintSupport "${_IMPORT_PREFIX}/lib/Qt6PrintSupportd.lib" "${_IMPORT_PREFIX}/bin/Qt6PrintSupportd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..498e5678df3c12eeaba8e56b6092a691f1f39e54 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::PrintSupport" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::PrintSupport APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::PrintSupport PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6PrintSupport.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6PrintSupport.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::PrintSupport ) +list(APPEND _cmake_import_check_files_for_Qt6::PrintSupport "${_IMPORT_PREFIX}/lib/Qt6PrintSupport.lib" "${_IMPORT_PREFIX}/bin/Qt6PrintSupport.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ebddb93754a046aa9c9222f43159b6c710aa5782 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportTargets.cmake @@ -0,0 +1,169 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::PrintSupport Qt6::PrintSupportPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::PrintSupport +add_library(Qt6::PrintSupport SHARED IMPORTED) + +set_target_properties(Qt6::PrintSupport PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_PRINTSUPPORT_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtPrintSupport;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::Gui;Qt6::Widgets;comdlg32;winspool" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6printsupport_metatypes.json>" + MODULE_PLUGIN_TYPES "printsupport" + QT_DISABLED_PRIVATE_FEATURES "cups;cupsjobwidget" + QT_DISABLED_PUBLIC_FEATURES "cups;cupsjobwidget" + QT_ENABLED_PRIVATE_FEATURES "cupspassworddialog" + QT_ENABLED_PUBLIC_FEATURES "printer;printpreviewwidget;printdialog;printpreviewdialog" + QT_QMAKE_PRIVATE_CONFIG "" + QT_QMAKE_PUBLIC_CONFIG "" + QT_QMAKE_PUBLIC_QT_CONFIG "" + _qt_config_module_name "printsupport" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_has_qpa_headers "TRUE" + _qt_module_include_name "QtPrintSupport" + _qt_module_interface_name "PrintSupport" + _qt_package_name "Qt6PrintSupport" + _qt_package_version "6.8.1" + _qt_private_module_target_name "PrintSupportPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-PrintSupport" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Create imported target Qt6::PrintSupportPrivate +add_library(Qt6::PrintSupportPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::PrintSupportPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtPrintSupport/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtPrintSupport/6.8.1/QtPrintSupport>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::GuiPrivate;Qt6::WidgetsPrivate;Qt6::PrintSupport" + _qt_config_module_name "printsupport_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6PrintSupport" + _qt_package_version "6.8.1" + _qt_public_module_target_name "PrintSupport" + _qt_sbom_spdx_id "SPDXRef-Package-qtbase-qt-module-PrintSupport" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtbase-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtbase-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtbase" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6PrintSupportTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Core" "Qt6::Gui" "Qt6::Widgets" "Qt6::CorePrivate" "Qt6::GuiPrivate" "Qt6::WidgetsPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..52a18baa825e3f1667df5f39415d64fb43bd10c1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "PrintSupport;PrintSupportPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0bb3d20c620e0c9afdf46f8f44fce73f5fd28892 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6PrintSupport/Qt6PrintSupportVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "PrintSupport;PrintSupportPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d5f5554d8f2088320fbd185e45a5a95a2c942709 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,6 @@ +# Additional target information for Qt6QDocCatchConversionsPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QDocCatchConversionsPrivate) + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..92c6431048948f8eb1bf51854248750752cc8194 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(QDocCatchConversionsPrivate + __qt_QDocCatchConversionsPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6QDocCatchConversionsPrivate_FOUND") + set("Qt6QDocCatchConversionsPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6QDocCatchConversionsPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6QDocCatchConversionsPrivate) instead. + set(Qt6QDocCatchConversionsPrivate_LIBRARIES "Qt6::QDocCatchConversionsPrivate") + + get_target_property(_Qt6QDocCatchConversionsPrivate_OWN_INCLUDE_DIRS + Qt6::QDocCatchConversionsPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QDocCatchConversionsPrivate_OWN_INCLUDE_DIRS) + set(_Qt6QDocCatchConversionsPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QDocCatchConversionsPrivatePrivate) + get_target_property(_Qt6QDocCatchConversionsPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QDocCatchConversionsPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QDocCatchConversionsPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6QDocCatchConversionsPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6QDocCatchConversionsPrivate_DEFINITIONS + Qt6::QDocCatchConversionsPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QDocCatchConversionsPrivate_DEFINITIONS) + set(Qt6QDocCatchConversionsPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6QDocCatchConversionsPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6QDocCatchConversionsPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6QDocCatchConversionsPrivate_COMPILE_DEFINITIONS + Qt6::QDocCatchConversionsPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QDocCatchConversionsPrivate_COMPILE_DEFINITIONS) + set(Qt6QDocCatchConversionsPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6QDocCatchConversionsPrivate_INCLUDE_DIRS + ${_Qt6QDocCatchConversionsPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6QDocCatchConversionsPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6QDocCatchConversionsPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6QDocCatchConversionsPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6QDocCatchConversionsPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6QDocCatchConversionsPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6QDocCatchConversionsPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6QDocCatchConversionsPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6QDocCatchConversionsPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6QDocCatchConversionsPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QDocCatchConversionsPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QDocCatchConversionsPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6QDocCatchConversionsPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::QDocCatchConversionsPrivate) + qt_make_features_available(Qt6::QDocCatchConversionsPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "QDocCatchConversionsPrivate") + + get_target_property(_qt_module_target_type "Qt6::QDocCatchConversionsPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::QDocCatchConversionsPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6QDocCatchConversionsPrivate_FOUND FALSE) + if(NOT DEFINED Qt6QDocCatchConversionsPrivate_NOT_FOUND_MESSAGE) + set(Qt6QDocCatchConversionsPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::QDocCatchConversionsPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6QDocCatchConversionsPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..954fabc46eef95232760a6c5ac3e94bc9e32ce10 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..27c625d27f81404730c5d7da6c7516d8ccebdf93 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateTargets.cmake @@ -0,0 +1,121 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QDocCatchConversionsPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QDocCatchConversionsPrivate +add_library(Qt6::QDocCatchConversionsPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::QDocCatchConversionsPrivate PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "QT_QDOCCATCHCONVERSIONS_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQDocCatchConversions;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQDocCatchConversions/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQDocCatchConversions/6.8.1/QtQDocCatchConversions>;${_IMPORT_PREFIX}/include/QtQDocCatchConversions" + _qt_config_module_name "qdoccatchconversions_private" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_include_name "QtQDocCatchConversions" + _qt_module_interface_name "QDocCatchConversions" + _qt_package_name "Qt6QDocCatchConversionsPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-module-QDocCatchConversionsPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchConversionsPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c3a86987f7f98589c6a460192523d9a254ed8d1b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QDocCatchConversionsPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c41b82496f9c08d72838dda99ebc2707597a47f9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchConversionsPrivate/Qt6QDocCatchConversionsPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QDocCatchConversionsPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..39ccac9fdc871d922fa0c28513c2b65f22d55176 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,6 @@ +# Additional target information for Qt6QDocCatchGeneratorsPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QDocCatchGeneratorsPrivate) + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8c4510c39f616c295b586be5b6168ecf2c43ef0e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(QDocCatchGeneratorsPrivate + __qt_QDocCatchGeneratorsPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6QDocCatchGeneratorsPrivate_FOUND") + set("Qt6QDocCatchGeneratorsPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6QDocCatchGeneratorsPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6QDocCatchGeneratorsPrivate) instead. + set(Qt6QDocCatchGeneratorsPrivate_LIBRARIES "Qt6::QDocCatchGeneratorsPrivate") + + get_target_property(_Qt6QDocCatchGeneratorsPrivate_OWN_INCLUDE_DIRS + Qt6::QDocCatchGeneratorsPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QDocCatchGeneratorsPrivate_OWN_INCLUDE_DIRS) + set(_Qt6QDocCatchGeneratorsPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QDocCatchGeneratorsPrivatePrivate) + get_target_property(_Qt6QDocCatchGeneratorsPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QDocCatchGeneratorsPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QDocCatchGeneratorsPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6QDocCatchGeneratorsPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6QDocCatchGeneratorsPrivate_DEFINITIONS + Qt6::QDocCatchGeneratorsPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QDocCatchGeneratorsPrivate_DEFINITIONS) + set(Qt6QDocCatchGeneratorsPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6QDocCatchGeneratorsPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6QDocCatchGeneratorsPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6QDocCatchGeneratorsPrivate_COMPILE_DEFINITIONS + Qt6::QDocCatchGeneratorsPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QDocCatchGeneratorsPrivate_COMPILE_DEFINITIONS) + set(Qt6QDocCatchGeneratorsPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6QDocCatchGeneratorsPrivate_INCLUDE_DIRS + ${_Qt6QDocCatchGeneratorsPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6QDocCatchGeneratorsPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6QDocCatchGeneratorsPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6QDocCatchGeneratorsPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6QDocCatchGeneratorsPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6QDocCatchGeneratorsPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6QDocCatchGeneratorsPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6QDocCatchGeneratorsPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6QDocCatchGeneratorsPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6QDocCatchGeneratorsPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QDocCatchGeneratorsPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QDocCatchGeneratorsPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6QDocCatchGeneratorsPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::QDocCatchGeneratorsPrivate) + qt_make_features_available(Qt6::QDocCatchGeneratorsPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "QDocCatchGeneratorsPrivate") + + get_target_property(_qt_module_target_type "Qt6::QDocCatchGeneratorsPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::QDocCatchGeneratorsPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6QDocCatchGeneratorsPrivate_FOUND FALSE) + if(NOT DEFINED Qt6QDocCatchGeneratorsPrivate_NOT_FOUND_MESSAGE) + set(Qt6QDocCatchGeneratorsPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::QDocCatchGeneratorsPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6QDocCatchGeneratorsPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0af28bb9618cbbb35df9e55b343a26e71bd673d8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9dadaa1b8ff9a5e0c404e67343be01f2f191d4d0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateTargets.cmake @@ -0,0 +1,121 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QDocCatchGeneratorsPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QDocCatchGeneratorsPrivate +add_library(Qt6::QDocCatchGeneratorsPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::QDocCatchGeneratorsPrivate PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "QT_QDOCCATCHGENERATORS_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQDocCatchGenerators;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQDocCatchGenerators/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQDocCatchGenerators/6.8.1/QtQDocCatchGenerators>;${_IMPORT_PREFIX}/include/QtQDocCatchGenerators" + _qt_config_module_name "qdoccatchgenerators_private" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_include_name "QtQDocCatchGenerators" + _qt_module_interface_name "QDocCatchGenerators" + _qt_package_name "Qt6QDocCatchGeneratorsPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-module-QDocCatchGeneratorsPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchGeneratorsPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..941396f0ac5d93bbd7e82120e40899bfba35a24f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QDocCatchGeneratorsPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..49f0587714da0e989c996bf6ea0e5ea1b7acd2e1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchGeneratorsPrivate/Qt6QDocCatchGeneratorsPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QDocCatchGeneratorsPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..686b927bfdb0ab716de885e0f4ae929bebd587c9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,6 @@ +# Additional target information for Qt6QDocCatchPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QDocCatchPrivate) + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..50d9f5fe2b117a73066b1d3c9b98736f3b2b21ec --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(QDocCatchPrivate + __qt_QDocCatchPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6QDocCatchPrivate_FOUND") + set("Qt6QDocCatchPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6QDocCatchPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6QDocCatchPrivate) instead. + set(Qt6QDocCatchPrivate_LIBRARIES "Qt6::QDocCatchPrivate") + + get_target_property(_Qt6QDocCatchPrivate_OWN_INCLUDE_DIRS + Qt6::QDocCatchPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QDocCatchPrivate_OWN_INCLUDE_DIRS) + set(_Qt6QDocCatchPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QDocCatchPrivatePrivate) + get_target_property(_Qt6QDocCatchPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QDocCatchPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QDocCatchPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6QDocCatchPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6QDocCatchPrivate_DEFINITIONS + Qt6::QDocCatchPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QDocCatchPrivate_DEFINITIONS) + set(Qt6QDocCatchPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6QDocCatchPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6QDocCatchPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6QDocCatchPrivate_COMPILE_DEFINITIONS + Qt6::QDocCatchPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QDocCatchPrivate_COMPILE_DEFINITIONS) + set(Qt6QDocCatchPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6QDocCatchPrivate_INCLUDE_DIRS + ${_Qt6QDocCatchPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6QDocCatchPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6QDocCatchPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6QDocCatchPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6QDocCatchPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6QDocCatchPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6QDocCatchPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6QDocCatchPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6QDocCatchPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6QDocCatchPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QDocCatchPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QDocCatchPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6QDocCatchPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::QDocCatchPrivate) + qt_make_features_available(Qt6::QDocCatchPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "QDocCatchPrivate") + + get_target_property(_qt_module_target_type "Qt6::QDocCatchPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::QDocCatchPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6QDocCatchPrivate_FOUND FALSE) + if(NOT DEFINED Qt6QDocCatchPrivate_NOT_FOUND_MESSAGE) + set(Qt6QDocCatchPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::QDocCatchPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6QDocCatchPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..be3f7dc96aac00541896d1bd42dcbfebb1a2c6ab --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2ea9a6acaeea6fef1db32193fd8f0f144540eb4e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateTargets.cmake @@ -0,0 +1,123 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.0.0") + message(FATAL_ERROR "CMake >= 3.0.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.0.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QDocCatchPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QDocCatchPrivate +add_library(Qt6::QDocCatchPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::QDocCatchPrivate PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "QT_QDOCCATCH_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQDocCatch;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQDocCatch/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQDocCatch/6.8.1/QtQDocCatch>;${_IMPORT_PREFIX}/include/QtQDocCatch" + _qt_config_module_name "qdoccatch_private" + _qt_is_header_module "TRUE" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_include_name "QtQDocCatch" + _qt_module_interface_name "QDocCatch" + _qt_module_is_3rdparty_header_library "TRUE" + _qt_module_skip_depends_include "TRUE" + _qt_package_name "Qt6QDocCatchPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qttools-qt-bundled-3rdparty-module-QDocCatchPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qttools-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qttools-33c5dd1+HEAD" + _qt_sbom_spdx_repo_project_name_lowercase "qttools" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QDocCatchPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..eb2b0bd29fd8a9840c61a2decad518dbc1838e29 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QDocCatchPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dadb543f3647c5970c08cc3dca794661b2e1ab3a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QDocCatchPrivate/Qt6QDocCatchPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QDocCatchPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7547f5df0e8e2185980937e7fd54d9c71e932e8d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QDebugMessageServiceFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QDebugMessageServiceFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QDebugMessageServiceFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QDebugMessageServiceFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QDebugMessageServiceFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QDebugMessageServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QDebugMessageServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QDebugMessageServiceFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QDebugMessageServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QDebugMessageServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QDebugMessageServiceFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7e980a85782bd3cf9517ab6eb65c853e093c2a54 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QDebugMessageServiceFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDebugMessageServiceFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDebugMessageServiceFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDebugMessageServiceFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..143afd8e85e01a61879abfd002d68bb1b457b674 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QDebugMessageServiceFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ac8420fd1304897dc9d9866652a6cb65d67d5f85 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QDebugMessageServiceFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QDebugMessageServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QDebugMessageServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_messagesd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QDebugMessageServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QDebugMessageServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_messagesd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f0568179c0a79aa30213dd64c88e7d41b511d0d7 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QDebugMessageServiceFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QDebugMessageServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QDebugMessageServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_messages.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QDebugMessageServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QDebugMessageServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_messages.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3f571af13c6630b109d8cbfec33a90e9b022a35c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QDebugMessageServiceFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QDebugMessageServiceFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QDebugMessageServiceFactoryPlugin +add_library(Qt6::QDebugMessageServiceFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QDebugMessageServiceFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QDebugMessageServiceFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QDebugMessageServiceFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QDebugMessageServiceFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7a60841c09fd6b66af539b8596c07d14a4bba27a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QLocalClientConnectionFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QLocalClientConnectionFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QLocalClientConnectionFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QLocalClientConnectionFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QLocalClientConnectionFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QLocalClientConnectionFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QLocalClientConnectionFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QLocalClientConnectionFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QLocalClientConnectionFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QLocalClientConnectionFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QLocalClientConnectionFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..14862d22480a5d6d6bfea15f130814f0ea6614ec --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QLocalClientConnectionFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QLocalClientConnectionFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QLocalClientConnectionFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QLocalClientConnectionFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..957f70c07a0aa29619512ccc242f9dcf9081829b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QLocalClientConnectionFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e4123d4276f2c27d1464f96f8e426c2b61b76d47 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QLocalClientConnectionFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QLocalClientConnectionFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QLocalClientConnectionFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_locald.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QLocalClientConnectionFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QLocalClientConnectionFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_locald.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..efa7d9ca1ad46a1653f2ec5a1ad0dd34f5d8a097 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QLocalClientConnectionFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QLocalClientConnectionFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QLocalClientConnectionFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_local.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QLocalClientConnectionFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QLocalClientConnectionFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_local.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cde808293ecbd57b32de5b5160c53d04af6eac6f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QLocalClientConnectionFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QLocalClientConnectionFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QLocalClientConnectionFactoryPlugin +add_library(Qt6::QLocalClientConnectionFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QLocalClientConnectionFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QLocalClientConnectionFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QLocalClientConnectionFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QLocalClientConnectionFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..da56dae868e65e67c8dce0eebad80d0011cfa51e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQmlDebugServerFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQmlDebugServerFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QQmlDebugServerFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQmlDebugServerFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQmlDebugServerFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QQmlDebugServerFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlDebugServerFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQmlDebugServerFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQmlDebugServerFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlDebugServerFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQmlDebugServerFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c5cbfe2f4d01cdfccaf1e9c852ebf5fef96e2728 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebugServerFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebugServerFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebugServerFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebugServerFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7a6f9b7f2866b15667afa6b2d21adf11495876e5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebugServerFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d8bf42e6e49c48c894f49a4ebeafc89b07abb36c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlDebugServerFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQmlDebugServerFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQmlDebugServerFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_serverd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlDebugServerFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlDebugServerFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_serverd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cc2b0755cea58fe9f21b76464143f87bb368c058 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlDebugServerFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQmlDebugServerFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQmlDebugServerFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_server.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlDebugServerFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlDebugServerFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_server.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e0d5096280f9e1ddd3995db9ff04bf8430b8cc7a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebugServerFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQmlDebugServerFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQmlDebugServerFactoryPlugin +add_library(Qt6::QQmlDebugServerFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQmlDebugServerFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QQmlDebugServerFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QQmlDebugServerFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebugServerFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..043dadff763ef362682926f57bba0c76ade9a0e1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQmlDebuggerServiceFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQmlDebuggerServiceFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QQmlDebuggerServiceFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQmlDebuggerServiceFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQmlDebuggerServiceFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QQmlDebuggerServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlDebuggerServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQmlDebuggerServiceFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQmlDebuggerServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlDebuggerServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQmlDebuggerServiceFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..960dc033582f0a947f8f591d3f7afe81deb6dc74 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebuggerServiceFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebuggerServiceFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebuggerServiceFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebuggerServiceFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7d6e63cb1e710a90b15f8c57864f17b64b7cbb10 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebuggerServiceFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1cbe115de5c4baca81703cbfb5b8564151a611c2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlDebuggerServiceFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQmlDebuggerServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQmlDebuggerServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_debuggerd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlDebuggerServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlDebuggerServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_debuggerd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b9a5b672de08487b9defd709bf3dc12d15ab565d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlDebuggerServiceFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQmlDebuggerServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQmlDebuggerServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_debugger.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlDebuggerServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlDebuggerServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_debugger.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d54a6a6fb30de01c8406c8c60338215220adff82 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlDebuggerServiceFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQmlDebuggerServiceFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQmlDebuggerServiceFactoryPlugin +add_library(Qt6::QQmlDebuggerServiceFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQmlDebuggerServiceFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QQmlDebuggerServiceFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QQmlDebuggerServiceFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlDebuggerServiceFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ea69cf13e6bcd1535113f30310d60816f147ac29 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQmlInspectorServiceFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQmlInspectorServiceFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QQmlInspectorServiceFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQmlInspectorServiceFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQmlInspectorServiceFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QQmlInspectorServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlInspectorServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQmlInspectorServiceFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQmlInspectorServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlInspectorServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQmlInspectorServiceFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e5866f52453a62afcf07c21b4c1893e07f66fc28 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlInspectorServiceFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlInspectorServiceFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlInspectorServiceFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlInspectorServiceFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b66723b24f8683b4f6b7b28887d3cc20b3918884 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlInspectorServiceFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..126b799ad62eadc7f570a64316fecef6522f4edd --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlInspectorServiceFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQmlInspectorServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQmlInspectorServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_inspectord.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlInspectorServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlInspectorServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_inspectord.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..60271f584c5a7a07cd2135f0c2e5da08beeac56d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlInspectorServiceFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQmlInspectorServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQmlInspectorServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_inspector.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlInspectorServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlInspectorServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_inspector.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..76beec8a0b552b63f72011a83aaf0dceb954dab5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlInspectorServiceFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQmlInspectorServiceFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQmlInspectorServiceFactoryPlugin +add_library(Qt6::QQmlInspectorServiceFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQmlInspectorServiceFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QQmlInspectorServiceFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QQmlInspectorServiceFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlInspectorServiceFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3a03ea2e0e3a4266ccd0270d10d348e84f8e5422 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQmlNativeDebugConnectorFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQmlNativeDebugConnectorFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QQmlNativeDebugConnectorFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQmlNativeDebugConnectorFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQmlNativeDebugConnectorFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QQmlNativeDebugConnectorFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlNativeDebugConnectorFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQmlNativeDebugConnectorFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQmlNativeDebugConnectorFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlNativeDebugConnectorFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQmlNativeDebugConnectorFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..92e9a9821a4a0da3283f2a4f403d652bafd3946b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugConnectorFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugConnectorFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugConnectorFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugConnectorFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dc8cb5c415a6de3449a57dab9162ce9337200357 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugConnectorFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dba5635e6da8e9a7bc40da9fe677062c2112115b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlNativeDebugConnectorFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQmlNativeDebugConnectorFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQmlNativeDebugConnectorFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_natived.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlNativeDebugConnectorFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlNativeDebugConnectorFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_natived.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ed2e58e37081a313342f0fde879ae89f2a5b3c2b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlNativeDebugConnectorFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQmlNativeDebugConnectorFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQmlNativeDebugConnectorFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_native.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlNativeDebugConnectorFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlNativeDebugConnectorFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_native.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d6ba93fea8e97b2fc030a930119ad82d118efe02 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugConnectorFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQmlNativeDebugConnectorFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQmlNativeDebugConnectorFactoryPlugin +add_library(Qt6::QQmlNativeDebugConnectorFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQmlNativeDebugConnectorFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QQmlNativeDebugConnectorFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QQmlNativeDebugConnectorFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugConnectorFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4ed837a1d5127e1d273a28db14e5d2102a9f9507 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQmlNativeDebugServiceFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQmlNativeDebugServiceFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QQmlNativeDebugServiceFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQmlNativeDebugServiceFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQmlNativeDebugServiceFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QQmlNativeDebugServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlNativeDebugServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQmlNativeDebugServiceFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQmlNativeDebugServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlNativeDebugServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQmlNativeDebugServiceFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2f80d734edd324e9616ce24fffc79e9658dbedef --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugServiceFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugServiceFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugServiceFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugServiceFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee59c874eb47a61f2cab044f6e20ac1cf6e7a2f6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugServiceFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d55592024abf15170eab55454dcd1f513dc8c406 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlNativeDebugServiceFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQmlNativeDebugServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQmlNativeDebugServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_nativedebuggerd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlNativeDebugServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlNativeDebugServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_nativedebuggerd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4f59adfcb20d69735cfe696c0882c58634a6abf8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlNativeDebugServiceFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQmlNativeDebugServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQmlNativeDebugServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_nativedebugger.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlNativeDebugServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlNativeDebugServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_nativedebugger.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d6ac5ec9a4a295f28cd276f57001baf7b797d978 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlNativeDebugServiceFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQmlNativeDebugServiceFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQmlNativeDebugServiceFactoryPlugin +add_library(Qt6::QQmlNativeDebugServiceFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQmlNativeDebugServiceFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QQmlNativeDebugServiceFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QQmlNativeDebugServiceFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlNativeDebugServiceFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7a8c3552545f45f14656b7dbbdb016e392abcc29 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQmlPreviewServiceFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQmlPreviewServiceFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QQmlPreviewServiceFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQmlPreviewServiceFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQmlPreviewServiceFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QQmlPreviewServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlPreviewServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQmlPreviewServiceFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQmlPreviewServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlPreviewServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQmlPreviewServiceFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d2d0e25f9d8f4a6d0b157fa6530c35d1522941a2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlPreviewServiceFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlPreviewServiceFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlPreviewServiceFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlPreviewServiceFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..42bdde3eaea0c2091b3534a3fb25f710b7127304 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlPreviewServiceFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1514c7d5e9df3e2de99310108e6242470ec9f530 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlPreviewServiceFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQmlPreviewServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQmlPreviewServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_previewd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlPreviewServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlPreviewServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_previewd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..37a9e055a423ffd9c510b7ba62776faefc42fd85 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlPreviewServiceFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQmlPreviewServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQmlPreviewServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_preview.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlPreviewServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlPreviewServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_preview.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4d8c3e51281f5239b4659e587f4d590c9e69877c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlPreviewServiceFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQmlPreviewServiceFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQmlPreviewServiceFactoryPlugin +add_library(Qt6::QQmlPreviewServiceFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQmlPreviewServiceFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QQmlPreviewServiceFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QQmlPreviewServiceFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlPreviewServiceFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..73810288790b7030be6db4f336b01d791996f794 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQmlProfilerServiceFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQmlProfilerServiceFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QQmlProfilerServiceFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQmlProfilerServiceFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQmlProfilerServiceFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QQmlProfilerServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlProfilerServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQmlProfilerServiceFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQmlProfilerServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQmlProfilerServiceFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQmlProfilerServiceFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..48633ac4b49e597e7939bb189b21753f3b00c4f8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlProfilerServiceFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlProfilerServiceFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlProfilerServiceFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlProfilerServiceFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..329aa45f85f390292bbc38c4db8edbf7188bdbfb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlProfilerServiceFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..00dd4655b578e567c472ca5798fd3375f4cec52d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlProfilerServiceFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQmlProfilerServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQmlProfilerServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_profilerd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlProfilerServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlProfilerServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_profilerd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ad11b482df526efcc962cb1a4edaeaf1a8336e9f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQmlProfilerServiceFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQmlProfilerServiceFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQmlProfilerServiceFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_profiler.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQmlProfilerServiceFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQmlProfilerServiceFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_profiler.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a343b24e12e15afa66d97ad05e4e56e1591b8145 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQmlProfilerServiceFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQmlProfilerServiceFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQmlProfilerServiceFactoryPlugin +add_library(Qt6::QQmlProfilerServiceFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQmlProfilerServiceFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QQmlProfilerServiceFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QQmlProfilerServiceFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQmlProfilerServiceFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..beda03c257f53eca387d37e939a19fe4de4638a2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QQuickProfilerAdapterFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QQuickProfilerAdapterFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QQuickProfilerAdapterFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QQuickProfilerAdapterFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QQuickProfilerAdapterFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QQuickProfilerAdapterFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQuickProfilerAdapterFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QQuickProfilerAdapterFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QQuickProfilerAdapterFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QQuickProfilerAdapterFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QQuickProfilerAdapterFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3e3806eaceab0f5192d44bfd18dc798cb21e49e1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickProfilerAdapterFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickProfilerAdapterFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickProfilerAdapterFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickProfilerAdapterFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ee57145894df5826e688bef2ac601074357bd088 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickProfilerAdapterFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..22c5d52967d98779a45eaf4db2fedcce315d7b7a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQuickProfilerAdapterFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QQuickProfilerAdapterFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QQuickProfilerAdapterFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_quickprofilerd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQuickProfilerAdapterFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQuickProfilerAdapterFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_quickprofilerd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1279e4724b41019e92f83f253cbda8af533beeea --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QQuickProfilerAdapterFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QQuickProfilerAdapterFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QQuickProfilerAdapterFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_quickprofiler.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QQuickProfilerAdapterFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QQuickProfilerAdapterFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_quickprofiler.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..008b902005eb2edfde50535a60d07a1c555d9f13 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QQuickProfilerAdapterFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QQuickProfilerAdapterFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QQuickProfilerAdapterFactoryPlugin +add_library(Qt6::QQuickProfilerAdapterFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QQuickProfilerAdapterFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QQuickProfilerAdapterFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QQuickProfilerAdapterFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QQuickProfilerAdapterFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d9e22e6b974a72d0c66ce9b1cb3e3023d3f747c1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QTcpServerConnectionFactoryPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QTcpServerConnectionFactoryPlugin) +get_target_property(_qt_imported_location Qt6::QTcpServerConnectionFactoryPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QTcpServerConnectionFactoryPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QTcpServerConnectionFactoryPlugin" for configuration "Release" +set_property(TARGET Qt6::QTcpServerConnectionFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTcpServerConnectionFactoryPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QTcpServerConnectionFactoryPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QTcpServerConnectionFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QTcpServerConnectionFactoryPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QTcpServerConnectionFactoryPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..91161568e3f78bc2f7691a7c5760db0f772a7489 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QTcpServerConnectionFactoryPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTcpServerConnectionFactoryPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTcpServerConnectionFactoryPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTcpServerConnectionFactoryPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a5cd13a829cf137495ba222cac2bed7622a1a68c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QTcpServerConnectionFactoryPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..459d5aa1d8baea8e3576fbd20d3a56c47542bb7d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTcpServerConnectionFactoryPlugin" for configuration "Debug" +set_property(TARGET Qt6::QTcpServerConnectionFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QTcpServerConnectionFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_tcpd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTcpServerConnectionFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTcpServerConnectionFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_tcpd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..34cd41b71e42830b26762a81cef63ff0c7e23bb4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QTcpServerConnectionFactoryPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QTcpServerConnectionFactoryPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QTcpServerConnectionFactoryPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_tcp.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QTcpServerConnectionFactoryPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QTcpServerConnectionFactoryPlugin "${_IMPORT_PREFIX}/plugins/qmltooling/qmldbg_tcp.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5c38a41bfccc0c332bde52fc159ffbfd2acaa895 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QTcpServerConnectionFactoryPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QTcpServerConnectionFactoryPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QTcpServerConnectionFactoryPlugin +add_library(Qt6::QTcpServerConnectionFactoryPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QTcpServerConnectionFactoryPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "Qml" + QT_PLUGIN_CLASS_NAME "QTcpServerConnectionFactory" + QT_PLUGIN_TYPE "qmltooling" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QTcpServerConnectionFactoryPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QTcpServerConnectionFactoryPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e99c8e11dd3eeb00c7b1ecf832e4a01918f3f674 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6Qml +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::Qml) +get_target_property(_qt_imported_location Qt6::Qml IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::Qml IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::Qml IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::Qml IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::Qml IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::Qml IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::Qml" for configuration "Release" +set_property(TARGET Qt6::Qml APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::Qml" for configuration "MinSizeRel" +set_property(TARGET Qt6::Qml APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::Qml PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlBuildInternals.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlBuildInternals.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e7bfde3434f0872dea4aacbb431558aee71b9f53 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlBuildInternals.cmake @@ -0,0 +1,478 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# +# QtDeclarative Specific extensions +# + +include_guard(GLOBAL) + +macro(qt_internal_get_internal_add_qml_module_keywords + option_args single_args multi_args + internal_option_args internal_single_args internal_multi_args) + set(${option_args} + DESIGNER_SUPPORTED + FOLLOW_FOREIGN_VERSIONING + NO_PLUGIN + NO_PLUGIN_OPTIONAL + NO_CREATE_PLUGIN_TARGET + NO_GENERATE_PLUGIN_SOURCE + NO_GENERATE_QMLTYPES + NO_GENERATE_QMLDIR + NO_GENERATE_EXTRA_QMLDIRS + NO_LINT + NO_CACHEGEN + ENABLE_TYPE_COMPILER + __QT_INTERNAL_STATIC_MODULE + __QT_INTERNAL_SYSTEM_MODULE + ) + set(${single_args} + URI + VERSION + PLUGIN_TARGET + TYPEINFO + CLASS_NAME + TYPE_COMPILER_NAMESPACE + ) + set(${multi_args} + QML_FILES + RESOURCES + IMPORTS + IMPORT_PATH + OPTIONAL_IMPORTS + DEFAULT_IMPORTS + DEPENDENCIES + PAST_MAJOR_VERSIONS + ) + # Args used by qt_internal_add_qml_module directly, which should not be passed to any other + # functions. + # + # INSTALL_SOURCE_QMLTYPES takes a path to an existing plugins.qmltypes file that should be + # installed. + # + # INSTALL_SOURCE_QMLDIR takes a path to an existing qmldir file that should be installed. + set(${internal_option_args} + ) + set(${internal_single_args} + INSTALL_SOURCE_QMLTYPES + INSTALL_SOURCE_QMLDIR + ) + set(${internal_multi_args} + ) + +endmacro() + +# This function is essentially a wrapper around qt6_add_qml_module(). +# It creates the targets explicitly and sets up internal properties before +# passing those targets to qt6_add_qml_module() for further updates. +# All keywords supported by qt_internal_add_module() can be used, as can most +# keywords for qt6_add_qml_module() except RESOURCE_PREFIX and +# OUTPUT_TARGETS. +# +# OUTPUT_DIRECTORY and INSTALL_DIRECTORY will be given more appropriate defaults +# if not provided by the caller. The defaults are usually what you want to use. +# +# - SOURCES is only passed through to qt_internal_add_plugin() or +# qt_internal_add_module() but not to qt6_add_qml_module(). +# +# See qt_internal_add_plugin() and qt6_add_qml_module() for the full set of +# supported keywords. +function(qt_internal_add_qml_module target) + + qt_internal_get_internal_add_module_keywords( + module_option_args + module_single_args + module_multi_args + ) + + qt_internal_get_internal_add_qml_module_keywords( + qml_module_option_args + qml_module_single_args + qml_module_multi_args + qml_module_internal_option_args + qml_module_internal_single_args + qml_module_internal_multi_args + ) + # TODO: Remove these once all repos have been updated to not use them + set(ignore_option_args + PLUGIN_OPTIONAL # Now the default + GENERATE_QMLTYPES # Now the default + INSTALL_QMLTYPES # Now the default + ) + + set(option_args + ${module_option_args} + ${qml_module_option_args} + ${ignore_option_args} + ${qml_module_internal_option_args} + ) + set(single_args + ${module_single_args} + ${qml_module_single_args} + ${qml_module_internal_single_args} + ) + set(multi_args + ${module_multi_args} + ${qml_module_multi_args} + ${qml_module_internal_multi_args} + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${option_args}" + "${single_args}" + "${multi_args}" + ) + _qt_internal_validate_all_args_are_parsed(arg) + + set(QT_QML_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_QMLDIR}") + string(REPLACE "." "/" target_path ${arg_URI}) + if(NOT arg_OUTPUT_DIRECTORY) + set(arg_OUTPUT_DIRECTORY "${QT_QML_OUTPUT_DIRECTORY}/${target_path}") + endif() + if(NOT arg_INSTALL_DIRECTORY) + set(arg_INSTALL_DIRECTORY "${INSTALL_QMLDIR}/${target_path}") + endif() + if(arg_NO_PLUGIN) + unset(arg_PLUGIN_TARGET) + elseif(NOT arg_PLUGIN_TARGET) + set(arg_PLUGIN_TARGET ${target}plugin) + endif() + + set(plugin_args "") + if(arg_NO_PLUGIN OR NOT arg_PLUGIN_TARGET STREQUAL target) + # Allow using an existing backing target. + if(NOT TARGET ${target}) + # Create the backing target now to handle module-related things + qt_remove_args(module_args + ARGS_TO_REMOVE + ${ignore_option_args} + ${qml_module_option_args} + ${qml_module_single_args} + ${qml_module_multi_args} + ${qml_module_internal_option_args} + ${qml_module_internal_single_args} + ${qml_module_internal_multi_args} + OUTPUT_DIRECTORY + INSTALL_DIRECTORY + ALL_ARGS + ${option_args} + ${single_args} + ${multi_args} + ARGS + ${ARGN} + ) + qt_internal_add_module(${target} ${module_args}) + elseif(arg_SOURCES) + # If a module target was pre-created, we still need to pass the additional sources. + target_sources(${target} PRIVATE ${arg_SOURCES}) + endif() + else() + # Since we are not creating a separate backing target, we have to pass + # through the default args to the plugin target creation instead + qt_internal_get_internal_add_plugin_keywords( + plugin_option_args plugin_single_args plugin_multi_args + ) + set(args_to_remove ${option_args} ${single_args} ${multi_args}) + list(REMOVE_ITEM args_to_remove + ${plugin_option_args} + ${plugin_single_args} + ${plugin_multi_args} + ) + qt_remove_args(plugin_args + ARGS_TO_REMOVE + ${args_to_remove} + DEFAULT_IF + OUTPUT_DIRECTORY + INSTALL_DIRECTORY + CLASS_NAME + ALL_ARGS + ${option_args} + ${single_args} + ${multi_args} + ARGS + ${ARGN} + ) + endif() + + set(add_qml_module_args "") + + if(NOT arg_NO_PLUGIN AND NOT arg_NO_CREATE_PLUGIN_TARGET) + # If the qt_internal_add_qml_module call didn't specify a CLASS_NAME, we need to pre-compute + # it here and pass it along to qt_internal_add_plugin -> qt_add_plugin so that + # qt_add_qml_plugin does not complain about differing class names (the default pre-computed + # class name of a regular plugin and qml plugin are different). + if(NOT arg_CLASS_NAME) + _qt_internal_compute_qml_plugin_class_name_from_uri("${arg_URI}" arg_CLASS_NAME) + endif() + + # If the module is explicitly marked as STATIC, the plugin should inherit that as well. + set(static_plugin "") + if(arg_STATIC) + set(static_plugin "STATIC") + endif() + + # Create plugin target now so we can set internal things + list(APPEND plugin_args + ${static_plugin} + PLUGIN_TYPE qml_plugin + DEFAULT_IF FALSE + OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + INSTALL_DIRECTORY ${arg_INSTALL_DIRECTORY} + CLASS_NAME ${arg_CLASS_NAME} + ) + + qt_internal_add_plugin(${arg_PLUGIN_TARGET} ${plugin_args}) + + # Use the plugin target name as the main part of the plugin basename. + set(plugin_basename "${arg_PLUGIN_TARGET}") + + # If the target name already ends with a "plugin" suffix, remove it and re-add it to the end + # of the base name after the infix. + if(plugin_basename MATCHES "(.+)plugin$") + set(plugin_basename "${CMAKE_MATCH_1}") + endif() + + # Add a the infix if Qt was configured with one. + if(QT_LIBINFIX) + string(APPEND plugin_basename "${QT_LIBINFIX}") + endif() + + # Add the "plugin" suffix after the infix. + string(APPEND plugin_basename "plugin") + + # Lowercase the whole thing and use it as the basename of the plugin library. + string(TOLOWER "${plugin_basename}" plugin_basename) + set_target_properties(${arg_PLUGIN_TARGET} PROPERTIES + OUTPUT_NAME "${plugin_basename}" + ) + + get_target_property(export_name ${arg_PLUGIN_TARGET} EXPORT_NAME) + if(export_name) + list(APPEND add_qml_module_args + INSTALLED_PLUGIN_TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::${export_name}" + ) + else() + list(APPEND add_qml_module_args + INSTALLED_PLUGIN_TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::${arg_PLUGIN_TARGET}" + ) + endif() + + if(NOT arg_PLUGIN_TARGET STREQUAL target) + get_target_property(lib_type ${arg_PLUGIN_TARGET} TYPE) + if(lib_type STREQUAL "STATIC_LIBRARY") + # This is needed so that the dependency on the backing target + # is included in the plugin's find_package() support. + # The naming of backing targets and plugins don't typically + # follow the pattern of other plugins with regard to Private + # suffixes, so the dependency logic in qt_internal_add_plugin() + # doesn't find these. For non-static builds, the private + # dependency doesn't get exposed to find_package(), so we don't + # have to make the dependency known for that case. + set_property(TARGET ${arg_PLUGIN_TARGET} APPEND PROPERTY + _qt_target_deps "${INSTALL_CMAKE_NAMESPACE}${target}\;${PROJECT_VERSION}" + ) + endif() + endif() + endif() + + # TODO: Check if we need arg_SOURCES in this condition + if (arg_SOURCES AND NOT arg_TYPEINFO) + set(arg_TYPEINFO "plugins.qmltypes") + endif() + + # Pass through options if given (these are present/absent, not true/false) + foreach(opt IN LISTS qml_module_option_args) + if(arg_${opt}) + list(APPEND add_qml_module_args ${opt}) + endif() + endforeach() + + # Pass through single and multi-value args as provided. + foreach(arg IN LISTS qml_module_single_args qml_module_multi_args) + if(DEFINED arg_${arg}) + list(APPEND add_qml_module_args ${arg} ${arg_${arg}}) + endif() + endforeach() + + if (arg_FOLLOW_FOREIGN_VERSIONING) + message(FATAL_ERROR "Do not set FOLLOW_FOREIGN_VERSIONING for module ${target}. It is already set by default for internal modules.") + endif() + + get_target_property(qt_namespace ${QT_CMAKE_EXPORT_NAMESPACE}::Core _qt_namespace) + if(qt_namespace) + list(APPEND add_qml_module_args NAMESPACE ${qt_namespace}) + endif() + + if (arg_ENABLE_TYPE_COMPILER AND NOT arg_TYPE_COMPILER_NAMESPACE) + # if qmltc namespace is not specified explicitly, use Qt's namespace + list(APPEND add_qml_module_args TYPE_COMPILER_NAMESPACE ${qt_namespace}) + endif() + + # Update the backing and plugin targets with qml-specific things. + qt6_add_qml_module(${target} + ${add_qml_module_args} + OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + RESOURCE_PREFIX "/qt-project.org/imports" + OUTPUT_TARGETS output_targets + FOLLOW_FOREIGN_VERSIONING + ) + + if(TARGET "${target}" AND NOT target STREQUAL "Qml") + qt_internal_add_autogen_sync_header_dependencies(${target} Qml) + endif() + if(TARGET "${arg_PLUGIN_TARGET}" AND NOT target STREQUAL arg_PLUGIN_TARGET) + qt_internal_add_autogen_sync_header_dependencies(${arg_PLUGIN_TARGET} Qml) + endif() + + if(output_targets) + set(plugin_export_targets) + set(backing_lib_export_targets) + + # Separate which output target should go to which export set. + # The plugin initializer library should go to the plugin export set, the rest should go to + # the backing lib export set. + # In the case when the plugin target is the same as the backing lib target, all of the + # output targets will go to the plugin export set. + + foreach(output_target IN LISTS output_targets) + get_target_property(is_plugin_init ${output_target} _is_qt_plugin_init_target) + if(is_plugin_init) + list(APPEND plugin_export_targets ${output_target}) + + # Plugin initializers associated with an internal module need the internal + # platform flags. + qt_internal_link_internal_platform_for_object_library("${output_target}") + else() + list(APPEND backing_lib_export_targets ${output_target}) + endif() + endforeach() + + if(backing_lib_export_targets) + qt_install(TARGETS ${backing_lib_export_targets} + EXPORT "${INSTALL_CMAKE_NAMESPACE}${target}Targets" + DESTINATION "${arg_INSTALL_DIRECTORY}" + ) + qt_internal_record_rcc_object_files(${target} "${backing_lib_export_targets}" + INSTALL_DIRECTORY "${arg_INSTALL_DIRECTORY}" + ) + + qt_internal_add_targets_to_additional_targets_export_file( + TARGETS ${backing_lib_export_targets} + EXPORT_NAME_PREFIX "${INSTALL_CMAKE_NAMESPACE}${target}" + ) + endif() + + if(arg_PLUGIN_TARGET AND plugin_export_targets) + qt_install(TARGETS ${plugin_export_targets} + EXPORT "${INSTALL_CMAKE_NAMESPACE}${arg_PLUGIN_TARGET}Targets" + DESTINATION "${arg_INSTALL_DIRECTORY}" + ) + + qt_internal_add_targets_to_additional_targets_export_file( + TARGETS ${plugin_export_targets} + EXPORT_NAME_PREFIX "${INSTALL_CMAKE_NAMESPACE}${arg_PLUGIN_TARGET}" + ) + endif() + endif() + + if(DEFINED arg_QML_FILES OR DEFINED arg_RESOURCES) + foreach(resource_file IN LISTS arg_QML_FILES arg_RESOURCES) + __qt_get_relative_resource_path_for_file(file_resource_path ${resource_file}) + get_filename_component(resource_dir ${file_resource_path} DIRECTORY) + get_filename_component(resource_name ${file_resource_path} NAME) + if(resource_dir) + set(dest "${arg_INSTALL_DIRECTORY}/${resource_dir}") + else() + set(dest "${arg_INSTALL_DIRECTORY}") + endif() + qt_install( + FILES ${resource_file} + DESTINATION ${dest} + RENAME ${resource_name} + ) + endforeach() + endif() + + if(NOT arg_NO_GENERATE_QMLTYPES) + qt_install( + FILES ${arg_OUTPUT_DIRECTORY}/$ + DESTINATION "${arg_INSTALL_DIRECTORY}" + ) + + # Assign the install time metatypes file of the backing library to the plugin. + # Only do it if the backing library is different from the plugin and we do generate + # qml types. + # The install time metatypes only apply to Qt's own qml plugins, not to user project + # qml plugins. + if(arg_PLUGIN_TARGET AND + TARGET "${arg_PLUGIN_TARGET}" AND NOT target STREQUAL arg_PLUGIN_TARGET) + _qt_internal_get_metatypes_install_dir( + "" + "${INSTALL_ARCHDATADIR}" + install_dir + ) + + _qt_internal_assign_install_metatypes_files_and_properties( + "${arg_PLUGIN_TARGET}" + INSTALL_DIR "${install_dir}" + ) + endif() + endif() + + if(NOT arg_NO_GENERATE_QMLDIR) + qt_install( + FILES ${arg_OUTPUT_DIRECTORY}/qmldir + DESTINATION "${arg_INSTALL_DIRECTORY}" + ) + + get_target_property(extra_qmldirs ${target} _qt_internal_extra_qmldirs) + if(extra_qmldirs) + foreach(extra_qmldir IN LISTS extra_qmldirs) + __qt_get_relative_resource_path_for_file(qmldir_resource_path ${extra_qmldir}) + get_filename_component(qmldir_dir ${qmldir_resource_path} DIRECTORY) + qt_install( + FILES ${extra_qmldir} + DESTINATION "${arg_INSTALL_DIRECTORY}/${qmldir_dir}" + ) + endforeach() + endif() + endif() + + if(arg_INSTALL_SOURCE_QMLTYPES) + message(AUTHOR_WARNING + "INSTALL_SOURCE_QMLTYPES option is deprecated and should not be used. " + "Please port your module to use declarative type registration.") + + set(files ${arg_INSTALL_SOURCE_QMLTYPES}) + if(QT_WILL_INSTALL) + install( + FILES ${files} + DESTINATION "${arg_INSTALL_DIRECTORY}" + ) + else() + file( + COPY ${files} + DESTINATION "${arg_OUTPUT_DIRECTORY}" + ) + endif() + endif() + + if(arg_INSTALL_SOURCE_QMLDIR) + message(AUTHOR_WARNING + "INSTALL_SOURCE_QMLDIR option is deprecated and should not be used. " + "Please port your module to use declarative type registration.") + + set(files ${arg_INSTALL_SOURCE_QMLDIR}) + if(QT_WILL_INSTALL) + install( + FILES ${files} + DESTINATION "${arg_INSTALL_DIRECTORY}" + ) + else() + file( + COPY ${files} + DESTINATION "${arg_OUTPUT_DIRECTORY}" + ) + endif() + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e5d27415c321196e2c2674262a2094179f0cc599 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfig.cmake @@ -0,0 +1,189 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin +set(QT_KNOWN_POLICY_QTP0001 TRUE) +set(QT_KNOWN_POLICY_QTP0004 TRUE) +set(QT_KNOWN_POLICY_QTP0005 TRUE) + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDependencies.cmake") + _qt_internal_suggest_dependency_debugging(Qml + __qt_Qml_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6Qml_FOUND") + set("Qt6Qml_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6Qml_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6Qml) instead. + set(Qt6Qml_LIBRARIES "Qt6::Qml") + + get_target_property(_Qt6Qml_OWN_INCLUDE_DIRS + Qt6::Qml INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Qml_OWN_INCLUDE_DIRS) + set(_Qt6Qml_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QmlPrivate) + get_target_property(_Qt6Qml_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QmlPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6Qml_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6Qml_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6Qml_DEFINITIONS + Qt6::Qml INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Qml_DEFINITIONS) + set(Qt6Qml_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6Qml_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6Qml_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6Qml_COMPILE_DEFINITIONS + Qt6::Qml INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6Qml_COMPILE_DEFINITIONS) + set(Qt6Qml_COMPILE_DEFINITIONS "") + endif() + + set(Qt6Qml_INCLUDE_DIRS + ${_Qt6Qml_OWN_INCLUDE_DIRS}) + + set(Qt6Qml_PRIVATE_INCLUDE_DIRS + ${_Qt6Qml_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6Qml_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6Qml${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6Qml${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6Qml_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6Qml${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6Qml${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6Qml_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Qml_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6Qml_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6Qml_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::Qml) + qt_make_features_available(Qt6::Qml) + + foreach(extra_cmake_include Qt6QmlMacros.cmake;Qt6QmlConfigExtras.cmake;Qt6QmlFindQmlscInternal.cmake;Qt6QmlPublicCMakeHelpers.cmake) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "Qml") + + get_target_property(_qt_module_target_type "Qt6::Qml" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::Qml MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6Qml_FOUND FALSE) + if(NOT DEFINED Qt6Qml_NOT_FOUND_MESSAGE) + set(Qt6Qml_NOT_FOUND_MESSAGE + "Target \"Qt6::Qml\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6Qml_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigExtras.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigExtras.cmake new file mode 100644 index 0000000000000000000000000000000000000000..64a2d4965a4a13b049dbb5dffa6470d531c09b40 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigExtras.cmake @@ -0,0 +1,16 @@ +if(NOT QT_NO_CREATE_TARGETS) + set(__qt_qml_target Qt6::Qml) + get_property(__qt_qml_aliased_target TARGET ${__qt_qml_target} PROPERTY ALIASED_TARGET) + if(__qt_qml_aliased_target) + set(__qt_qml_target "${__qt_qml_aliased_target}") + endif() + if("ON") + _qt_internal_add_qml_deploy_info_finalizer("${__qt_qml_target}") + endif() + set_property(TARGET ${__qt_qml_target} APPEND PROPERTY + INTERFACE_QT_EXECUTABLE_FINALIZERS + qt6_import_qml_plugins + ) + unset(__qt_qml_target) + unset(__qt_qml_aliased_target) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ed6b44813cf0128fd8b07ef370085eafcd8fef57 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f7609f39a4fb4a129580df7c88c58db7a6b72039 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6Qml_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_Qml_third_party_deps "") + +_qt_internal_find_third_party_dependencies("Qml" __qt_Qml_third_party_deps) + +# Find Qt tool package. +set(__qt_Qml_tool_deps "Qt6QmlTools\;6.8.1") +_qt_internal_find_tool_dependencies("Qml" __qt_Qml_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_Qml_target_deps "Qt6Core\;6.8.1;Qt6QmlIntegration\;6.8.1;Qt6Network\;6.8.1") +set(__qt_Qml_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("Qml" __qt_Qml_target_deps + __qt_Qml_find_dependency_paths) + +set(_Qt6Qml_MODULE_DEPENDENCIES "Core;QmlIntegration;Network") +set(Qt6Qml_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlDeploySupport.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlDeploySupport.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d098730f1b6473641d91c6ee7968b98498ebda8f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlDeploySupport.cmake @@ -0,0 +1,352 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# NOTE: This code should only ever be executed in script mode. It expects to be +# used either as part of an install(CODE) call or called by a script +# invoked via cmake -P as a POST_BUILD step. It would not normally be +# included directly, it should be pulled in automatically by the deploy +# support set up by qtbase. + +cmake_minimum_required(VERSION 3.16...3.21) + +function(qt6_deploy_qml_imports) + set(no_value_options + NO_QT_IMPORTS + ) + set(single_value_options + TARGET + PLUGINS_DIR # Internal option, only used for macOS app bundle targets + QML_DIR + PLUGINS_FOUND # Name of an output variable + ) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unparsed arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if(NOT arg_TARGET) + message(FATAL_ERROR "TARGET must be specified") + endif() + + if(NOT arg_QML_DIR) + set(arg_QML_DIR "${QT_DEPLOY_QML_DIR}") + endif() + + if(NOT arg_PLUGINS_DIR) + set(arg_PLUGINS_DIR "${QT_DEPLOY_PLUGINS_DIR}") + endif() + + # The target's finalizer should have written out this file + string(MAKE_C_IDENTIFIER "${arg_TARGET}" target_id) + set(filename "${__QT_DEPLOY_IMPL_DIR}/deploy_qml_imports/${target_id}") + if(__QT_DEPLOY_GENERATOR_IS_MULTI_CONFIG) + string(APPEND filename "-${__QT_DEPLOY_ACTIVE_CONFIG}") + endif() + string(APPEND filename ".cmake") + if(NOT EXISTS "${filename}") + message(FATAL_ERROR + "No QML imports information recorded for target ${arg_TARGET}. " + "The target must be an executable and qt_add_qml_module() must " + "have been called with it. If using a CMake version lower than 3.19, ensure " + "that the executable is manually finalized with qt_finalize_target(). " + "Missing file:\n ${filename}" + ) + endif() + include(${filename}) + +endfunction() + +if(NOT __QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_deploy_qml_imports) + if(__QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_deploy_qml_imports(${ARGV}) + + cmake_parse_arguments(PARSE_ARGV 0 arg "" "PLUGINS_FOUND" "") + if(arg_PLUGINS_FOUND) + set(${arg_PLUGINS_FOUND} ${${arg_PLUGINS_FOUND}} PARENT_SCOPE) + endif() + else() + message(FATAL_ERROR "qt_deploy_qml_imports() is only available in Qt 6.") + endif() + endfunction() +endif() + +function(_qt_internal_deploy_qml_imports_for_target) + set(no_value_options + BUNDLE + NO_QT_IMPORTS + ) + set(single_value_options + IMPORTS_FILE + PLUGINS_FOUND + QML_DIR + PLUGINS_DIR + ) + set(multi_value_options "") + + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + foreach(opt IN LISTS single_value_options) + if(NOT arg_${opt}) + message(FATAL_ERROR "Required argument not provided: ${opt}") + endif() + endforeach() + + include("${arg_IMPORTS_FILE}") + + macro(_qt_internal_parse_qml_imports_entry prefix index) + cmake_parse_arguments("${prefix}" + "" + "CLASSNAME;NAME;PATH;PLUGIN;RELATIVEPATH;TYPE;VERSION;LINKTARGET" + "" + ${qml_import_scanner_import_${index}} + ) + endmacro() + + get_filename_component(install_prefix_abs "${QT_DEPLOY_PREFIX}" ABSOLUTE) + set(plugins_found "") + + if(__QT_DEPLOY_POST_BUILD) + message(STATUS "Running macOS bundle QML support POST_BUILD routine.") + + # Unset the DESTDIR environment variable if it's set during a post build step, otherwise + # file(INSTALL) will install to the wrong location, which will not coincide with where + # symlinks will be created using file(CREATE_LINK) + the overridden QT_DEPLOY_PREFIX that + # will NOT contain DESTDIR. + if(DEFINED ENV{DESTDIR}) + message(STATUS "Clearing DESTDIR environment variable, because it's not " + "supposed to be set during the post build step.") + set(ENV{DESTDIR} "") + endif() + endif() + + # Parse the generated cmake file. It is possible for the scanner to find no + # usage of QML, in which case the import count is 0. + if(qml_import_scanner_imports_count GREATER 0) + set(processed_names "") + math(EXPR last_index "${qml_import_scanner_imports_count} - 1") + foreach(index RANGE 0 ${last_index}) + _qt_internal_parse_qml_imports_entry(entry ${index}) + + if("${entry_NAME}" STREQUAL "") + message(WARNING "No NAME at scan index ${index}: ${imports_file}") + continue() + endif() + + # A plugin might have multiple entries (e.g. for different versions). + # Only copy it once. + if("${entry_NAME}" IN_LIST processed_names) + continue() + endif() + # Even if we skip this one, we don't need to process it again + list(APPEND processed_names ${entry_NAME}) + + if("${entry_PATH}" STREQUAL "" OR + "${entry_PLUGIN}" STREQUAL "" OR + "${entry_RELATIVEPATH}" STREQUAL "") + # These might be a valid QML module, but not have a plugin library. + # We only care about modules that have a plugin we need to copy. + continue() + endif() + + if(arg_NO_QT_IMPORTS AND + "${entry_LINKTARGET}" MATCHES "${__QT_CMAKE_EXPORT_NAMESPACE}::") + continue() + endif() + + # For installation, we want the qmldir file and its plugin. If the + # CMake project generating the plugin sets version details on its + # CMake target, we might have symlinks and version numbers in the + # file names, so account for those. There should never be plugin + # libraries for more than one QML module in the directory, so we + # shouldn't need to worry about matching plugins we don't want. + # + # install_qmldir and install_plugin do not contain $ENV{DESTDIR}, + # whereas dest_qmldir and dest_plugin do. + # The install_ variants are used in file(INSTALL) to avoid double DESTDIR in paths. + # Other code should reference the dest_ variants instead. + set(relative_qmldir "${arg_QML_DIR}/${entry_RELATIVEPATH}") + if("${CMAKE_INSTALL_PREFIX}" STREQUAL "") + set(install_qmldir "./${relative_qmldir}") + else() + set(install_qmldir "${CMAKE_INSTALL_PREFIX}/${relative_qmldir}") + endif() + set(dest_qmldir "${QT_DEPLOY_PREFIX}/${relative_qmldir}") + if(arg_BUNDLE) + if("${CMAKE_INSTALL_PREFIX}" STREQUAL "") + set(install_plugin "./${arg_PLUGINS_DIR}") + else() + set(install_plugin "${CMAKE_INSTALL_PREFIX}/${arg_PLUGINS_DIR}") + endif() + set(dest_plugin "${QT_DEPLOY_PREFIX}/${arg_PLUGINS_DIR}") + else() + set(install_plugin "${install_qmldir}") + set(dest_plugin "${dest_qmldir}") + endif() + + file(INSTALL "${entry_PATH}/qmldir" DESTINATION "${install_qmldir}") + + if(DEFINED __QT_DEPLOY_TARGET_${entry_LINKTARGET}_FILE AND + __QT_DEPLOY_TARGET_${entry_LINKTARGET}_TYPE STREQUAL "STATIC_LIBRARY") + # If the QML plugin is built statically, skip further deployment. + continue() + endif() + + if(__QT_DEPLOY_POST_BUILD) + # We are being invoked as a post-build step. The plugin might + # not exist yet, so we can't even glob for it, let alone copy + # it. We know what its name should be though, so we can create + # a symlink to where it will eventually be, which will be enough + # to allow it to run from the build tree. It won't matter if + # the plugin gets updated later in the build, the symlink will + # still be pointing at the right location. + # In theory, this could be possible for any platform that + # supports symlinks (which all do in some form now, even + # Windows if the right permissions are set), but we only really + # expect to need this for macOS app bundles. + if(DEFINED __QT_DEPLOY_TARGET_${entry_LINKTARGET}_FILE) + set(source_file "${__QT_DEPLOY_TARGET_${entry_LINKTARGET}_FILE}") + get_filename_component(source_file_name "${source_file}" NAME) + set(final_destination "${dest_qmldir}/${source_file_name}") + else() + # TODO: This is inconsistent with what we do further down below for the + # installation case. There we file(GLOB) any files we find, whereas here we + # build the path manually, because the file might not exist yet. + # Ideally both cases should use neither file(GLOB) nor manual path building, + # and instead rely on available target information or qmldir information. + # Currently that is not possible because we don't have all targets exposed + # via the __QT_DEPLOY_TARGET_{target} mechanism, only those that are built as + # part of the current project, and the qmldir -> qmlimportscanner does print + # the full file path, because there is one qmldir, but possibly 2+ plugins + # (debug and release). + set(plugin_suffix "") + if(__QT_DEPLOY_ACTIVE_CONFIG STREQUAL "Debug") + string(APPEND plugin_suffix "${__QT_DEPLOY_QT_DEBUG_POSTFIX}") + endif() + + set(source_file "${entry_PATH}/lib${entry_PLUGIN}${plugin_suffix}.dylib") + set(final_destination "${dest_qmldir}/lib${entry_PLUGIN}${plugin_suffix}.dylib") + endif() + + message(STATUS "Symlinking: ${final_destination}") + file(CREATE_LINK + "${source_file}" + "${final_destination}" + SYMBOLIC + ) + + # We don't add this plugin to plugins_found because we don't + # actually make a copy of the plugin. We don't want the caller + # thinking they should further process what would still be the + # original plugin in the build tree. + continue() + endif() + + # Deploy the plugin. + if(DEFINED __QT_DEPLOY_TARGET_${entry_LINKTARGET}_FILE) + set(files "${__QT_DEPLOY_TARGET_${entry_LINKTARGET}_FILE}") + else() + # We don't know the exact target file name. Fall back to file name heuristics. + + # Construct a regular expression that matches the plugin's file name. + set(plugin_regex "^(.*/)?(lib)?${entry_PLUGIN}") + if(__QT_DEPLOY_QT_IS_MULTI_CONFIG_BUILD_WITH_DEBUG) + # If our application is a release build, do not match any debug suffix. + # If our application is a debug build, match exactly a debug suffix. + if(__QT_DEPLOY_ACTIVE_CONFIG STREQUAL "Debug") + string(APPEND plugin_regex "${__QT_DEPLOY_QT_DEBUG_POSTFIX}") + endif() + else() + # The Qt installation does only contain one build of the plugin. We match any + # possible debug suffix, or none. + string(APPEND plugin_regex ".*") + endif() + string(APPEND plugin_regex "\\.(so|dylib|dll)(\\.[0-9]+)*$") + + file(GLOB files LIST_DIRECTORIES false "${entry_PATH}/*${entry_PLUGIN}*") + list(FILTER files INCLUDE REGEX "${plugin_regex}") + endif() + file(INSTALL ${files} DESTINATION "${install_plugin}" USE_SOURCE_PERMISSIONS) + + get_filename_component(dest_plugin_abs "${dest_plugin}" ABSOLUTE) + if(__QT_DEPLOY_TOOL STREQUAL "GRD") + # Use the full plugin path for deployment. This is necessary for file(GRD) to + # resolve the dependencies of the plugins. + list(APPEND plugins_found ${files}) + else() + # Use relative paths for the plugins. If we used full paths here, macdeployqt would + # modify the RPATHS of plugins in the Qt installation. + file(RELATIVE_PATH rel_path "${install_prefix_abs}" "${dest_plugin_abs}") + foreach(file IN LISTS files) + get_filename_component(filename "${file}" NAME) + list(APPEND plugins_found "${rel_path}/${filename}") + endforeach() + endif() + + # Install runtime dependencies on Windows. + if(__QT_DEPLOY_SYSTEM_NAME STREQUAL "Windows") + foreach(file IN LISTS __QT_DEPLOY_TARGET_${entry_LINKTARGET}_RUNTIME_DLLS) + if(__QT_DEPLOY_VERBOSE) + message(STATUS "runtime dependency for QML plugin '${entry_PLUGIN}':") + endif() + file(INSTALL ${file} DESTINATION "${QT_DEPLOY_PREFIX}/${QT_DEPLOY_BIN_DIR}") + endforeach() + endif() + + if(__QT_DEPLOY_TOOL STREQUAL "GRD" AND __QT_DEPLOY_MUST_ADJUST_PLUGINS_RPATH) + # The RPATHs of the installed plugins do not match Qt's original lib directory. + # We must set the RPATH to point to QT_DEPLOY_LIBDIR. + _qt_internal_get_rpath_origin(rpath_origin) + foreach(file_path IN LISTS files) + get_filename_component(file_name ${file_path} NAME) + file(RELATIVE_PATH rel_lib_dir "${dest_plugin}" + "${QT_DEPLOY_PREFIX}/${QT_DEPLOY_LIB_DIR}" + ) + _qt_internal_set_rpath( + FILE "${dest_plugin}/${file_name}" + NEW_RPATH "${rpath_origin}/${rel_lib_dir}" + ) + endforeach() + endif() + + if(arg_BUNDLE) + # Actual plugin binaries will be in PlugIns, but qmldir files + # expect them to be in the same directory as themselves + # (i.e. under Resources/qml/...). Add a symlink at the place + # the qmldir expects the binary to be. This arrangement keeps + # binaries under PlugIns and non-binaries under Resources, + # which is required for code signing to work properly. + get_filename_component(dest_qmldir_abs "${dest_qmldir}" ABSOLUTE) + file(RELATIVE_PATH rel_path "${dest_qmldir_abs}" "${dest_plugin_abs}") + foreach(plugin_file IN LISTS files) + get_filename_component(filename "${plugin_file}" NAME) + + set(final_destination "${dest_qmldir}/${filename}") + message(STATUS "Symlinking: ${final_destination}") + file(CREATE_LINK "${rel_path}/${filename}" "${final_destination}" SYMBOLIC) + endforeach() + endif() + endforeach() + endif() + + set(${arg_PLUGINS_FOUND} ${plugins_found} PARENT_SCOPE) + +endfunction() + +function(_qt_internal_show_skip_qml_runtime_deploy_message) + # Don't show the message in static Qt builds, it can be misleading, because we still + # run qmlimportscanner / link the static qml plguins into the binary despite not having + # a qml deployment step. + if(__QT_DEPLOY_IS_SHARED_LIBS_BUILD) + message(STATUS "Skipping QML module deployment steps.") + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlFindQmlscInternal.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlFindQmlscInternal.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e7806c11a45ba7abb1114835d76a6a3ee35cd260 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlFindQmlscInternal.cmake @@ -0,0 +1,45 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +if (QT_NO_FIND_QMLSC) + return() +endif() + +set(QT_NO_FIND_QMLSC TRUE) + +# Set up QT_HOST_PATH as an extra root path to look for the Tools package +# when cross-compiling. +if(NOT "${QT_HOST_PATH}" STREQUAL "" AND NOT QT_INTERNAL_SKIP_QMLSC_HOST_PATHS_ADJUSTMENT) + set(_qt_backup_qmlsc_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH}) + set(_qt_backup_qmlsc_CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH}) + set(_qt_backup_qmlsc_CMAKE_SYSROOT ${CMAKE_SYSROOT}) + + list(PREPEND CMAKE_PREFIX_PATH "${QT_HOST_PATH_CMAKE_DIR}") + if(_qt_additional_host_packages_prefix_paths) + list(PREPEND CMAKE_PREFIX_PATH "${_qt_additional_host_packages_prefix_paths}") + endif() + + list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_HOST_PATH}") + if(_qt_additional_host_packages_root_paths) + list(PREPEND CMAKE_FIND_ROOT_PATH "${_qt_additional_host_packages_root_paths}") + endif() + if(NOT QT_INTERNAL_SKIP_QMLSC_SYSROOT_ADJUSTMENT) + unset(CMAKE_SYSROOT) + endif() +endif() + +# This can't use the find_package(Qt6 COMPONENTS) signature, because Qt6Config uses NO_DEFAULT and +# won't look at the prepended extra find root paths. +find_package(Qt6QmlCompilerPlusPrivateTools ${PROJECT_VERSION} QUIET CONFIG + PATHS + ${_qt_additional_host_packages_prefix_paths} +) + +if(NOT "${QT_HOST_PATH}" STREQUAL "" AND NOT QT_INTERNAL_SKIP_QMLSC_HOST_PATHS_ADJUSTMENT) + set(CMAKE_PREFIX_PATH ${_qt_backup_qmlsc_CMAKE_PREFIX_PATH}) + set(CMAKE_FIND_ROOT_PATH ${_qt_backup_qmlsc_CMAKE_FIND_ROOT_PATH}) + set(CMAKE_SYSROOT ${_qt_backup_qmlsc_CMAKE_SYSROOT}) + unset(_qt_backup_qmlsc_CMAKE_PREFIX_PATH) + unset(_qt_backup_qmlsc_CMAKE_FIND_ROOT_PATH) + unset(_qt_backup_qmlsc_CMAKE_SYSROOT) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlMacros.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlMacros.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9eb4274a9dd9e7333bff40a615bdd603566d76f6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlMacros.cmake @@ -0,0 +1,4954 @@ +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# +# Q6QmlMacros +# + +set(__qt_qml_macros_module_base_dir "${CMAKE_CURRENT_LIST_DIR}" CACHE INTERNAL "") + +# Install support uses the CMAKE_INSTALL_xxxDIR variables. Include this here +# so that it is more likely to get pulled in earlier at a higher level, and also +# to avoid re-including it many times later +include(GNUInstallDirs) +_qt_internal_add_deploy_support("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDeploySupport.cmake") + +# This function is used to parse DEPENDENCY and IMPORT entries passed to qt_add_qml_module +# It takes the entry as a mandatory argument, and then sets the following +# user provided properties in the callers scope +# OUTPUT_URI : the URI of the module; mandatory argument +# OUTPUT_VERSION : the requested version of the module; will potentially be empty; mandatory +# OUTPUT_MODULE_LOCATION : the folder in which the module is located; optional; can be used to extract potential import path +# OUTPUT_MODULE_TARGET : the target corresponding to the module + +function(_qt_internal_parse_qml_module_dependency dependency was_marked_as_target) + set(args_option "") + set(args_single OUTPUT_URI OUTPUT_VERSION OUTPUT_MODULE_LOCATION OUTPUT_MODULE_TARGET) + set(args_multi QML_FILES IMPORT_PATHS) + + cmake_parse_arguments(PARSE_ARGV 2 arg + "${args_option}" "${args_single}" "${args_multi}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown/unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if(NOT arg_OUTPUT_URI) + message(FATAL_ERROR "Missing output URI variable") + endif() + if(NOT arg_OUTPUT_VERSION) + message(FATAL_ERROR "Missing output version variable") + endif() + + set(dep_version "") + set(dep_target_or_uri "") + string(FIND "${dependency}" "/" slash_position REVERSE) + if(slash_position EQUAL -1) + set(dep_target_or_uri "${dependency}") + else() + string(SUBSTRING "${dependency}" 0 ${slash_position} dep_module) + math(EXPR slash_position "${slash_position} + 1") + string(SUBSTRING "${dependency}" ${slash_position} -1 dep_version) + if(NOT dep_version MATCHES "^([0-9]+(\\.[0-9]+)?|auto)$") + message(FATAL_ERROR + "Invalid module dependency version number. " + "Expected 'VersionMajor', 'VersionMajor.VersionMinor' or 'auto'." + ) + endif() + set(dep_target_or_uri "${dep_module}") + endif() + if("${was_marked_as_target}" AND NOT TARGET ${dep_target_or_uri}) + message(FATAL_ERROR "Argument ${dep_target_or_uri} is not a target!") + endif() + if("${was_marked_as_target}") + qt6_query_qml_module(${dep_target_or_uri} + URI dependency_uri + QMLDIR qmldir_location + ) + set(dep_module ${dependency_uri}) + else() + set(dep_module "${dep_target_or_uri}") + endif() + set(${arg_OUTPUT_URI} ${dep_module} PARENT_SCOPE) + set(${arg_OUTPUT_VERSION} ${dep_version} PARENT_SCOPE) + if(arg_OUTPUT_MODULE_LOCATION) + if(was_marked_as_target) + if(NOT qmldir_location) + message(FATAL_ERROR "module has no qmldir! Given target was ${dep_target_or_uri}") + endif() + set(module_location "${qmldir_location}") + string(REGEX MATCHALL "\\." matches "${dependency_uri}") + list(LENGTH matches go_up_count) + # inclusive, which is what we want here: go up once for the qmldir, + # and then once per separated component + foreach(i RANGE ${go_up_count}) + get_filename_component(module_location "${module_location}" DIRECTORY) + endforeach() + set(${arg_OUTPUT_MODULE_LOCATION} "${module_location}" PARENT_SCOPE) + else() + set(${arg_OUTPUT_MODULE_LOCATION} "NOTFOUND" PARENT_SCOPE) + endif() + endif() + if (arg_OUTPUT_MODULE_TARGET AND was_marked_as_target) + set(${arg_OUTPUT_MODULE_TARGET} "${dep_target_or_uri}" PARENT_SCOPE) + else() + set(${arg_OUTPUT_MODULE_TARGET} "" PARENT_SCOPE) + endif() +endfunction() + +function(_qt_internal_write_qmldir_part target) + set(effective_outdir $) + set(qtconf_file "${effective_outdir}/${target}_qt.part.conf") + get_target_property(dependency_targets "${target}" QT_QML_DEPENDENT_QML_MODULE_TARGETS) + get_directory_property(counter + DIRECTORY ${PROJECT_SOURCE_DIR} + QT_QMLDIR_DEFERRED_WRITEOUT_COUNTER + ) + math(EXPR counter "${counter} - 1") + set_property( + DIRECTORY ${PROJECT_SOURCE_DIR} + PROPERTY QT_QMLDIR_DEFERRED_WRITEOUT_COUNTER "${counter}" + ) + if(dependency_targets) + foreach(dep_target ${dependency_targets}) + qt6_query_qml_module(${dep_target} + QMLDIR qmldir_location + ) + get_filename_component(module_location "${qmldir_location}" DIRECTORY) + get_filename_component(module_import_path "${module_location}" DIRECTORY) + list(APPEND qt_all_qml_output_dirs ${module_import_path}) + endforeach() + if (qt_all_qml_output_dirs) + list(REMOVE_DUPLICATES qt_all_qml_output_dirs) + # TODO: this will break for paths containing a newline character.. + list(JOIN qt_all_qml_output_dirs "\n" qt_all_qml_output_dirs) + + file(GENERATE + OUTPUT "${qtconf_file}" + CONTENT "${qt_all_qml_output_dirs}\n" + ) + set_property( + DIRECTORY ${PROJECT_SOURCE_DIR} + APPEND + PROPERTY QT_QMLDIR_ALL_PARTS "${qtconf_file}" + ) + set_property( + DIRECTORY ${PROJECT_SOURCE_DIR} + APPEND + PROPERTY QT_QMLDIR_DEFERRED_WRITEOUT_ALL_TARGETS "${target}") + endif() + endif() + + if (counter EQUAL 0) + # counter reached zero, all relevant finalizers are done + get_directory_property(all_parts DIRECTORY ${PROJECT_SOURCE_DIR} QT_QMLDIR_ALL_PARTS) + if (NOT all_parts) + return() + endif() + list(JOIN all_parts "\n" all_parts_string) + set(command_args_location "${PROJECT_BINARY_DIR}/.qt/qtconf_list_$") + file(GENERATE + OUTPUT "${command_args_location}" + CONTENT "${all_parts_string}\n" + ) + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + add_custom_command( + OUTPUT "${command_args_location}.done" + COMMAND + ${tool_wrapper} + $ + --merge-qt-conf "${command_args_location}" + COMMENT "Generating qt.conf file" + DEPENDS + ${all_parts} + ${QT_CMAKE_EXPORT_NAMESPACE}::qmltyperegistrar + ) + # actually not specific to $target, but we need a unique identifier + set(customtargetname "generate_finalqtconf_${target}") + add_custom_target("${customtargetname}" DEPENDS "${command_args_location}.done") + get_directory_property(all_targets + DIRECTORY ${PROJECT_SOURCE_DIR} + QT_QMLDIR_DEFERRED_WRITEOUT_ALL_TARGETS + ) + foreach (moduleTarget ${all_targets}) + add_dependencies(${moduleTarget} "${customtargetname}") + endforeach() + endif() +endfunction() + +function(_qt_internal_writebuilddir_qtconf_nondeferred property_folder writeout_folder) + set(qt_all_qml_output_dirs "") + get_directory_property(targets + DIRECTORY "${property_folder}" + QT_QML_TARGETS_FOR_DEFERRED_QTCONF_WRITEOUT + ) + set(qtconf_file "${writeout_folder}/qt.conf") + foreach(target IN LISTS targets) + get_target_property(dependency_targets "${target}" QT_QML_DEPENDENT_QML_MODULE_TARGETS) + if(NOT dependency_targets) + continue() + endif() + foreach(dep_target ${dependency_targets}) + qt6_query_qml_module(${dep_target} + QMLDIR qmldir_location + ) + get_filename_component(module_location "${qmldir_location}" DIRECTORY) + get_filename_component(module_import_path "${module_location}" DIRECTORY) + list(APPEND qt_all_qml_output_dirs ${module_import_path}) + endforeach() + endforeach() + if (NOT qt_all_qml_output_dirs) + return() + endif() + + list(REMOVE_DUPLICATES qt_all_qml_output_dirs) + # add quotes to deal with whitespace + list(TRANSFORM qt_all_qml_output_dirs APPEND "\"") + list(TRANSFORM qt_all_qml_output_dirs PREPEND "\"") + list(JOIN qt_all_qml_output_dirs "," qt_all_qml_output_dirs) + + configure_file( + ${__qt_qml_macros_module_base_dir}/Qt6qt.conf.in ${qtconf_file} + @ONLY + ) +endfunction() + + +function(qt6_add_qml_module target) + set(args_option + STATIC + SHARED + DESIGNER_SUPPORTED + FOLLOW_FOREIGN_VERSIONING + AUTO_RESOURCE_PREFIX + NO_PLUGIN + NO_PLUGIN_OPTIONAL + NO_CREATE_PLUGIN_TARGET + NO_GENERATE_PLUGIN_SOURCE + NO_GENERATE_QMLTYPES + NO_GENERATE_QMLDIR + NO_GENERATE_EXTRA_QMLDIRS + NO_LINT + NO_CACHEGEN + NO_RESOURCE_TARGET_PATH + NO_IMPORT_SCAN + ENABLE_TYPE_COMPILER + + # Used to mark modules as having static side effects (i.e. if they install an image provider) + __QT_INTERNAL_STATIC_MODULE + # Used to mark modules as being a system module that provides all builtins + __QT_INTERNAL_SYSTEM_MODULE + # Give the resource for the qmldir a unique name; TODO: Remove once we can + __QT_INTERNAL_DISAMBIGUATE_QMLDIR_RESOURCE + ) + + set(args_single + PLUGIN_TARGET + INSTALLED_PLUGIN_TARGET # Internal option only, it may be removed + OUTPUT_TARGETS + RESOURCE_PREFIX + URI + TARGET_PATH # Internal option only, it may be removed + VERSION + OUTPUT_DIRECTORY + CLASS_NAME + TYPEINFO + NAMESPACE + # TODO: We don't handle installation, warn if callers used these with the old + # API and eventually remove them once we have updated all other repos + RESOURCE_EXPORT + INSTALL_DIRECTORY + INSTALL_LOCATION + TYPE_COMPILER_NAMESPACE + QMLTC_EXPORT_DIRECTIVE + QMLTC_EXPORT_FILE_NAME + ) + + set(args_multi + SOURCES + QML_FILES + RESOURCES + IMPORTS + IMPORT_PATH + OPTIONAL_IMPORTS + DEFAULT_IMPORTS + DEPENDENCIES + PAST_MAJOR_VERSIONS + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${args_option}" + "${args_single}" + "${args_multi}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown/unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + # Warn about options we no longer need/use (these were used by the internal + # targets and examples, but the logic has been shifted to + # qt_internal_add_qml_module() or left as a responsibility of the caller). + if(DEFINED arg_RESOURCE_EXPORT) + message(AUTHOR_WARNING + "RESOURCE_EXPORT will be ignored. This function does not handle " + "installation, which is what RESOURCE_EXPORT was previously used " + "for. Please update your project to install the target directly." + ) + endif() + + if(DEFINED arg_INSTALL_DIRECTORY) + message(AUTHOR_WARNING + "INSTALL_DIRECTORY will be ignored. This function does not handle " + "installation, please update your project to install the target " + "directly." + ) + endif() + + if(DEFINED arg_INSTALL_LOCATION) + message(AUTHOR_WARNING + "INSTALL_LOCATION will be ignored. This function does not handle " + "installation, please update your project to install the target " + "directly." + ) + endif() + + # Mandatory arguments + if (NOT arg_URI) + message(FATAL_ERROR + "Called without a module URI. Please specify one using the URI argument." + ) + endif() + + _qt_internal_require_qml_uri_valid("${arg_URI}") + + if (NOT arg_VERSION) + set(arg_VERSION "254.254") + elseif ("${arg_VERSION}" MATCHES "^([0-9]+\\.[0-9]+)\\.[0-9]+$") + set(arg_VERSION "${CMAKE_MATCH_1}") + elseif (NOT "${arg_VERSION}" MATCHES "^[0-9]+\\.[0-9]+$") + message(FATAL_ERROR + "Called with an invalid version argument: '${arg_VERSION}'. " + "Expected version in the form: VersionMajor.VersionMinor." + ) + endif() + + if(QT_QML_NO_CACHEGEN) + set(arg_NO_CACHEGEN TRUE) + endif() + + # Other arguments and checking for invalid combinations + if (NOT arg_TARGET_PATH) + # NOTE: This will always be used for copying things to the build + # directory, but it will not be used for resource paths if + # NO_RESOURCE_TARGET_PATH was given. + string(REPLACE "." "/" arg_TARGET_PATH ${arg_URI}) + endif() + + if(arg_NO_PLUGIN AND DEFINED arg_PLUGIN_TARGET) + message(FATAL_ERROR + "NO_PLUGIN was specified, but PLUGIN_TARGET was also given. " + "At most one of these can be present." + ) + endif() + + if (NOT arg_ENABLE_TYPE_COMPILER) + if (DEFINED arg_TYPE_COMPILER_NAMESPACE) + message(WARNING + "TYPE_COMPILER_NAMESPACE is set, but ENABLE_TYPE_COMPILER is not specified. " + "The TYPE_COMPILER_NAMESPACE value will be ignored." + ) + endif() + + if (DEFINED arg_QMLTC_EXPORT_DIRECTIVE) + message(WARNING + "QMLTC_EXPORT_DIRECTIVE is set, but ENABLE_TYPE_COMPILER is not specified. " + "The QMLTC_EXPORT_DIRECTIVE value will be ignored." + ) + endif() + if (DEFINED arg_QMLTC_EXPORT_FILE_NAME) + message(WARNING + "QMLTC_EXPORT_FILE_NAME is set, but ENABLE_TYPE_COMPILER is not specified. " + "The QMLTC_EXPORT_FILE_NAME will be ignored." + ) + endif() + else() + if ((DEFINED arg_QMLTC_EXPORT_FILE_NAME) AND (NOT (DEFINED arg_QMLTC_EXPORT_DIRECTIVE))) + message(FATAL_ERROR + "Specifying a value for QMLTC_EXPORT_FILE_NAME also requires one for QMLTC_EXPORT_DIRECTIVE." + ) + endif() + endif() + + set(is_executable FALSE) + if(TARGET ${target}) + if(arg_STATIC OR arg_SHARED) + message(FATAL_ERROR + "Cannot use STATIC or SHARED keyword when passed an existing target (${target})" + ) + endif() + + # With CMake 3.17 and earlier, a source file's generated property isn't + # visible outside of the directory scope in which it is set. That can + # lead to build errors for things like type registration due to CMake + # thinking nothing will create a missing file on the first run. With + # CMake 3.18 or later, we can force that visibility. Policy CMP0118 + # added in CMake 3.20 should have made this unnecessary, but we can't + # rely on that because the user project controls what it is set to at + # the point where it matters, which is the end of the target's + # directory scope (hence we can't even test for it here). + get_target_property(source_dir ${target} SOURCE_DIR) + if(NOT source_dir STREQUAL CMAKE_CURRENT_SOURCE_DIR AND + CMAKE_VERSION VERSION_LESS "3.18") + message(WARNING + "qt6_add_qml_module() is being called in a different " + "directory scope to the one in which the target \"${target}\" " + "was created. CMake 3.18 or later is required to generate a " + "project robustly for this scenario, but you are using " + "CMake ${CMAKE_VERSION}. Ideally, qt6_add_qml_module() should " + "only be called from the same scope as the one the target was " + "created in to avoid dependency and visibility problems." + ) + endif() + + get_target_property(backing_target_type ${target} TYPE) + get_target_property(is_android_executable "${target}" _qt_is_android_executable) + if (backing_target_type STREQUAL "EXECUTABLE" OR is_android_executable) + if(DEFINED arg_PLUGIN_TARGET) + message(FATAL_ERROR + "A QML module with an executable as its backing target " + "cannot have a plugin." + ) + endif() + if(arg_NO_CREATE_PLUGIN_TARGET) + message(WARNING + "A QML module with an executable as its backing target " + "cannot have a plugin. The NO_CREATE_PLUGIN_TARGET option " + "has no effect and should be removed." + ) + endif() + set(arg_NO_PLUGIN TRUE) + set(lib_type "") + set(is_executable TRUE) + elseif(arg_NO_RESOURCE_TARGET_PATH) + message(FATAL_ERROR + "NO_RESOURCE_TARGET_PATH cannot be used for a backing target " + "that is not an executable" + ) + elseif(backing_target_type STREQUAL "STATIC_LIBRARY") + set(lib_type STATIC) + elseif(backing_target_type MATCHES "(SHARED|MODULE)_LIBRARY") + set(lib_type SHARED) + else() + message(FATAL_ERROR "Unsupported backing target type: ${backing_target_type}") + endif() + else() + if(arg_STATIC AND arg_SHARED) + message(FATAL_ERROR + "Both STATIC and SHARED specified, at most one can be given" + ) + endif() + + if(arg_NO_RESOURCE_TARGET_PATH) + message(FATAL_ERROR + "NO_RESOURCE_TARGET_PATH can only be provided when an existing " + "executable target is passed in as the backing target" + ) + endif() + + # Explicit arguments take precedence, otherwise default to using the same + # staticality as what Qt was built with. This follows the already + # established default behavior for building ordinary Qt plugins. + # We don't allow the standard CMake BUILD_SHARED_LIBS variable to control + # the default because that can lead to different defaults depending on + # whether you build with a separate backing target or not. + if(arg_STATIC) + set(lib_type STATIC) + elseif(arg_SHARED) + set(lib_type SHARED) + elseif(QT6_IS_SHARED_LIBS_BUILD) + set(lib_type SHARED) + else() + set(lib_type STATIC) + endif() + endif() + + if(arg_NO_PLUGIN) + # Simplifies things a bit further below + set(arg_PLUGIN_TARGET "") + elseif(NOT DEFINED arg_PLUGIN_TARGET) + if(arg_NO_CREATE_PLUGIN_TARGET) + # We technically could allow this and rely on the project using the + # default plugin target name, but not doing so gives us the + # flexibility to potentially change that default later if needed. + message(FATAL_ERROR + "PLUGIN_TARGET must also be provided when NO_CREATE_PLUGIN_TARGET " + "is used. If you want to disable creating a plugin altogether, " + "use the NO_PLUGIN option instead." + ) + endif() + set(arg_PLUGIN_TARGET ${target}plugin) + endif() + if(arg_NO_CREATE_PLUGIN_TARGET AND arg_PLUGIN_TARGET STREQUAL target AND NOT TARGET ${target}) + message(FATAL_ERROR + "PLUGIN_TARGET is the same as the backing target, which is allowed, " + "but NO_CREATE_PLUGIN_TARGET was also given and the target does not " + "exist. Either ensure the target is already created or do not " + "specify NO_CREATE_PLUGIN_TARGET." + ) + endif() + if(NOT arg_INSTALLED_PLUGIN_TARGET) + set(arg_INSTALLED_PLUGIN_TARGET ${arg_PLUGIN_TARGET}) + endif() + + set(no_gen_source) + if(arg_NO_GENERATE_PLUGIN_SOURCE) + set(no_gen_source NO_GENERATE_PLUGIN_SOURCE) + endif() + + if(arg_OUTPUT_DIRECTORY) + get_filename_component(arg_OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}" + ABSOLUTE BASE_DIR "${CMAKE_CURRENT_BINARY_DIR}" + ) + else() + if("${QT_QML_OUTPUT_DIRECTORY}" STREQUAL "") + set(arg_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + # For libraries, we assume/require that the source directory + # structure is consistent with the target path. For executables, + # the source directory will usually not reflect the target path + # and the project will often expect to be able to use resource + # paths that don't include the target path (they need the + # NO_RESOURCE_TARGET_PATH option if they do that). Tooling always + # needs the target path in the file system though, so the output + # directory should always have it. Handle the special case for + # executables to ensure this is what we get. + if(is_executable) + string(APPEND arg_OUTPUT_DIRECTORY "/${arg_TARGET_PATH}") + endif() + else() + if(NOT IS_ABSOLUTE "${QT_QML_OUTPUT_DIRECTORY}") + message(FATAL_ERROR + "QT_QML_OUTPUT_DIRECTORY must be an absolute path, but given: " + "${QT_QML_OUTPUT_DIRECTORY}" + ) + endif() + # This inherently does what we want for libraries and executables + set(arg_OUTPUT_DIRECTORY ${QT_QML_OUTPUT_DIRECTORY}/${arg_TARGET_PATH}) + endif() + endif() + + # Sanity check that we are not trying to have two different QML modules use + # the same output directory. + _qt_internal_find_qml_module(other_target BY_OUTPUT_DIR "${arg_OUTPUT_DIRECTORY}") + if(other_target) + message(FATAL_ERROR + "Output directory for target \"${target}\" is already used by " + "another QML module (target \"${other_target}\"). " + "Output directory is:\n ${arg_OUTPUT_DIRECTORY}\n" + ) + endif() + + set_property(GLOBAL APPEND PROPERTY _qt_all_qml_uris ${arg_URI}) + set_property(GLOBAL APPEND PROPERTY _qt_all_qml_output_dirs ${arg_OUTPUT_DIRECTORY}) + set_property(GLOBAL APPEND PROPERTY _qt_all_qml_targets ${target}) + + if(NOT arg_CLASS_NAME AND TARGET "${arg_PLUGIN_TARGET}") + get_target_property(class_name ${arg_PLUGIN_TARGET} QT_PLUGIN_CLASS_NAME) + if(class_name) + set(arg_CLASS_NAME) + endif() + endif() + if(NOT arg_CLASS_NAME) + _qt_internal_compute_qml_plugin_class_name_from_uri("${arg_URI}" arg_CLASS_NAME) + endif() + + if(TARGET ${target}) + if(arg_PLUGIN_TARGET STREQUAL target) + # Insert the plugin's URI into its meta data to enable usage + # of static plugins in QtDeclarative (like in mkspecs/features/qml_plugin.prf). + set_property(TARGET ${target} APPEND PROPERTY + AUTOMOC_MOC_OPTIONS "-Muri=${arg_URI}" + ) + endif() + else() + if(arg_PLUGIN_TARGET STREQUAL target) + set(conditional_args ${no_gen_source}) + if(arg_NAMESPACE) + list(APPEND conditional_args NAMESPACE ${arg_NAMESPACE}) + endif() + qt6_add_qml_plugin(${target} + ${lib_type} + OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + URI ${arg_URI} + CLASS_NAME ${arg_CLASS_NAME} + ${conditional_args} + ) + else() + qt6_add_library(${target} ${lib_type}) + endif() + endif() + + if(NOT target STREQUAL Qml) + target_link_libraries(${target} PRIVATE ${QT_CMAKE_EXPORT_NAMESPACE}::Qml) + endif() + + if(NOT arg_TYPEINFO AND NOT arg_NO_GENERATE_QMLTYPES) + set(arg_TYPEINFO ${target}.qmltypes) + endif() + + set(all_qml_import_paths "${arg_IMPORT_PATH}") + set(all_dependency_targets) + + set(original_no_show_policy_value "${QT_NO_SHOW_OLD_POLICY_WARNINGS}") + # silent by default, we only warn if someone uses TARGET as a URI + set(QT_NO_SHOW_OLD_POLICY_WARNINGS TRUE) + __qt_internal_setup_policy(QTP0005 "6.8.0" + "" # intentionally empty as we silence the warning anyway + ) + qt6_policy(GET QTP0005 allow_targets_for_dependencies_policy) + set(QT_NO_SHOW_OLD_POLICY_WARNINGS "${original_no_show_policy_value}") + string(COMPARE EQUAL "${allow_targets_for_dependencies_policy}" "NEW" target_is_keyword) + + + set(target_keyword_was_set FALSE) + foreach(import_set IN ITEMS IMPORTS OPTIONAL_IMPORTS DEFAULT_IMPORTS) + foreach(import IN LISTS arg_${import_set}) + if (import STREQUAL "TARGET") + if (target_is_keyword) + set(target_keyword_was_set TRUE) + continue() + else() + message(AUTHOR_WARNING "TARGET is treated as a URI because QTP0005 is set to OLD. This is deprecated behavior. Check https://doc.qt.io/qt-6/qt-cmake-policy-qtp0005.html for policy details.") + set(target_keyword_was_set FALSE) + endif() + endif() + _qt_internal_parse_qml_module_dependency(${import} ${target_keyword_was_set} + OUTPUT_URI import_uri + OUTPUT_VERSION import_version + OUTPUT_MODULE_LOCATION module_location + OUTPUT_MODULE_TARGET dependency_target + ) + get_filename_component(module_import_path "${module_location}" DIRECTORY) + list(APPEND all_qml_import_paths "${module_import_path}") + + if (NOT "${import_version}" STREQUAL "") + set_property(TARGET ${target} APPEND PROPERTY + QT_QML_MODULE_${import_set} "${import_uri} ${import_version}" + ) + else() + set_property(TARGET ${target} APPEND PROPERTY + QT_QML_MODULE_${import_set} "${import_uri}" + ) + endif() + if(TARGET "${dependency_target}") + list(APPEND all_dependency_targets "${dependency_target}") + endif() + set(target_keyword_was_set FALSE) + endforeach() + endforeach() + + foreach(dependency IN LISTS arg_DEPENDENCIES) + + if (dependency STREQUAL "TARGET") + if (target_is_keyword) + set(target_keyword_was_set TRUE) + continue() + else() + message(AUTHOR_WARNING "TARGET is treated as a URI because QTP0005 is set to OLD. This is deprecated behavior. Check https://doc.qt.io/qt-6/qt-cmake-policy-qtp0005.html for policy details.") + set(target_keyword_was_set FALSE) + endif() + endif() + _qt_internal_parse_qml_module_dependency(${dependency} "${target_keyword_was_set}" + OUTPUT_URI dep_uri + OUTPUT_VERSION dep_version + OUTPUT_MODULE_LOCATION module_location + OUTPUT_MODULE_TARGET dependency_target + ) + get_filename_component(module_import_path "${module_location}" DIRECTORY) + list(APPEND all_qml_import_paths "${module_import_path}") + if (NOT "${dep_version}" STREQUAL "") + set_property(TARGET ${target} APPEND PROPERTY + QT_QML_MODULE_DEPENDENCIES "${dep_uri} ${dep_version}" + ) + else() + set_property(TARGET ${target} APPEND PROPERTY + QT_QML_MODULE_DEPENDENCIES "${dep_uri}" + ) + endif() + set(target_keyword_was_set FALSE) + if(TARGET "${dependency_target}") + list(APPEND all_dependency_targets "${dependency_target}") + endif() + endforeach() + ### TODO: add support for transitive dependencies, too + list(REMOVE_DUPLICATES all_dependency_targets) + set_property(TARGET ${target} PROPERTY QT_QML_DEPENDENT_QML_MODULE_TARGETS "${all_dependency_targets}") + _qt_internal_collect_qml_module_dependencies(${target}) + + if(arg_AUTO_RESOURCE_PREFIX) + if(arg_RESOURCE_PREFIX) + message(FATAL_ERROR + "Both RESOURCE_PREFIX and AUTO_RESOURCE_PREFIX are specified for ${target}. " + "You can only have one." + ) + else() + set(arg_RESOURCE_PREFIX "/qt/qml") + message(DEPRECATION "AUTO_RESOURCE_PREFIX is deprecated. " + "Please use the qt_policy(SET) command to set the QTP0001 policy, " + "or use the qt_standard_project_setup() command to set your preferred " + "REQUIRES to get the preferred behavior. " + "Check https://doc.qt.io/qt-6/qt-cmake-policy-qtp0001.html for policy details.") + endif() + elseif(arg_RESOURCE_PREFIX) + _qt_internal_canonicalize_resource_path("${arg_RESOURCE_PREFIX}" arg_RESOURCE_PREFIX) + elseif(arg_NO_RESOURCE_TARGET_PATH) + # Suppress the warning if NO_RESOURCE_TARGET_PATH is given. + # In that case, we assume the user knows what they want. + set(arg_RESOURCE_PREFIX "/") + else() + __qt_internal_setup_policy(QTP0001 "6.5.0" +"':/qt/qml/' is the default resource prefix for QML modules. \ +Check https://doc.qt.io/qt-6/qt-cmake-policy-qtp0001.html for policy details." + ) + qt6_policy(GET QTP0001 use_auto_prefix_policy) + if ("${use_auto_prefix_policy}" STREQUAL "NEW") + set(arg_RESOURCE_PREFIX "/qt/qml") + else() + set(arg_RESOURCE_PREFIX "/") + endif() + endif() + + if(arg_NO_RESOURCE_TARGET_PATH) + set(qt_qml_module_resource_prefix "${arg_RESOURCE_PREFIX}") + else() + if(arg_RESOURCE_PREFIX STREQUAL "/") # Checked so we prevent double-slash + set(qt_qml_module_resource_prefix "/${arg_TARGET_PATH}") + else() + set(qt_qml_module_resource_prefix "${arg_RESOURCE_PREFIX}/${arg_TARGET_PATH}") + endif() + endif() + + list(REMOVE_DUPLICATES all_qml_import_paths) + + set_target_properties(${target} PROPERTIES + QT_QML_MODULE_NO_LINT "${arg_NO_LINT}" + QT_QML_MODULE_NO_CACHEGEN "${arg_NO_CACHEGEN}" + QT_QML_MODULE_NO_GENERATE_QMLDIR "${arg_NO_GENERATE_QMLDIR}" + QT_QML_MODULE_NO_GENERATE_EXTRA_QMLDIRS "${arg_NO_GENERATE_EXTRA_QMLDIRS}" + QT_QML_MODULE_NO_PLUGIN "${arg_NO_PLUGIN}" + QT_QML_MODULE_NO_PLUGIN_OPTIONAL "${arg_NO_PLUGIN_OPTIONAL}" + QT_QML_MODULE_NO_IMPORT_SCAN "${arg_NO_IMPORT_SCAN}" + _qt_qml_module_follow_foreign_versioning "${arg_FOLLOW_FOREIGN_VERSIONING}" + QT_QML_MODULE_URI "${arg_URI}" + QT_QML_MODULE_TARGET_PATH "${arg_TARGET_PATH}" + QT_QML_MODULE_VERSION "${arg_VERSION}" + QT_QML_MODULE_CLASS_NAME "${arg_CLASS_NAME}" + + QT_QML_MODULE_PLUGIN_TARGET "${arg_PLUGIN_TARGET}" + QT_QML_MODULE_INSTALLED_PLUGIN_TARGET "${arg_INSTALLED_PLUGIN_TARGET}" + + # Also Save the PLUGIN_TARGET values in a separate property to circumvent + # https://gitlab.kitware.com/cmake/cmake/-/issues/21484 when exporting the properties + _qt_qml_module_plugin_target "${arg_PLUGIN_TARGET}" + _qt_qml_module_installed_plugin_target "${arg_INSTALLED_PLUGIN_TARGET}" + + QT_QML_MODULE_DESIGNER_SUPPORTED "${arg_DESIGNER_SUPPORTED}" + QT_QML_MODULE_IS_STATIC "${arg___QT_INTERNAL_STATIC_MODULE}" + QT_QML_MODULE_IS_SYSTEM "${arg___QT_INTERNAL_SYSTEM_MODULE}" + QT_QML_MODULE_OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}" + QT_QML_MODULE_RESOURCE_PREFIX "${qt_qml_module_resource_prefix}" + QT_QML_MODULE_PAST_MAJOR_VERSIONS "${arg_PAST_MAJOR_VERSIONS}" + QT_QML_MODULE_NAMESPACE "${arg_NAMESPACE}" + + # TODO: Check how this is used by qt6_android_generate_deployment_settings() + QT_QML_IMPORT_PATH "${all_qml_import_paths}" + ) + + if(arg_TYPEINFO) + set_target_properties(${target} PROPERTIES + QT_QML_MODULE_TYPEINFO "${arg_TYPEINFO}" + ) + endif() + + # Executables don't have a plugin target, so no need to export the properties. + if(NOT backing_target_type STREQUAL "EXECUTABLE" AND NOT is_android_executable) + set_property(TARGET ${target} APPEND PROPERTY + EXPORT_PROPERTIES _qt_qml_module_plugin_target _qt_qml_module_installed_plugin_target + ) + endif() + + if(NOT arg_NO_GENERATE_QMLTYPES) + set(type_registration_extra_args "") + if(arg_NAMESPACE) + list(APPEND type_registration_extra_args NAMESPACE ${arg_NAMESPACE}) + endif() + set_target_properties(${target} PROPERTIES _qt_internal_has_qmltypes TRUE) + _qt_internal_qml_type_registration(${target} ${type_registration_extra_args}) + else() + set_target_properties(${target} PROPERTIES _qt_internal_has_qmltypes FALSE) + endif() + + set(output_targets) + + if(NOT arg_NO_GENERATE_QMLDIR) + _qt_internal_target_generate_qmldir(${target}) + set_source_files_properties(${arg_OUTPUT_DIRECTORY}/qmldir + PROPERTIES GENERATED TRUE + ) + + if(${arg___QT_INTERNAL_DISAMBIGUATE_QMLDIR_RESOURCE}) + # TODO: Make this the default and remove the option + string(REPLACE "/" "_" qmldir_resource_name "${target}_qmldir_${arg_TARGET_PATH}") + else() + # Embed qmldir in qrc. The following comments relate mostly to Qt5->6 transition. + # The requirement to keep the same resource name might no longer apply, but it doesn't + # currently appear to cause any hinderance to keep it. + # The qmldir resource name needs to match the one generated by qmake's qml_module.prf, + # to ensure that all Q_INIT_RESOURCE(resource_name) calls in Qt code don't lead to + # undefined symbol errors when linking an application project. + # The Q_INIT_RESOURCE() calls are not strictly necessary anymore because the CMake Qt + # build passes around the compiled resources as object files. + # These object files have global initiliazers that don't get discared when linked into + # an application (as opposed to when the resource libraries were embedded into the + # static libraries when Qt was built with qmake). + # The reason to match the naming is to ensure that applications link successfully + # regardless if Qt was built with CMake or qmake, while the build system transition + # phase is still happening. + string(REPLACE "/" "_" qmldir_resource_name "qmake_${arg_TARGET_PATH}") + endif() + + # The qmldir file ALWAYS has to be under the target path, even in the + # resources. If it isn't, an explicit import can't find it. We need a + # second copy NOT under the target path if NO_RESOURCE_TARGET_PATH is + # given so that the implicit import will work. + set(prefixes "${qt_qml_module_resource_prefix}") + if(arg_NO_RESOURCE_TARGET_PATH) + # The above prefixes item won't include the target path, so add a + # second one that does. + if(qt_qml_module_resource_prefix STREQUAL "/") + list(APPEND prefixes "/${arg_TARGET_PATH}") + else() + list(APPEND prefixes "${qt_qml_module_resource_prefix}/${arg_TARGET_PATH}") + endif() + endif() + set_source_files_properties(${arg_OUTPUT_DIRECTORY}/qmldir + PROPERTIES QT_RESOURCE_ALIAS "qmldir" + ) + + foreach(prefix IN LISTS prefixes) + set(resource_targets) + qt6_add_resources(${target} ${qmldir_resource_name} + FILES ${arg_OUTPUT_DIRECTORY}/qmldir + PREFIX "${prefix}" + OUTPUT_TARGETS resource_targets + ) + + # Save the resource name in a property so we can reference it later in a qml plugin + # constructor, to avoid discarding the resource if it's in a static library. + __qt_internal_sanitize_resource_name( + sanitized_qmldir_resource_name "${qmldir_resource_name}") + set_property(TARGET ${target} APPEND PROPERTY + _qt_qml_module_sanitized_resource_names "${sanitized_qmldir_resource_name}") + + list(APPEND output_targets ${resource_targets}) + # If we are adding the same file twice, we need a different resource + # name for the second one. It has the same QT_RESOURCE_ALIAS but a + # different prefix, so we can't put it in the same resource. + string(APPEND qmldir_resource_name "_copy") + endforeach() + endif() + + if(NOT arg_NO_PLUGIN AND NOT arg_NO_CREATE_PLUGIN_TARGET) + # This also handles the case where ${arg_PLUGIN_TARGET} already exists, + # including where it is the same as ${target}. If ${arg_PLUGIN_TARGET} + # already exists, it will update the necessary things that are specific + # to qml plugins. + if(TARGET ${arg_PLUGIN_TARGET}) + set(plugin_args "") + else() + set(plugin_args ${lib_type}) + endif() + list(APPEND plugin_args ${no_gen_source}) + if(arg_NAMESPACE) + list(APPEND plugin_args NAMESPACE ${arg_NAMESPACE}) + endif() + qt6_add_qml_plugin(${arg_PLUGIN_TARGET} + ${plugin_args} + OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + BACKING_TARGET ${target} + CLASS_NAME ${arg_CLASS_NAME} + ) + endif() + + if(TARGET "${arg_PLUGIN_TARGET}" AND NOT arg_PLUGIN_TARGET STREQUAL target) + target_link_libraries(${arg_PLUGIN_TARGET} PRIVATE ${target}) + endif() + + target_sources(${target} PRIVATE ${arg_SOURCES}) + + # QML tooling might need to map build dir paths to source dir paths. Create + # a mapping file before qt6_target_qml_sources() to be able to use it + _qt_internal_qml_map_build_files(${target} ${qt_qml_module_resource_prefix} dir_map_qrc) + # use different property from _qt_generated_qrc_files since this qrc is + # special (and is not a real resource file) + set_property(TARGET ${target} APPEND PROPERTY _qt_qml_meta_qrc_files "${dir_map_qrc}") + + set(cache_target) + qt6_target_qml_sources(${target} + __QT_INTERNAL_FORCE_DEFER_QMLDIR + QML_FILES ${arg_QML_FILES} + RESOURCES ${arg_RESOURCES} + OUTPUT_TARGETS cache_target + PREFIX "${qt_qml_module_resource_prefix}" + ADDING_QML_MODULE + ) + list(APPEND output_targets ${cache_target}) + + # Build an init object library for static plugins and propagate it along with the plugin + # target. + # TODO: Figure out if we can move this code block into qt_add_qml_plugin. Need to consider + # various corner cases. + # QTBUG-96937 + if(TARGET "${arg_PLUGIN_TARGET}") + get_target_property(plugin_lib_type ${arg_PLUGIN_TARGET} TYPE) + if(plugin_lib_type STREQUAL "STATIC_LIBRARY") + __qt_internal_add_static_plugin_init_object_library( + "${arg_PLUGIN_TARGET}" plugin_init_target) + list(APPEND output_targets ${plugin_init_target}) + + __qt_internal_propagate_object_library("${arg_PLUGIN_TARGET}" "${plugin_init_target}") + endif() + endif() + + if(NOT arg_NO_GENERATE_QMLDIR) + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.19.0") + # Defer the write to allow more qml files to be added later by calls to + # qt6_target_qml_sources(). We wrap the deferred call with EVAL CODE + # so that ${target} is evaluated now rather than the end of the scope. + # We also delay target finalization until after our deferred write + # because the qmldir file must be written before any finalizer + # might call qt_import_qml_plugins(). + cmake_language(EVAL CODE + "cmake_language(DEFER ID_VAR write_id CALL _qt_internal_write_deferred_qmldir_file ${target})" + ) + _qt_internal_delay_finalization_until_after(${write_id}) + else() + # Can't defer the write, have to do it now + _qt_internal_write_deferred_qmldir_file(${target}) + endif() + endif() + + if (arg_ENABLE_TYPE_COMPILER) + if (DEFINED arg_TYPE_COMPILER_NAMESPACE AND NOT $) + set(qmltc_namespace ${arg_TYPE_COMPILER_NAMESPACE}) + else() + string(REPLACE "." "::" qmltc_namespace "${arg_URI}") + endif() + _qt_internal_target_enable_qmltc(${target} + QML_FILES ${arg_QML_FILES} + IMPORT_PATHS ${arg_IMPORT_PATH} + NAMESPACE ${qmltc_namespace} + EXPORT_MACRO_NAME ${arg_QMLTC_EXPORT_DIRECTIVE} + EXPORT_FILE_NAME ${arg_QMLTC_EXPORT_FILE_NAME} + MODULE ${arg_URI} + ) + endif() + + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${output_targets} PARENT_SCOPE) + endif() + + + set(ensure_set_properties + QT_QML_MODULE_PLUGIN_TYPES_FILE + QT_QML_MODULE_QML_FILES + QT_QML_MODULE_RESOURCES # Original files as provided by the project (absolute) + QT_QML_MODULE_RESOURCE_PATHS # By qmlcachegen (resource paths) + QT_QMLCACHEGEN_DIRECT_CALLS + QT_QMLCACHEGEN_EXECUTABLE + QT_QMLCACHEGEN_ARGUMENTS + ) + foreach(prop IN LISTS ensure_set_properties) + get_target_property(val ${target} ${prop}) + if("${val}" MATCHES "-NOTFOUND$") + set_target_properties(${target} PROPERTIES ${prop} "") + endif() + endforeach() + + if(${QT_QML_GENERATE_QMLLS_INI}) + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.19.0") + # collect all build dirs obtained from all the qt_add_qml_module calls and + # write the .qmlls.ini file in a deferred call + + if(NOT "${arg_OUTPUT_DIRECTORY}" STREQUAL "") + set(output_folder "${arg_OUTPUT_DIRECTORY}") + else() + set(output_folder "${CMAKE_CURRENT_BINARY_DIR}") + endif() + string(REPLACE "." ";" uri_bits "${arg_URI}") + set(build_folder "${output_folder}") + foreach(bit IN LISTS uri_bits) + get_filename_component(build_folder "${build_folder}" DIRECTORY) + endforeach() + get_directory_property(_qmlls_ini_build_folders _qmlls_ini_build_folders) + list(APPEND _qmlls_ini_build_folders "${build_folder}") + set_directory_properties(PROPERTIES _qmlls_ini_build_folders "${_qmlls_ini_build_folders}") + set_property(DIRECTORY APPEND PROPERTY _qmlls_ini_import_path_targets "${target}") + + # if no call with id 'qmlls_ini_generation_id' was deferred for this directory, do it now + cmake_language(DEFER GET_CALL qmlls_ini_generation_id call) + if("${call}" STREQUAL "") + cmake_language(EVAL CODE + "cmake_language(DEFER ID qmlls_ini_generation_id CALL _qt_internal_write_deferred_qmlls_ini_file ${target})" + ) + endif() + else() + get_property(__qt_internal_generate_qmlls_ini_warning + GLOBAL + PROPERTY __qt_internal_generate_qmlls_ini_warning + ) + if (NOT "${__qt_internal_generate_qmlls_ini_warning}") + message(WARNING "QT_QML_GENERATE_QMLLS_INI is not supported on CMake versions < 3.19, disabling...") + set_property(GLOBAL PROPERTY __qt_internal_generate_qmlls_ini_warning ON) + endif() + endif() + endif() + + # write out extra qtconf files for executables to automatically set up import paths; + # but avoid needless warnings and work if there are no relevant dependencies specified + if((backing_target_type STREQUAL "EXECUTABLE") + AND all_dependency_targets) + if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.19.0") + # The general logic is that every target writes out a "partial" file, + # containing its needed imports. + # Once all partial files are written, + # we run a helper process which consolidates them. + # We need the counter to know when the last finalizer runs, + # as only then we'll know that all partial files have been + # written out, and we can start merging them. + get_directory_property(counter + DIRECTORY ${PROJECT_SOURCE_DIR} + QT_QMLDIR_DEFERRED_WRITEOUT_COUNTER + ) + if (NOT counter) + set(counter "0") + endif() + math(EXPR counter "${counter} + 1") + set_property( + DIRECTORY ${PROJECT_SOURCE_DIR} + PROPERTY QT_QMLDIR_DEFERRED_WRITEOUT_COUNTER + "${counter}" + ) + cmake_language(EVAL CODE " + cmake_language(DEFER DIRECTORY [[${PROJECT_SOURCE_DIR}]] + CALL _qt_internal_write_qmldir_part ${target}) + ") + else() + # Before CMake 3.19, we don't have DEFER, so we immediately write out the qt.conf + # file, overwriting its content if necessary. + # That would be fine, as we build up a list and just end up overwriting the file again + # Unfortunately, CMake < 3.19 doesn't allow us to set directory properties on + # binary dirs, either. + # So we'll end up having to set the properties on the source directory + get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if (is_multi_config) + message(FATAL + "Using TARGET based dependencies in qt_add_qml_module requires at least CMake 3.19 " + "when using multi-config generators") + else() + message(WARNING + "Using TARGET based dependencies in qt_add_qml_module with CMake < 3.19 " + "might result in missing import paths if they are not added manually.") + endif() + get_target_property(effective_outdir ${target} RUNTIME_OUTPUT_DIRECTORY) + if (NOT "${effective_outdir}") + set(effective_outdir "${CMAKE_CURRENT_BINARY_DIR}") + endif() + + set_property( + DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + APPEND + PROPERTY QT_QML_TARGETS_FOR_DEFERRED_QTCONF_WRITEOUT + ${target} + ) + _qt_internal_writebuilddir_qtconf_nondeferred("${CMAKE_CURRENT_SOURCE_DIR}" "${effective_outdir}") + endif() + endif() + + if("${CMAKE_VERSION}" VERSION_GREATER_EQUAL "3.19.0") + get_cmake_property(aotstats_setup_called _qt_internal_deferred_aotstats_setup) + if(NOT aotstats_setup_called) + set_property(GLOBAL PROPERTY _qt_internal_deferred_aotstats_setup TRUE) + cmake_language(EVAL CODE "cmake_language(DEFER DIRECTORY \"${CMAKE_BINARY_DIR}\" " + "CALL _qt_internal_deferred_aotstats_setup)") + endif() + else() + if(NOT TARGET all_aotstats) + add_custom_target( + all_aotstats + ${CMAKE_COMMAND} -E echo "aotstats is not supported on CMake versions < 3.19" + ) + endif() + endif() +endfunction() + +function(_qt_internal_deferred_aotstats_setup) + get_property(module_targets GLOBAL PROPERTY _qt_qml_aotstats_module_targets) + + set(onlybytecode_modules "") + set(empty_modules "") + set(module_aotstats_targets "") + set(module_aotstats_files "") + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + foreach(module_target IN LISTS module_targets) + get_target_property(qmlcachegen_args ${module_target} QT_QMLCACHEGEN_ARGUMENTS) + get_target_property(uri ${module_target} QT_QML_MODULE_URI) + get_target_property(aotstats_files ${module_target} QT_QML_MODULE_AOTSTATS_FILES) + get_target_property(rcc_qmlcache_path ${module_target} QT_QML_MODULE_RCC_QMLCACHE_PATH) + + if("--only-bytecode" IN_LIST qmlcachegen_args) + list(APPEND onlybytecode_modules "${uri}(${module_target})") + continue() + elseif(NOT aotstats_files) + list(APPEND empty_modules "${uri}(${module_target})") + continue() + endif() + + list(JOIN aotstats_files "\n" aotstats_files_lines) + set(module_aotstats_list_file "${rcc_qmlcache_path}/module_${module_target}.aotstatslist") + file(WRITE ${module_aotstats_list_file} "${aotstats_files_lines}") + + set(output "${rcc_qmlcache_path}/module_${module_target}.aotstats") + add_custom_command( + OUTPUT ${output} + DEPENDS ${aotstats_files} ${module_aotstats_list_file} + COMMAND + ${tool_wrapper} + $ + aggregate + ${module_aotstats_list_file} + ${output} + ) + + set(module_aotstats_target_name "module_${module_target}_aotstats_target") + add_custom_target(${module_aotstats_target_name} + DEPENDS ${output} + ) + _qt_internal_assign_to_internal_targets_folder(${module_aotstats_target_name}) + if(TARGET ${module_target}_qmltyperegistration) + add_dependencies(${module_aotstats_target_name} ${module_target}_qmltyperegistration) + else() + add_dependencies(${module_aotstats_target_name} ${module_target}) + endif() + + list(APPEND module_aotstats_targets ${module_aotstats_target_name}) + list(APPEND module_aotstats_files ${output}) + endforeach() + + + set(project_rcc_qmlcache "${PROJECT_BINARY_DIR}/.rcc/qmlcache") + + set(qmlaotstats_options "") + if(onlybytecode_modules) + set(onlybytecode_modules_file "${project_rcc_qmlcache}/aotstats_onlybytecode_modules.txt") + list(JOIN onlybytecode_modules "\n" onlybytecode_modules_lines) + file(WRITE ${onlybytecode_modules_file} "${onlybytecode_modules_lines}") + list(APPEND qmlaotstats_options "--only-bytecode-modules" "${onlybytecode_modules_file}") + endif() + if(empty_modules) + set(empty_modules_file "${project_rcc_qmlcache}/aotstats_empty_modules.txt") + list(JOIN empty_modules "\n" empty_modules_lines) + file(WRITE ${empty_modules_file} "${empty_modules_lines}") + list(APPEND qmlaotstats_options "--empty-modules" "${empty_modules_file}") + endif() + + list(JOIN module_aotstats_files "\n" module_aotstats_lines) + set(aotstats_list_file "${project_rcc_qmlcache}/all_aotstats.aotstatslist") + file(WRITE "${aotstats_list_file}" "${module_aotstats_lines}") + + set(all_aotstats_file "${project_rcc_qmlcache}/all_aotstats.aotstats") + set(formatted_stats_file "${project_rcc_qmlcache}/all_aotstats.txt") + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + add_custom_command( + OUTPUT + "${all_aotstats_file}" + "${formatted_stats_file}" + DEPENDS ${module_aotstats_targets} ${module_aotstats_files} + COMMAND + ${tool_wrapper} + $ + aggregate + "${aotstats_list_file}" + "${all_aotstats_file}" + COMMAND + ${tool_wrapper} + $ + format + "${all_aotstats_file}" + "${formatted_stats_file}" + "${qmlaotstats_options}" + COMMAND_EXPAND_LISTS + ) + + if(NOT TARGET all_aotstats) + add_custom_target(all_aotstats + DEPENDS "${formatted_stats_file}" + COMMAND "${CMAKE_COMMAND}" -E cat "${formatted_stats_file}" + ) + endif() +endfunction() + +function(_qt_internal_write_deferred_qmlls_ini_file target) + set(qmlls_ini_file "${CMAKE_CURRENT_SOURCE_DIR}/.qmlls.ini") + get_directory_property(_qmlls_ini_build_folders _qmlls_ini_build_folders) + list(REMOVE_DUPLICATES _qmlls_ini_build_folders) + get_directory_property(_qmlls_ini_import_path_targets _qmlls_ini_import_path_targets) + set(_import_paths "") + foreach(import_path_target IN LISTS _qmlls_ini_import_path_targets) + get_target_property(import_path ${import_path_target} QT_QML_IMPORT_PATH) + list(APPEND _import_paths "${import_path}") + endforeach() + + if(NOT CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows") + # replace cmake list separator ';' with unix path separator ':' + string(REPLACE ";" ":" concatenated_build_dirs "${_qmlls_ini_build_folders}") + list(JOIN _import_paths ":" concatenated_import_paths) + else() + # cmake list separator and windows path separator are both ';', so no replacement needed + set(concatenated_build_dirs "${_qmlls_ini_build_folders}") + set(concatenated_import_paths "${_import_paths}") + endif() + + _populate_qmlls_ini_file( + ${target} + "${qmlls_ini_file}" + "${concatenated_build_dirs}" + "${concatenated_import_paths}") +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_qml_module) + qt6_add_qml_module(${ARGV}) + cmake_parse_arguments(PARSE_ARGV 1 arg "" "OUTPUT_TARGETS" "") + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${${arg_OUTPUT_TARGETS}} PARENT_SCOPE) + endif() + endfunction() +endif() + +function(_populate_qmlls_ini_file target qmlls_ini_file concatenated_build_dirs import_paths) + get_target_property(qtpaths ${QT_CMAKE_EXPORT_NAMESPACE}::qtpaths LOCATION) + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + + add_custom_command( + OUTPUT + ${qmlls_ini_file} + COMMAND ${CMAKE_COMMAND} -E echo "[General]" > ${qmlls_ini_file} + COMMAND ${CMAKE_COMMAND} -E echo "buildDir=${concatenated_build_dirs}" >> ${qmlls_ini_file} + COMMAND ${CMAKE_COMMAND} -E echo "no-cmake-calls=false" >> ${qmlls_ini_file} + COMMAND ${CMAKE_COMMAND} -E echo_append "docDir=" >> ${qmlls_ini_file} + COMMAND + ${tool_wrapper} + ${qtpaths} + --query QT_INSTALL_DOCS >> ${qmlls_ini_file} + COMMAND ${CMAKE_COMMAND} -E echo "importPaths=${import_paths}" >> ${qmlls_ini_file} + COMMENT "Populating .qmlls.ini file" + VERBATIM + ) + add_custom_target(${target}_generate_qmlls_ini_file + DEPENDS ${qmlls_ini_file} + VERBATIM + ) + add_dependencies(${target} ${target}_generate_qmlls_ini_file) +endfunction() + +# Make the prefix conform to the following: +# - Starts with a "/" +# - Does not end with a "/" unless the prefix is exactly "/" +function(_qt_internal_canonicalize_resource_path path out_var) + if(NOT path) + set(path "/") + endif() + if(NOT path MATCHES "^/") + string(PREPEND path "/") + endif() + if(path MATCHES [[(.+)/$]]) + set(path "${CMAKE_MATCH_1}") + endif() + set(${out_var} "${path}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_get_escaped_uri uri out_var) + string(REGEX REPLACE "[^A-Za-z0-9]" "_" escaped_uri "${uri}") + set(${out_var} "${escaped_uri}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_compute_qml_plugin_class_name_from_uri uri out_var) + _qt_internal_get_escaped_uri("${uri}" escaped_uri) + set(${out_var} "${escaped_uri}Plugin" PARENT_SCOPE) +endfunction() + +macro(_qt_internal_genex_getproperty var target property) + set(${var} "$") + set(have_${var} "$") +endmacro() + +macro(_qt_internal_genex_getjoinedproperty var target property item_prefix glue) + _qt_internal_genex_getproperty(${var} ${target} ${property}) + set(${var} "$<${have_${var}}:${item_prefix}$>") +endmacro() + + +# Creates a genex that will call a c++ macro on each of the list values. +# Handles empty lists. +macro(_qt_internal_genex_get_list_joined_with_macro var input_list macro_name with_ending_semicolon) + set(${var} "${input_list}") + set(have_${var} "$") + + set(_macro_begin "${macro_name}(") + set(_macro_end ")") + if(with_ending_semicolon) + string(APPEND _macro_end ";") + endif() + set(_macro_glue "${_macro_end}\n${_macro_begin}") + + string(JOIN "" ${var} + "${_macro_begin}" + "$" + "${_macro_end}") + + set(${var} "$<${have_${var}}:${${var}}>") + + unset(_macro_begin) + unset(_macro_end) + unset(_macro_glue) +endmacro() + +# Reads a target property that contains a list of values and creates a genex that will +# call a c++ macro on each of the values. +# Handles empty properties. +macro(_qt_internal_genex_get_property_joined_with_macro var target property macro_name + with_ending_semicolon) + _qt_internal_genex_getproperty(${var} ${target} ${property}) + _qt_internal_genex_get_list_joined_with_macro("${var}" "${${var}}" "${macro_name}" + "${with_ending_semicolon}") +endmacro() + +macro(_qt_internal_genex_getoption var target property) + set(${var} "$>") +endmacro() + +# Gets the Qt import paths, prepends -I, appends the values to the given import_paths_var output +# variable. +function(_qt_internal_extend_qml_import_paths import_paths_var) + set(local_var ${${import_paths_var}}) + + _qt_internal_get_main_qt_qml_import_paths(qt_import_paths) + + # Append the paths instead of prepending them, to ensure Qt import paths are searched after + # any target or build dir specific import paths. + foreach(import_path IN LISTS qt_import_paths) + list(APPEND local_var -I "${import_path}") + endforeach() + + set(${import_paths_var} ${local_var} PARENT_SCOPE) +endfunction() + +function(_qt_internal_assign_to_qmllint_targets_folder target) + get_property(folder_name GLOBAL PROPERTY QT_QMLLINTER_TARGETS_FOLDER) + if("${folder_name}" STREQUAL "") + get_property(__qt_qt_targets_folder GLOBAL PROPERTY QT_TARGETS_FOLDER) + set(folder_name "${__qt_qt_targets_folder}/QmlLinter") + set_property(GLOBAL PROPERTY QT_QMLLINTER_TARGETS_FOLDER ${folder_name}) + endif() + set_property(TARGET ${target} PROPERTY FOLDER "${folder_name}") +endfunction() + +function(_qt_internal_target_enable_qmllint target) + set(lint_target ${target}_qmllint) + set(lint_target_json ${target}_qmllint_json) + set(lint_target_module ${target}_qmllint_module) + if(TARGET ${lint_target} OR TARGET ${target}_qmllint_json OR TARGET ${target}_qmllint_module) + return() + endif() + + _qt_internal_genex_getproperty(qmllint_files ${target} QT_QML_LINT_FILES) + _qt_internal_genex_getjoinedproperty(import_args ${target} + QT_QML_IMPORT_PATH "-I$" "$" + ) + _qt_internal_genex_getjoinedproperty(qrc_args ${target} + _qt_generated_qrc_files "--resource$" "$" + ) + + # Facilitate self-import so it can find the qmldir file. We also try to walk + # back up the directory structure to find a base path under which this QML + # module is located. Such a base path is likely to be used for other QML + # modules that we might need to find, so add it to the import path if we + # find a compatible directory structure. It doesn't make sense to do this + # for an executable though, since it can never be found as a QML module for + # a different QML module/target. + get_target_property(target_type ${target} TYPE) + get_target_property(is_android_executable ${target} _qt_is_android_executable) + if(target_type STREQUAL "EXECUTABLE" OR is_android_executable) + # The executable's own QML module's qmldir file will usually be under a + # subdirectory (matching the module's target path) below the target's + # build directory. + list(APPEND import_args -I "$") + elseif(target_type MATCHES "LIBRARY") + get_target_property(output_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + get_target_property(target_path ${target} QT_QML_MODULE_TARGET_PATH) + if(output_dir MATCHES "${target_path}$") + string(REGEX REPLACE "(.*)/${target_path}" "\\1" base_dir "${output_dir}") + list(APPEND import_args -I "${base_dir}") + else() + message(WARNING + "The ${target} target is a QML module with target path ${target_path}. " + "It uses an OUTPUT_DIRECTORY of ${output_dir}, which should end in the " + "same target path, but doesn't. Tooling such as qmllint may not work " + "correctly." + ) + endif() + endif() + + if(NOT "${QT_QML_OUTPUT_DIRECTORY}" STREQUAL "") + list(APPEND import_args -I "${QT_QML_OUTPUT_DIRECTORY}") + endif() + + _qt_internal_extend_qml_import_paths(import_args) + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + + set(qmllint_args + --bare + ${import_args} + ${qrc_args} + ${qmllint_files} + ) + + get_target_property(target_binary_dir ${target} BINARY_DIR) + set(qmllint_dir ${target_binary_dir}/.rcc/qmllint) + set(qmllint_rsp_path ${qmllint_dir}/${target}.rsp) + + file(GENERATE + OUTPUT "${qmllint_rsp_path}" + CONTENT "$\n" + ) + + set(cmd + "${tool_wrapper}" + $ + @${qmllint_rsp_path} + ) + + set(cmd_dummy ${CMAKE_COMMAND} -E echo "Nothing to do for target ${lint_target}.") + + # We need this target to depend on all qml type registrations. This is the + # only way we can be sure that all *.qmltypes files for any QML modules we + # depend on will have been generated. + add_custom_target(${lint_target} + COMMAND "$" + COMMAND_EXPAND_LISTS + DEPENDS + ${QT_CMAKE_EXPORT_NAMESPACE}::qmllint + ${qmllint_files} + ${qmllint_rsp_path} + $ + WORKING_DIRECTORY "$" + ) + _qt_internal_assign_to_qmllint_targets_folder(${lint_target}) + + list(APPEND qmllint_args "--json" "${CMAKE_BINARY_DIR}/${lint_target}.json") + + set(qmllint_rsp_path ${qmllint_dir}/${target}_json.rsp) + + file(GENERATE + OUTPUT "${qmllint_rsp_path}" + CONTENT "$\n" + ) + + set(cmd + "${tool_wrapper}" + $ + @${qmllint_rsp_path} + ) + + add_custom_target(${lint_target_json} + COMMAND "$<${have_qmllint_files}:${cmd}>" + COMMAND_EXPAND_LISTS + DEPENDS + ${QT_CMAKE_EXPORT_NAMESPACE}::qmllint + ${qmllint_files} + ${qmllint_rsp_path} + $ + WORKING_DIRECTORY "$" + ) + _qt_internal_assign_to_qmllint_targets_folder(${lint_target_json}) + + set_target_properties(${lint_target_json} PROPERTIES EXCLUDE_FROM_ALL TRUE) + + get_target_property(module_uri ${target} QT_QML_MODULE_URI) + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + + set(qmllint_args + ${import_args} + ${qrc_args} + --module + ${module_uri} + ) + + set(qmllint_rsp_path ${qmllint_dir}/${target}_module.rsp) + + file(GENERATE + OUTPUT "${qmllint_rsp_path}" + CONTENT "$\n" + ) + + set(cmd + "${tool_wrapper}" + $ + @${qmllint_rsp_path} + ) + + add_custom_target(${lint_target_module} + COMMAND ${cmd} + COMMAND_EXPAND_LISTS + DEPENDS + ${QT_CMAKE_EXPORT_NAMESPACE}::qmllint + ${qmllint_files} + ${qmllint_rsp_path} + $ + WORKING_DIRECTORY "$" + ) + _qt_internal_assign_to_qmllint_targets_folder(${lint_target_module}) + + # Make the global linting target depend on the one we add here. + # Note that the caller is free to change the value of QT_QMLLINT_ALL_TARGET + # for different QML modules if they wish, which means they can implement + # their own grouping of the ${target}_qmllint targets. + _qt_internal_add_all_qmllint_target(QT_QMLLINT_ALL_TARGET + all_qmllint ${lint_target}) + _qt_internal_add_all_qmllint_target(QT_QMLLINT_JSON_ALL_TARGET + all_qmllint_json ${lint_target_json}) + _qt_internal_add_all_qmllint_target(QT_QMLLINT_MODULE_ALL_TARGET + all_qmllint_module ${lint_target_module}) +endfunction() + +# This is a modified version of __qt_propagate_generated_resource from qtbase. +# +# It uses a common __qt_internal_propagate_object_library function to link and propagate the object +# library to the end-point executable. +# +# The reason for propagating the qmlcache target as a 'fake resource' from the build system +# perspective is to ensure proper handling of the object files in generated qmake .prl files. +function(_qt_internal_propagate_qmlcache_object_lib + target + generated_source_code + link_condition + output_generated_target) + set(resource_target "${target}_qmlcache") + qt6_add_library("${resource_target}" OBJECT "${generated_source_code}") + + # Needed to trigger the handling of the object library for .prl generation. + set_property(TARGET ${resource_target} APPEND PROPERTY _qt_resource_name ${resource_target}) + + # Export info that this is a qmlcache target, in case if we ever need to detect such targets, + # similar how we need it for plugin initializers. + set_property(TARGET ${resource_target} PROPERTY _is_qt_qmlcache_target TRUE) + set_property(TARGET ${resource_target} APPEND PROPERTY + EXPORT_PROPERTIES _is_qt_qmlcache_target + ) + + # Save the path to the generated source file, relative to the the current build dir. + # The path will be used in static library prl file generation to ensure qmake links + # against the installed resource object files. + # Example saved path: + # .rcc/qrc_qprintdialog.cpp + file(RELATIVE_PATH generated_cpp_file_relative_path + "${CMAKE_CURRENT_BINARY_DIR}" + "${generated_source_code}") + set_property(TARGET ${resource_target} APPEND PROPERTY + _qt_resource_generated_cpp_relative_path "${generated_cpp_file_relative_path}") + + # Qml specific additions. + target_link_libraries(${resource_target} PRIVATE + ${QT_CMAKE_EXPORT_NAMESPACE}::QmlPrivate + ${QT_CMAKE_EXPORT_NAMESPACE}::Core + ) + + __qt_internal_propagate_object_library(${target} ${resource_target} + EXTRA_CONDITIONS "${link_condition}" + ) + + set(${output_generated_target} "${resource_target}" PARENT_SCOPE) +endfunction() + +# Create an 'all_qmllint' target. The target's name can be user-controlled by ${target_var} with the +# default name ${default_target_name}. The parameter ${lint_target} holds the name of the single +# foo_qmllint target that should be triggered by the all_qmllint target. +function(_qt_internal_add_all_qmllint_target target_var default_target_name lint_target) + set(target_name "${${target_var}}") + if("${target_name}" STREQUAL "") + set(target_name ${default_target_name}) + endif() + _qt_internal_add_phony_target(${target_name} + WARNING_VARIABLE QT_NO_QMLLINT_CREATION_WARNING + TARGET_CREATED_HOOK _qt_internal_assign_to_qmllint_targets_folder + ) + _qt_internal_add_phony_target_dependencies(${target_name} ${lint_target}) +endfunction() + +# Hack for the Visual Studio generator. Create the all_qmllint target named ${target} and work +# around the lack of a working add_dependencies by calling 'cmake --build' for every dependency. +function(_qt_internal_add_all_qmllint_target_deferred target) + get_property(target_dependencies GLOBAL PROPERTY _qt_target_${target}_dependencies) + set(target_commands "") + foreach(dependency IN LISTS target_dependencies) + list(APPEND target_commands + COMMAND "${CMAKE_COMMAND}" --build "${CMAKE_BINARY_DIR}" -t ${dependency} + ) + endforeach() + add_custom_target(${target} ${target_commands}) + _qt_internal_assign_to_qmllint_targets_folder(${target}) +endfunction() + +function(_qt_internal_target_enable_qmlcachegen target qmlcachegen) + set_target_properties(${target} PROPERTIES _qt_cachegen_set_up TRUE) + + get_target_property(target_binary_dir ${target} BINARY_DIR) + set(qmlcache_dir ${target_binary_dir}/.rcc/qmlcache) + set(qmlcache_resource_name qmlcache_${target}) + + # Save the resource name in a property so we can reference it later in a qml plugin + # constructor, to avoid discarding the resource if it's in a static library. + __qt_internal_sanitize_resource_name( + sanitized_qmlcache_resource_name "${qmlcache_resource_name}") + set_target_properties(${target} PROPERTIES _qt_cachegen_sanitized_resource_name + "${sanitized_qmlcache_resource_name}") + + # INTEGRITY_SYMBOL_UNIQUENESS + # The cache loader file name has to be unique, because the Integrity compiler uses the file name + # for the generation of the translation unit static constructor symbol name. + # e.g. __sti___19_qmlcache_loader_cpp_11acedbd + # For some reason the symbol is created with global visibility. + # + # When an application links against the Basic and Fusion static qml plugins, the linker + # fails with duplicate symbol errors because both of those plugins will contain the same symbol. + # + # With gcc on regular Linux, the symbol names are also the same, but it's not a problem because + # they have local (hidden) visbility. + # + # Make the file name unique by prepending the target name. + set(qmlcache_loader_cpp ${qmlcache_dir}/${target}_qmlcache_loader.cpp) + + set(qmlcache_loader_list ${qmlcache_dir}/${target}_qml_loader_file_list.rsp) + set(qmlcache_resource_paths "$") + + _qt_internal_genex_getjoinedproperty(qrc_resource_args ${target} + _qt_generated_qrc_files "--resource$" "$" + ) + + if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config" AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") + set(qmlcachegen "$") + endif() + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + set(cmd + "${tool_wrapper}" + ${qmlcachegen} + --resource-name "${qmlcache_resource_name}" + -o "${qmlcache_loader_cpp}" + "@${qmlcache_loader_list}" + ) + + file(GENERATE + OUTPUT ${qmlcache_loader_list} + CONTENT "$\n$\n" + ) + + add_custom_command( + OUTPUT ${qmlcache_loader_cpp} + COMMAND "${cmd}" + COMMAND_EXPAND_LISTS + DEPENDS + ${qmlcachegen} + ${qmlcache_loader_list} + $ + VERBATIM + ) + + # The current scope sees the file as generated automatically, but the + # target scope may not if it is different. Force it where we can. + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set_source_files_properties( + ${qmlcache_loader_cpp} + TARGET_DIRECTORY ${target} + PROPERTIES GENERATED TRUE + SKIP_AUTOGEN TRUE + ) + endif() + get_target_property(target_source_dir ${target} SOURCE_DIR) + if(NOT target_source_dir STREQUAL CMAKE_CURRENT_SOURCE_DIR) + add_custom_target(${target}_qmlcachegen DEPENDS ${qmlcache_loader_cpp}) + add_dependencies(${target} ${target}_qmlcachegen) + endif() + + # TODO: Probably need to reject ${target} being an object library as unsupported + target_sources(${target} PRIVATE "${qmlcache_loader_cpp}") + target_link_libraries(${target} PRIVATE + ${QT_CMAKE_EXPORT_NAMESPACE}::QmlPrivate + ${QT_CMAKE_EXPORT_NAMESPACE}::Core + ) +endfunction() + +# We cannot defer writing out the qmldir file to generation time because the +# qmlimportscanner runs at configure time as part of target finalizers. +# Therefore, the best we can do is defer writing the qmldir file if we are +# using a recent enough CMake version, otherwise we write it out progressively +# on each call that adds qml sources. The immediate progressive writes will +# trigger some unnecessary rebuilds after reconfiguring due to the qmldir +# file's timestamp being updated even though its contents might not change, +# but that's the cost of not having deferred write capability. +function(_qt_internal_target_generate_qmldir target) + + macro(_qt_internal_qmldir_item prefix property) + get_target_property(_value ${target} ${property}) + if(_value) + string(APPEND content "${prefix} ${_value}\n") + endif() + endmacro() + + macro(_qt_internal_qmldir_item_list prefix property) + get_target_property(_values ${target} ${property}) + if(_values) + foreach(_value IN LISTS _values) + string(APPEND content "${prefix} ${_value}\n") + endforeach() + endif() + endmacro() + + get_target_property(uri ${target} QT_QML_MODULE_URI) + if(NOT uri) + message(FATAL_ERROR "Target ${target} has no URI set, cannot create qmldir") + endif() + set(content "module ${uri}\n") + + _qt_internal_qmldir_item(linktarget QT_QML_MODULE_INSTALLED_PLUGIN_TARGET) + + get_target_property(plugin_target ${target} QT_QML_MODULE_PLUGIN_TARGET) + if(plugin_target) + get_target_property(no_plugin_optional ${target} QT_QML_MODULE_NO_PLUGIN_OPTIONAL) + if(NOT no_plugin_optional MATCHES "NOTFOUND" AND NOT no_plugin_optional) + string(APPEND content "optional ") + endif() + + get_target_property(target_path ${target} QT_QML_MODULE_TARGET_PATH) + _qt_internal_get_qml_plugin_output_name(plugin_output_name ${plugin_target} + TARGET_PATH "${target_path}" + URI "${uri}" + ) + string(APPEND content "plugin ${plugin_output_name}\n") + + _qt_internal_qmldir_item(classname QT_QML_MODULE_CLASS_NAME) + endif() + + get_target_property(designer_supported ${target} QT_QML_MODULE_DESIGNER_SUPPORTED) + if(designer_supported) + string(APPEND content "designersupported\n") + endif() + + get_target_property(static_module ${target} QT_QML_MODULE_IS_STATIC) + if (static_module) + string(APPEND content "static\n") + endif() + + get_target_property(system_module ${target} QT_QML_MODULE_IS_SYSTEM) + if (system_module) + string(APPEND content "system\n") + endif() + + _qt_internal_qmldir_item(typeinfo QT_QML_MODULE_TYPEINFO) + + _qt_internal_qmldir_item_list(import QT_QML_MODULE_IMPORTS) + _qt_internal_qmldir_item_list("optional import" QT_QML_MODULE_OPTIONAL_IMPORTS) + _qt_internal_qmldir_item_list("default import" QT_QML_MODULE_DEFAULT_IMPORTS) + + _qt_internal_qmldir_item_list(depends QT_QML_MODULE_DEPENDENCIES) + + get_target_property(prefix ${target} QT_QML_MODULE_RESOURCE_PREFIX) + if(prefix) + # Ensure we use a path that ends with a "/", but handle the special case + # of "/" without anything after it + if(NOT prefix STREQUAL "/" AND NOT prefix MATCHES "/$") + string(APPEND prefix "/") + endif() + string(APPEND content "prefer :${prefix}\n") + endif() + + # TODO: What about multi-config generators? Would we need per-config qmldir + # files (because we will have per-config plugin targets)? + + # Record the contents but defer the actual write. We will write the file + # later, either at the end of qt6_add_qml_module() or the end of the + # directory scope (depending on the CMake version being used). + set_property(TARGET ${target} PROPERTY _qt_internal_qmldir_content "${content}") + + # NOTE: qt6_target_qml_sources() may append further content later. +endfunction() + +function(_qt_internal_write_deferred_qmldir_file target) + get_target_property(__qt_qmldir_content ${target} _qt_internal_qmldir_content) + get_target_property(out_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + set(qmldir_file "${out_dir}/qmldir") + configure_file(${__qt_qml_macros_module_base_dir}/Qt6qmldirTemplate.cmake.in ${qmldir_file} @ONLY) +endfunction() + +# With a macOS framework Qt build, moc needs to be passed -F +# arguments to resolve framework style includes like #include +# Extract the location of the Qt frameworks by querying the imported location of +# the target (where target is a Qt library). Do not care about non-Qt targets. +function(_qt_internal_qml_get_qt_framework_path target out_var) + set(value "") + # NOTE: only exercise IMPORTED_LOCATION of various flavors. this seems to be + # good enough in other places (e.g. when locating qmlimportscanner) + get_target_property(target_path ${target} IMPORTED_LOCATION) + if(NOT target_path) + set(configs "RELWITHDEBINFO;RELEASE;MINSIZEREL;DEBUG") + foreach(config ${configs}) + get_target_property(target_path ${target} IMPORTED_LOCATION_${config}) + # NOTE: to be fair, any location is good enough. the macro + # definitions we need must not vary between configurations + if(target_path) + break() + endif() + endforeach() + endif() + string(REGEX REPLACE "(.*)/Qt[^/]+\\.framework.*" "\\1" target_fw_path "${target_path}") + if(target_fw_path) + set(value "${target_fw_path}") + endif() + set(${out_var} "${value}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_qml_get_qt_framework_path_moc_option target out_var) + _qt_internal_qml_get_qt_framework_path(${target} target_fw_path) + if(target_fw_path) + set(${out_var} "-F${target_fw_path}" PARENT_SCOPE) + else() + set(${out_var} "" PARENT_SCOPE) + endif() +endfunction() + +# creates a QRC mapping between QML files in build directory and QML files in +# source directory +function(_qt_internal_qml_map_build_files target qml_module_prefix qrc_file_out_var) + get_target_property(output_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + if(NOT output_dir) + # TODO: we might want to support non-qml modules here (think QML + # language server) but it is unclear whether the below code would + # succeed, so just abort here until we have a proper test case + message(WARNING "Target ${target} is not a QML module. Cannot detect its output directory") + return() + endif() + + set(qrcContents "") + string(APPEND qrcContents " ${output_dir}\n") + + # dump the contents into the .qrc file + set(template_file "${__qt_qml_macros_module_base_dir}/Qt6QmlModuleDirMappingTemplate.qrc.in") + set(generated_qrc_file "${output_dir}/${target}_qml_module_dir_map.qrc") + set(qt_qml_module_dir_mapping_contents "${qrcContents}") + configure_file(${template_file} ${generated_qrc_file}) + + set(${qrc_file_out_var} ${generated_qrc_file} PARENT_SCOPE) +endfunction() + +# Creates a qrc file that maps QML file path to generated C++ header file name +function(_qt_internal_qml_add_qmltc_file_mapping_resource qrc_file target qml_files) + get_target_property(output_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + set(qrcContents "") + + # go over all QML_FILES, mapping QML files to generated C++ sources + foreach(qml_file IN LISTS qml_files) + get_filename_component(file_absolute ${qml_file} ABSOLUTE) + get_filename_component(file_basename ${file_absolute} NAME_WLE) # extension is always .qml + string(REGEX REPLACE "[$#?]+" "_" compiled_file ${file_basename}) + + # NB: use . pattern. if + # lowercase(file_name) is already taken (e.g. project has main.qml and + # main.h/main.cpp), the compilation might fail. in this case, expect + # user to specify QT_QMLTC_FILE_BASENAME + string(TOLOWER ${compiled_file} file_name) + + get_source_file_property(specified_file_name ${qml_file} QT_QMLTC_FILE_BASENAME) + if (specified_file_name) + get_filename_component(file_name ${specified_file_name} NAME_WLE) + endif() + + # .h is enough as corresponding .cpp is not interesting (and + # we can get it easily by replacing the extension) + string(APPEND qrcContents " ${file_absolute}\n") + endforeach() + + # dump the contents into the .qrc file + set(template_file "${__qt_qml_macros_module_base_dir}/Qt6QmltcFileMappingTemplate.qrc.in") + set(generated_qrc_file "${output_dir}/.qmltc/${target}/${target}_qmltc_file_map.qrc") + set(qt_qml_qmltc_file_mapping_contents "${qrcContents}") + configure_file(${template_file} ${generated_qrc_file}) + + set(${qrc_file} ${generated_qrc_file} PARENT_SCOPE) +endfunction() + +# Compile Qml files (.qml) to C++ source files with QML type compiler (qmltc). +function(_qt_internal_target_enable_qmltc target) + set(args_option "") + set(args_single NAMESPACE EXPORT_MACRO_NAME EXPORT_FILE_NAME MODULE) + set(args_multi QML_FILES IMPORT_PATHS) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${args_option}" "${args_single}" "${args_multi}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown/unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if (NOT arg_QML_FILES) + message(FATAL_ERROR "FILES option not given or contains empty list for target ${target}") + endif() + + if(NOT TARGET "${target}") + message(FATAL_ERROR "\"${target}\" is not a known target") + endif() + + get_target_property(target_source_dir ${target} SOURCE_DIR) + get_target_property(target_binary_dir ${target} BINARY_DIR) + + set(generated_sources_other_scope) + + set(compiled_files) # compiled files list to be used to generate MOC C++ + set(qmltc_executable "$") + if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config" AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") + set(qmltc_executable "$") + endif() + + set(common_args "") + if(arg_NAMESPACE) + list(APPEND common_args --namespace "${arg_NAMESPACE}") + endif() + if(arg_MODULE) + list(APPEND common_args --module "${arg_MODULE}") + endif() + if(arg_EXPORT_MACRO_NAME) + list(APPEND common_args --export "${arg_EXPORT_MACRO_NAME}") + if(arg_EXPORT_FILE_NAME) + list(APPEND common_args --exportInclude "${arg_EXPORT_FILE_NAME}") + endif() + endif() + + get_target_property(output_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + set(qmldir_file ${output_dir}/qmldir) + # TODO: we still need to specify the qmldir here for _explicit_ imports of + # own module. in theory this could be pushed to the user side + list(APPEND common_args "-i" ${qmldir_file}) + + foreach(import_path IN LISTS arg_IMPORT_PATHS) + list(APPEND common_args -I "${import_path}") + endforeach() + + _qt_internal_extend_qml_import_paths(common_args) + + # we explicitly depend on qmldir (due to `-i ${qmldir_file}`) but also + # implicitly on the generated qmltypes file, which is a part of qmldir + set(qml_module_files) + list(APPEND qml_module_files ${qmldir_file}) + get_target_property(qmltypes_file ${target} QT_QML_MODULE_TYPEINFO) + if(qmltypes_file) + list(APPEND qml_module_files ${output_dir}/${qmltypes_file}) + endif() + + get_target_property(potential_qml_modules ${target} LINK_LIBRARIES) + foreach(lib ${potential_qml_modules}) + if(NOT TARGET ${lib}) + continue() + endif() + + # if we have a versionless Qt lib, find the public one with a version + if(lib MATCHES "^Qt::(.*)") + set(lib "${CMAKE_MATCH_1}") + if(lib MATCHES "^(.*)Private") # remove "Private" + set(lib "${CMAKE_MATCH_1}") + endif() + set(lib ${QT_CMAKE_EXPORT_NAMESPACE}::${lib}) + if(NOT TARGET ${lib}) + continue() + endif() + endif() + + # when we have a suitable lib, ignore INTERFACE_LIBRARY and IMPORTED + get_target_property(lib_type ${lib} TYPE) + get_target_property(lib_is_imported ${lib} IMPORTED) + if(lib_type STREQUAL "INTERFACE_LIBRARY" OR lib_is_imported) + continue() + endif() + + # get any QT_QML_MODULE_ property, this way we can tell whether we deal + # with QML module target or not. use output dir as it's used later + get_target_property(external_output_dir ${lib} QT_QML_MODULE_OUTPUT_DIRECTORY) + if(NOT external_output_dir) # not a QML module, so not interesting + continue() + endif() + + get_target_property(external_qmltypes_file ${lib} QT_QML_MODULE_TYPEINFO) + if(external_qmltypes) + # add linked module's qmltypes file to a list of target + # dependencies. unlike qmllint or other tooling, qmltc only cares + # about explicitly linked libraries. things like plugins are not + # supported by design and would result in C++ compilation errors + list(APPEND qml_module_files ${external_output_dir}/${external_qmltypes_file}) + endif() + endforeach() + + # ignore non-QML and to-be-skipped QML files + set(filtered_qml_files "") + foreach(qml_file_src IN LISTS arg_QML_FILES) + if(NOT qml_file_src MATCHES "\\.(qml)$") + continue() + endif() + get_source_file_property(skip_qmltc ${qml_file_src} QT_QML_SKIP_TYPE_COMPILER) + if(skip_qmltc) + continue() + endif() + list(APPEND filtered_qml_files ${qml_file_src}) + endforeach() + + # qmltc needs qrc files to supply to the QQmlJSResourceFileMapper + _qt_internal_genex_getjoinedproperty(qrc_args ${target} + _qt_generated_qrc_files "--resource$" "$" + ) + # qmltc also needs meta data qrc files when importing types from own module + _qt_internal_genex_getjoinedproperty(metadata_qrc_args ${target} + _qt_qml_meta_qrc_files "--meta-resource$" "$" + ) + list(APPEND qrc_args ${metadata_qrc_args}) + + # NB: pass qml files variable as string to preserve its list nature + # (otherwise we lose all but first element of the list inside a function) + _qt_internal_qml_add_qmltc_file_mapping_resource( + qmltc_file_map_qrc ${target} "${filtered_qml_files}") + # append --resource to qmltc's command line + list(APPEND qrc_args --resource "${qmltc_file_map_qrc}") + + list(APPEND common_args ${qrc_args}) + + foreach(qml_file_src IN LISTS filtered_qml_files) + get_filename_component(file_absolute ${qml_file_src} ABSOLUTE) + + get_filename_component(file_basename ${file_absolute} NAME_WLE) # extension is always .qml + string(REGEX REPLACE "[$#?]+" "_" compiled_file ${file_basename}) + string(TOLOWER ${compiled_file} file_name) + + # NB: use . pattern. if + # lowercase(file_name) is already taken (e.g. project has main.qml and + # main.h/main.cpp), the compilation might fail. in this case, expect + # user to specify QT_QMLTC_FILE_BASENAME + get_source_file_property(specified_file_name ${qml_file_src} QT_QMLTC_FILE_BASENAME) + if (specified_file_name) + get_filename_component(file_name ${specified_file_name} NAME_WLE) + endif() + + # Note: add '${target}' to path to avoid potential conflicts where 2+ + # distinct targets use the same ${target_binary_dir}/.qmltc/ output dir + set(compiled_header "${target_binary_dir}/.qmltc/${target}/${file_name}.h") + set(compiled_cpp "${target_binary_dir}/.qmltc/${target}/${file_name}.cpp") + get_filename_component(out_dir ${compiled_header} DIRECTORY) + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + add_custom_command( + OUTPUT ${compiled_header} ${compiled_cpp} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out_dir} + COMMAND + ${tool_wrapper} + ${qmltc_executable} + --bare + --header "${compiled_header}" + --impl "${compiled_cpp}" + ${common_args} + ${file_absolute} + COMMAND_EXPAND_LISTS + DEPENDS + ${qmltc_executable} + "${file_absolute}" + ${qml_module_files} + $ + $ + ${qmltc_file_map_qrc} + COMMENT "Compiling ${qml_file_src} with qmltc" + VERBATIM + ) + + set_source_files_properties(${compiled_header} ${compiled_cpp} + PROPERTIES SKIP_AUTOGEN ON + SKIP_UNITY_BUILD_INCLUSION ON) + target_sources(${target} PRIVATE ${compiled_header} ${compiled_cpp}) + target_include_directories(${target} PUBLIC ${out_dir}) + # The current scope automatically sees the file as generated, but the + # target scope may not if it is different. Force it where we can. + # We will also have to add the generated file to a target in this + # scope at the end to ensure correct dependencies. + if(NOT target_source_dir STREQUAL CMAKE_CURRENT_SOURCE_DIR) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + list(APPEND generated_sources_other_scope ${compiled_header} ${compiled_cpp}) + endif() + endif() + + list(APPEND compiled_files ${compiled_header}) + endforeach() + + set(extra_moc_options "") + if(APPLE AND QT_FEATURE_framework) + # this is a special case, where we need -F options passed to manual moc. + # since we're in qmltc code, we only ever need to check QtCore and QtQml + # for framework path + list(APPEND link_libs ${QT_CMAKE_EXPORT_NAMESPACE}::Core ${QT_CMAKE_EXPORT_NAMESPACE}::Qml) + foreach(lib ${link_libs}) + _qt_internal_qml_get_qt_framework_path_moc_option(${lib} moc_option) + if(moc_option) + list(APPEND extra_moc_options ${moc_option}) + endif() + endforeach() + endif() + + # run MOC manually for the generated files + qt6_wrap_cpp(compiled_moc_files ${compiled_files} TARGET ${target} OPTIONS ${extra_moc_options}) + set_source_files_properties(${compiled_moc_files} PROPERTIES SKIP_AUTOGEN ON + SKIP_UNITY_BUILD_INCLUSION ON) + target_sources(${target} PRIVATE ${compiled_moc_files}) + if(NOT target_source_dir STREQUAL CMAKE_CURRENT_SOURCE_DIR) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set_source_files_properties(${generated_sources_other_scope} ${compiled_moc_files} + TARGET_DIRECTORY ${target} + PROPERTIES + SKIP_AUTOGEN TRUE + GENERATED TRUE + ) + endif() + + if(NOT TARGET ${target}_tooling) + message(FATAL_ERROR + "${target}_tooling is not found, although it should be in this function.") + endif() + # adding sources to ${target}_tooling would ensure that these sources + # become a dependency of ${target} in this weird case that we have. + # add_dependencies() for ${target} and ${target}_tooling must have been + # added as part of qt_add_qml_module() command run. + target_sources(${target}_tooling PRIVATE + ${generated_sources_other_scope} ${compiled_moc_files} + ) + endif() + +endfunction() + +function(qt6_target_compile_qml_to_cpp target) + message(WARNING + "qt6_target_compile_qml_to_cpp() can no longer be used standalone and is planned to be " + "removed in a future Qt release. To enable qmltc compilation, use:\n" + "qt6_add_qml_module(${target} ... ENABLE_TYPE_COMPILER)" + ) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_target_compile_qml_to_cpp) + qt6_target_compile_qml_to_cpp(${ARGV}) + endfunction() +endif() + +# Get extern declaration for types registration function. +function(_qt_internal_qml_get_types_extern_declaration register_types_function_name out_var) + set(with_ending_semicolon FALSE) + _qt_internal_genex_get_list_joined_with_macro( + content + "${register_types_function_name}" + "QT_DECLARE_EXTERN_SYMBOL_VOID" + ${with_ending_semicolon} + ) + + string(PREPEND content "\n") + set(${out_var} "${content}" PARENT_SCOPE) +endfunction() + +# Get code block that should reference the types registration function in the plugin constructor. +# Ensures the symbol is not discarded when linking. +function(_qt_internal_qml_get_types_keep_reference register_types_function_name out_var) + set(with_ending_semicolon FALSE) + _qt_internal_genex_get_list_joined_with_macro( + content + "${register_types_function_name}" + "QT_KEEP_SYMBOL" + ${with_ending_semicolon} + ) + + string(PREPEND content "\n") + set(${out_var} "${content}" PARENT_SCOPE) +endfunction() + +# Get extern declaration for cachegen resource. +function(_qt_internal_qml_get_cachegen_extern_resource_declaration target out_var) + set(with_ending_semicolon FALSE) + _qt_internal_genex_get_property_joined_with_macro( + content + "${target}" + "_qt_cachegen_sanitized_resource_name" + "QT_DECLARE_EXTERN_RESOURCE" + ${with_ending_semicolon} + ) + + string(PREPEND content "\n") + set(${out_var} "${content}" PARENT_SCOPE) +endfunction() + +# Get code block that should reference the cachegen resource in the plugin constructor. +# Ensures the resource is not discarded when linking. +function(_qt_internal_qml_get_cachegen_resource_keep_reference target out_var) + set(with_ending_semicolon FALSE) + _qt_internal_genex_get_property_joined_with_macro( + content + "${target}" + "_qt_cachegen_sanitized_resource_name" + "QT_KEEP_RESOURCE" + ${with_ending_semicolon} + ) + + string(PREPEND content "\n") + set(${out_var} "${content}" PARENT_SCOPE) +endfunction() + +# Get extern declaration for a regular resource. +function(_qt_internal_qml_get_resource_extern_declarations target out_var) + set(with_ending_semicolon FALSE) + _qt_internal_genex_get_property_joined_with_macro( + content + "${target}" + "_qt_qml_module_sanitized_resource_names" + "QT_DECLARE_EXTERN_RESOURCE" + ${with_ending_semicolon} + ) + + string(PREPEND content "\n") + set(${out_var} "${content}" PARENT_SCOPE) +endfunction() + +# Get code block that should reference regular resources in the plugin constructor. +# Ensures the resources are not discarded when linking. +function(_qt_internal_qml_get_resource_keep_references target out_var) + set(with_ending_semicolon FALSE) + _qt_internal_genex_get_property_joined_with_macro( + content + "${target}" + "_qt_qml_module_sanitized_resource_names" + "QT_KEEP_RESOURCE" + ${with_ending_semicolon} + ) + + string(PREPEND content "\n") + set(${out_var} "${content}" PARENT_SCOPE) +endfunction() + +# Get 3 different code blocks that should be inserted into various locations of the generated +# qml plugin cpp file. The code blocks ensure that if a target links to a plugin backed by a static +# library and initializes the plugin using Q_IMPORT_PLUGIN, none of the resources or type +# registration functions in the backing library are discarded by the linker. +function(_qt_internal_qml_get_symbols_to_keep + target + backing_target_type + register_types_function_name + out_var_intro + out_var_intro_namespaced + out_var_constructor) + set(intro_content "") + set(intro_namespaced_content "") + + # External symbol declarations. + _qt_internal_qml_get_types_extern_declaration("${register_types_function_name}" output) + string(APPEND intro_namespaced_content "${output}") + + if(backing_target_type STREQUAL "STATIC_LIBRARY") + _qt_internal_qml_get_cachegen_extern_resource_declaration(${target} output) + string(APPEND intro_content "${output}") + + _qt_internal_qml_get_resource_extern_declarations(${target} output) + string(APPEND intro_content "${output}") + endif() + + + # Reference the external symbols in the plugin constructor to prevent the linker from + # discarding the symbols. + # The types symbol is an exported symbol, so we always reference it. + set(constructor_content "") + + _qt_internal_qml_get_types_keep_reference("${register_types_function_name}" output) + string(APPEND constructor_content "${output}") + + # Only reference the resources if the backing library is static. + # If the backing library is shared, the symbols will not be found at link time because they + # are not exported symbols. + if(backing_target_type STREQUAL "STATIC_LIBRARY") + _qt_internal_qml_get_cachegen_resource_keep_reference(${target} output) + string(APPEND constructor_content "${output}") + + _qt_internal_qml_get_resource_keep_references(${target} output) + string(APPEND constructor_content "${output}") + endif() + + set(${out_var_intro} "${intro_content}" PARENT_SCOPE) + set(${out_var_intro_namespaced} "${intro_namespaced_content}" PARENT_SCOPE) + set(${out_var_constructor} "${constructor_content}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_set_qml_target_multi_config_output_directory target output_directory) + # In multi-config builds we need to make sure that at least one configuration has the dynamic + # plugin that is located next to qmldir file, otherwise QML engine won't be able to load the + # plugin. + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + # We don't care about static plugins here since, they are linked at build time and + # their location doesn't affect the runtime. + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "SHARED_LIBRARY" OR target_type STREQUAL "MODULE_LIBRARY") + if(NOT "${output_directory}") + set(output_directory "${CMAKE_CURRENT_BINARY_DIR}") + endif() + + list(GET CMAKE_CONFIGURATION_TYPES 0 default_config) + string(JOIN "" output_directory_with_default_config + "$," + "${output_directory}," + "${output_directory}/$" + ">" + ) + set_target_properties(${target} PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${output_directory_with_default_config}" + LIBRARY_OUTPUT_DIRECTORY "${output_directory_with_default_config}" + ) + endif() + endif() +endfunction() + +function(qt6_add_qml_plugin target) + set(args_option + STATIC + SHARED + NO_GENERATE_PLUGIN_SOURCE + ) + + set(args_single + OUTPUT_DIRECTORY + URI + BACKING_TARGET + CLASS_NAME + NAMESPACE + # The following is only needed on Android, and even then, only if the + # default conversion from the URI is not applicable. It is an internal + # option, it may be removed. + TARGET_PATH + ) + + set(args_multi "") + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${args_option}" + "${args_single}" + "${args_multi}" + ) + + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if(NOT arg_URI) + if(NOT arg_BACKING_TARGET) + message(FATAL_ERROR "No URI or BACKING_TARGET provided") + endif() + if(NOT TARGET ${arg_BACKING_TARGET}) + if(arg_BACKING_TARGET STREQUAL target) + message(FATAL_ERROR + "Plugin ${target} is its own backing target, URI must be provided" + ) + else() + message(FATAL_ERROR + "No URI provided and unable to obtain it from the BACKING_TARGET " + "(${arg_BACKING_TARGET}) because no such target exists" + ) + endif() + endif() + get_target_property(arg_URI ${arg_BACKING_TARGET} QT_QML_MODULE_URI) + if(NOT arg_URI) + message(FATAL_ERROR + "No URI provided and the BACKING_TARGET (${arg_BACKING_TARGET}) " + "does not have one set either" + ) + endif() + endif() + + _qt_internal_require_qml_uri_valid("${arg_URI}") + + # TODO: Probably should remove TARGET_PATH as a supported keyword now + if(NOT arg_TARGET_PATH AND TARGET "${arg_BACKING_TARGET}") + get_target_property(arg_TARGET_PATH ${arg_BACKING_TARGET} QT_QML_MODULE_TARGET_PATH) + endif() + if(NOT arg_TARGET_PATH) + string(REPLACE "." "/" arg_TARGET_PATH "${arg_URI}") + endif() + + _qt_internal_get_escaped_uri("${arg_URI}" escaped_uri) + + if(NOT arg_CLASS_NAME) + if(NOT "${arg_BACKING_TARGET}" STREQUAL "") + get_target_property(arg_CLASS_NAME ${arg_BACKING_TARGET} QT_QML_MODULE_CLASS_NAME) + endif() + if(NOT arg_CLASS_NAME) + _qt_internal_compute_qml_plugin_class_name_from_uri("${arg_URI}" arg_CLASS_NAME) + endif() + endif() + + if(arg_BACKING_TARGET AND TARGET "${arg_BACKING_TARGET}") + get_target_property(backing_type ${arg_BACKING_TARGET} TYPE) + endif() + + if(TARGET ${target}) + # Plugin target already exists. Perform a few sanity checks, but we + # otherwise trust that the target is appropriate for use as a plugin. + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "EXECUTABLE") + message(FATAL_ERROR "Plugins cannot be executables (target: ${target})") + endif() + foreach(arg IN ITEMS STATIC SHARED) + if(arg_${arg}) + message(FATAL_ERROR + "Cannot specify ${arg} keyword, target ${target} already exists" + ) + endif() + endforeach() + + get_target_property(existing_class_name ${target} QT_PLUGIN_CLASS_NAME) + if(existing_class_name) + if(NOT existing_class_name STREQUAL arg_CLASS_NAME) + message(FATAL_ERROR + "An existing plugin target was given, but it has a different class name " + "(${existing_class_name}) to that being used here (${arg_CLASS_NAME})" + ) + endif() + elseif(arg_CLASS_NAME) + set_property(TARGET ${target} PROPERTY QT_PLUGIN_CLASS_NAME "${arg_CLASS_NAME}") + else() + message(FATAL_ERROR + "An existing '${target}' plugin target was given, but it has no class name set " + "and no new class name was provided." + ) + endif() + else() + if(arg_STATIC AND arg_SHARED) + message(FATAL_ERROR + "Cannot specify both STATIC and SHARED for target ${target}" + ) + endif() + set(lib_type "") + if(arg_STATIC) + set(lib_type STATIC) + elseif(arg_SHARED) + set(lib_type SHARED) + endif() + + if(TARGET "${arg_BACKING_TARGET}") + # Ensure that the plugin type we create will be compatible with the + # type of backing target we were given + if(backing_type STREQUAL "STATIC_LIBRARY") + if(lib_type STREQUAL "") + set(lib_type STATIC) + elseif(lib_type STREQUAL "SHARED") + message(FATAL_ERROR + "Mixing a static backing library with a non-static plugin " + "is not supported" + ) + endif() + elseif(backing_type STREQUAL "SHARED_LIBRARY") + if(lib_type STREQUAL "") + set(lib_type SHARED) + elseif(lib_type STREQUAL "STATIC") + message(FATAL_ERROR + "Mixing a non-static backing library with a static plugin " + "is not supported" + ) + endif() + elseif(backing_type STREQUAL "EXECUTABLE") + message(FATAL_ERROR + "A separate plugin should not be needed when the backing target " + "is an executable. Pre-create the plugin target before calling " + "this command if you really must have a separate plugin." + ) + else() + # Object libraries, utility/custom targets + message(FATAL_ERROR "Unsupported backing target type: ${backing_type}") + endif() + endif() + + qt6_add_plugin(${target} ${lib_type} + PLUGIN_TYPE qml_plugin + CLASS_NAME ${arg_CLASS_NAME} + ) + endif() + + get_target_property(install_rpath ${target} INSTALL_RPATH) + # Ignore any CMAKE_INSTALL_RPATH and set a better default RPATH on platforms + # that support it, if allowed. Projects will often set CMAKE_INSTALL_RPATH + # for executables or backing libraries, but forget about plugins. Because + # the path for QML plugins depends on their URI, it is unlikely that + # CMAKE_INSTALL_RPATH would ever be intended for use with QML plugins. + # + # Avoid setting INSTALL_RPATH if it was set before. This is mostly + # applicable for the Qml plugins built in Qt tree, that got INSTALL_RPATH + # from the qt_internal_add_plugin function, but also can be the case for the + # user Qml plugins created manually. + if(NOT WIN32 AND NOT QT_NO_QML_PLUGIN_RPATH AND NOT install_rpath) + # Construct a relative path from a default install location (assumed to + # be qml/target-path) to ${CMAKE_INSTALL_LIBDIR}. This would be + # applicable for Apple too (although unusual) if this is a bare install + # (i.e. not part of an app bundle). + string(REPLACE "/" ";" path "qml/${arg_TARGET_PATH}") + list(LENGTH path path_count) + string(REPEAT "../" ${path_count} rel_path) + string(APPEND rel_path "${CMAKE_INSTALL_LIBDIR}") + if(APPLE) + set(install_rpath + # If embedded in an app bundle, search in a bundle-local path + # first. This path should always be the same for every app + # bundle because plugin binaries should live in the PlugIns + # directory, not a subdirectory of it or anywhere else. + # Similarly, frameworks and bare shared libraries should always + # be in the bundle's Frameworks directory. + "@loader_path/../Frameworks" + + # This will be needed if the plugin is not installed as part of + # an app bundle, such as when used by a command-line tool. + "@loader_path/${rel_path}" + ) + else() + set(install_rpath "$ORIGIN/${rel_path}") + endif() + set_target_properties(${target} PROPERTIES INSTALL_RPATH "${install_rpath}") + endif() + + get_target_property(moc_opts ${target} AUTOMOC_MOC_OPTIONS) + set(already_set FALSE) + if(moc_opts) + foreach(opt IN LISTS moc_opts) + if("${opt}" MATCHES "^-Muri=") + set(already_set TRUE) + break() + endif() + endforeach() + endif() + if(NOT already_set) + # Insert the plugin's URI into its meta data to enable usage + # of static plugins in QtDeclarative (like in mkspecs/features/qml_plugin.prf). + set_property(TARGET ${target} APPEND PROPERTY + AUTOMOC_MOC_OPTIONS "-Muri=${arg_URI}" + ) + endif() + + # Work around QTBUG-115152. + # Assign / duplicate the backing library's metatypes file to the qml plugin. + # This ensures that the metatypes are passed as foreign types to qmltyperegistrar when + # a consumer links against the plugin, but not the backing library. + # This is needed because the plugin links PRIVATEly to the backing library and thus the + # backing library's INTERFACE_SOURCES don't end up in the final consumer's SOURCES. + # Arguably doing this is cleaner than changing the linkage to PUBLIC, because that will + # propagate not only the INTERFACE_SOURCES, but also other link dependencies, which might + # be unwanted. + # In general this is a workaround due to CMake's limitations around support for propagating + # custom properties across targets to a final consumer target. + # https://gitlab.kitware.com/cmake/cmake/-/issues/20416 + if(arg_BACKING_TARGET + AND TARGET "${arg_BACKING_TARGET}" AND NOT arg_BACKING_TARGET STREQUAL target) + get_target_property(plugin_meta_types_file "${target}" INTERFACE_QT_META_TYPES_BUILD_FILE) + get_target_property( + backing_meta_types_file "${arg_BACKING_TARGET}" INTERFACE_QT_META_TYPES_BUILD_FILE) + get_target_property( + backing_meta_types_file_name + "${arg_BACKING_TARGET}" INTERFACE_QT_META_TYPES_FILE_NAME) + get_target_property(backing_has_qmltypes "${arg_BACKING_TARGET}" _qt_internal_has_qmltypes) + if(backing_has_qmltypes AND NOT plugin_meta_types_file) + _qt_internal_assign_build_metatypes_files_and_properties( + "${target}" + METATYPES_FILE_NAME "${backing_meta_types_file_name}" + METATYPES_FILE_PATH "${backing_meta_types_file}" + ) + endif() + endif() + + if(ANDROID) + _qt_internal_get_qml_plugin_output_name(plugin_output_name ${target} + BACKING_TARGET "${arg_BACKING_TARGET}" + TARGET_PATH "${arg_TARGET_PATH}" + URI "${arg_URI}" + ) + set_target_properties(${target} + PROPERTIES + LIBRARY_OUTPUT_NAME "${plugin_output_name}" + ) + set_property(TARGET "${target}" + PROPERTY _qt_android_apply_arch_suffix_called_from_qt_impl TRUE) + qt6_android_apply_arch_suffix(${target}) + endif() + + if(NOT arg_OUTPUT_DIRECTORY AND arg_BACKING_TARGET AND TARGET ${arg_BACKING_TARGET}) + get_target_property(arg_OUTPUT_DIRECTORY ${arg_BACKING_TARGET} QT_QML_MODULE_OUTPUT_DIRECTORY) + endif() + if(arg_OUTPUT_DIRECTORY) + # Plugin target must be in the output directory. The backing target, + # if it is different to the plugin target, can be anywhere. + set_target_properties(${target} PROPERTIES + RUNTIME_OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + LIBRARY_OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + ARCHIVE_OUTPUT_DIRECTORY ${arg_OUTPUT_DIRECTORY} + ) + endif() + + _qt_internal_set_qml_target_multi_config_output_directory(${target} "${arg_OUTPUT_DIRECTORY}") + + if(NOT arg_NO_GENERATE_PLUGIN_SOURCE) + set(generated_cpp_file_name_base "${target}_${arg_CLASS_NAME}") + set(register_types_function_name "qml_register_types_${escaped_uri}") + + # These are all substituted in the template file used further below + set(qt_qml_plugin_class_name "${arg_CLASS_NAME}") + set(qt_qml_plugin_moc_include_name "${generated_cpp_file_name_base}.moc") + set(qt_qml_plugin_intro "") + set(qt_qml_plugin_outro "") + set(qt_qml_plugin_constructor_content "") + + # Get the target that contains the resource names. + set(target_with_prop "${target}") + if(NOT arg_BACKING_TARGET STREQUAL "" AND TARGET "${arg_BACKING_TARGET}") + set(target_with_prop "${arg_BACKING_TARGET}") + endif() + + _qt_internal_qml_get_symbols_to_keep( + "${target_with_prop}" + "${backing_type}" + "${register_types_function_name}" + extra_intro_content + extra_intro_namespaced_content + extra_costructor_content + ) + + string(APPEND qt_qml_plugin_intro "${extra_intro_content}\n\n") + + if (arg_NAMESPACE) + string(APPEND qt_qml_plugin_intro "namespace ${arg_NAMESPACE} {\n") + string(APPEND qt_qml_plugin_outro "} // namespace ${arg_NAMESPACE}") + endif() + + string(APPEND qt_qml_plugin_intro "${extra_intro_namespaced_content}") + + string(APPEND qt_qml_plugin_constructor_content "${extra_costructor_content}") + + # Configure file from the template. + set(generated_cpp_file_in + "${CMAKE_CURRENT_BINARY_DIR}/${generated_cpp_file_name_base}_in.cpp" + ) + configure_file( + "${__qt_qml_macros_module_base_dir}/Qt6QmlPluginTemplate.cpp.in" + "${generated_cpp_file_in}" + @ONLY + ) + + get_target_property(template_generated ${target} _qt_qml_plugin_template_generated) + + if(NOT template_generated) + # Generate the file to allow adding generator expressions. + set(generated_cpp_file + "${CMAKE_CURRENT_BINARY_DIR}/${generated_cpp_file_name_base}.cpp" + ) + file(GENERATE OUTPUT "${generated_cpp_file}" + INPUT "${generated_cpp_file_in}" + ) + + # We can't rely on policy CMP0118 since user project controls it + set(scope_args) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set(scope_args TARGET_DIRECTORY ${target}) + endif() + set_source_files_properties("${generated_cpp_file}" ${scope_args} + PROPERTIES GENERATED TRUE + ) + + # Because the add_qml_plugin function might be called multiple times on the same target, + # Only generate and add the cpp file once. + set_target_properties(${target} PROPERTIES _qt_qml_plugin_template_generated TRUE) + target_sources(${target} PRIVATE "${generated_cpp_file}") + endif() + + # The generated cpp file expects to include its moc-ed output file. + set_target_properties(${target} PROPERTIES AUTOMOC TRUE) + endif() + + target_link_libraries(${target} PRIVATE ${QT_CMAKE_EXPORT_NAMESPACE}::Qml) + + # Link plugin against its backing lib if it has one. + if(NOT arg_BACKING_TARGET STREQUAL "" AND NOT arg_BACKING_TARGET STREQUAL target) + target_link_libraries(${target} PRIVATE ${arg_BACKING_TARGET}) + endif() + + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.19.0") + # Defer the collection of plugin dependencies until after any extra target_link_libraries + # calls that a user project might do. + # We wrap the deferred call with EVAL CODE + # so that ${target} is evaluated now rather than the end of the scope. + cmake_language(EVAL CODE + "cmake_language(DEFER CALL _qt_internal_add_static_qml_plugin_dependencies \"${target}\" \"${arg_BACKING_TARGET}\")" + ) + else() + # Can't defer, have to do it now. + _qt_internal_add_static_qml_plugin_dependencies("${target}" "${arg_BACKING_TARGET}") + endif() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_add_qml_plugin) + qt6_add_qml_plugin(${ARGV}) + endfunction() +endif() + +function(qt6_target_qml_sources target) + + get_target_property(uri ${target} QT_QML_MODULE_URI) + get_target_property(output_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + if(NOT uri OR NOT output_dir) + message(FATAL_ERROR "Target ${target} is not a QML module") + endif() + + set(args_option + NO_LINT + NO_CACHEGEN + NO_QMLDIR_TYPES + __QT_INTERNAL_FORCE_DEFER_QMLDIR # Used only by qt6_add_qml_module() + ADDING_QML_MODULE + ) + + set(args_single + PREFIX + OUTPUT_TARGETS + ) + + set(args_multi + QML_FILES + RESOURCES + ) + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${args_option}" "${args_single}" "${args_multi}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown/unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if(NOT arg_QML_FILES) + set_property(GLOBAL APPEND PROPERTY _qt_qml_aotstats_module_targets ${target}) + endif() + + get_target_property(no_lint ${target} QT_QML_MODULE_NO_LINT) + if(NOT arg_QML_FILES AND NOT arg_RESOURCES) + if(NOT arg_NO_LINT AND NOT no_lint) + _qt_internal_target_enable_qmllint(${target}) + endif() + + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} "" PARENT_SCOPE) + endif() + return() + endif() + + if(NOT arg___QT_INTERNAL_FORCE_DEFER_QMLDIR AND ${CMAKE_VERSION} VERSION_LESS "3.19.0") + message(FATAL_ERROR + "You are using CMake ${CMAKE_VERSION}, but CMake 3.19 or later " + "is required to add qml files with this function. Either pass " + "the qml files to qt6_add_qml_module() instead or update to " + "CMake 3.19 or later." + ) + endif() + + get_target_property(no_cachegen ${target} QT_QML_MODULE_NO_CACHEGEN) + get_target_property(no_qmldir ${target} QT_QML_MODULE_NO_GENERATE_QMLDIR) + get_target_property(no_extra_qmldirs ${target} QT_QML_MODULE_NO_GENERATE_EXTRA_QMLDIRS) + get_target_property(resource_prefix ${target} QT_QML_MODULE_RESOURCE_PREFIX) + get_target_property(qml_module_version ${target} QT_QML_MODULE_VERSION) + get_target_property(past_major_versions ${target} QT_QML_MODULE_PAST_MAJOR_VERSIONS) + + if(NOT output_dir) + # Probably not a qml module. We still want to support tooling for this + # scenario, it's just that we will be relying solely on the implicit + # imports to find things. + set(output_dir ${CMAKE_CURRENT_BINARY_DIR}) + set(no_qmldir TRUE) + endif() + + if(NOT arg_PREFIX) + if(resource_prefix) + set(arg_PREFIX ${resource_prefix}) + else() + message(FATAL_ERROR + "PREFIX option not given and target ${target} does not have a " + "QT_QML_MODULE_RESOURCE_PREFIX property set." + ) + endif() + endif() + _qt_internal_canonicalize_resource_path("${arg_PREFIX}" arg_PREFIX) + if(arg_PREFIX STREQUAL resource_prefix) + set(prefix_override "") + else() + set(prefix_override "${arg_PREFIX}") + endif() + if(NOT arg_PREFIX STREQUAL "/") + string(APPEND arg_PREFIX "/") + endif() + + if (qml_module_version MATCHES "^([0-9]+)\\.") + set(qml_module_files_versions "${CMAKE_MATCH_1}.0") + else() + message(FATAL_ERROR + "No major version found in '${qml_module_version}'." + ) + endif() + if (past_major_versions OR past_major_versions STREQUAL "0") + foreach (past_major_version ${past_major_versions}) + list(APPEND qml_module_files_versions "${past_major_version}.0") + endforeach() + endif() + + # Linting and cachegen can still occur for a target that isn't a qml module, + # but for such targets, there is no qmldir file to update. + if(arg_NO_LINT) + set(no_lint TRUE) + endif() + if(arg_NO_CACHEGEN OR QT_QML_NO_CACHEGEN) + set(no_cachegen TRUE) + endif() + if(no_qmldir MATCHES "NOTFOUND" OR arg_NO_QMLDIR_TYPES) + set(no_qmldir TRUE) + endif() + + if(NOT no_cachegen AND arg_QML_FILES) + + # Even if we don't generate a qmldir file, it still should be here, manually written. + # We can pass it unconditionally. If it's not there, qmlcachegen or qmlsc might warn, + # but that's not fatal. + set(qmldir_file ${output_dir}/qmldir) + + _qt_internal_genex_getproperty(qmltypes_file ${target} QT_QML_MODULE_PLUGIN_TYPES_FILE) + _qt_internal_genex_getproperty(qmlcachegen ${target} QT_QMLCACHEGEN_EXECUTABLE) + _qt_internal_genex_getproperty(direct_calls ${target} QT_QMLCACHEGEN_DIRECT_CALLS) + _qt_internal_genex_getjoinedproperty(arguments ${target} + QT_QMLCACHEGEN_ARGUMENTS "$" "$" + ) + _qt_internal_genex_getjoinedproperty(import_paths ${target} + QT_QML_IMPORT_PATH "-I$" "$" + ) + _qt_internal_genex_getjoinedproperty(qrc_resource_args ${target} + _qt_generated_qrc_files "--resource$" "$" + ) + get_target_property(target_type ${target} TYPE) + get_target_property(is_android_executable ${target} _qt_is_android_executable) + if(target_type STREQUAL "EXECUTABLE" OR is_android_executable) + # The application binary directory is part of the default import path. + list(APPEND import_paths -I "$") + else() + string(REPLACE "." "/" uri_path "${uri}") + string(FIND "${output_dir}" "${uri_path}" position REVERSE) + string(LENGTH "${output_dir}" output_dir_length) + string(LENGTH "${uri_path}" uri_path_length) + math(EXPR import_path_length "${output_dir_length} - ${uri_path_length}") + if("${position}" EQUAL "${import_path_length}") + string(SUBSTRING "${output_dir}" "0" "${import_path_length}" import_path) + list(APPEND import_paths -I "${import_path}") + endif() + endif() + _qt_internal_extend_qml_import_paths(import_paths) + set(cachegen_args + ${import_paths} + -i "${qmldir_file}" + "$<${have_direct_calls}:--direct-calls>" + "$<${have_arguments}:${arguments}>" + ${qrc_resource_args} + # The --only-bytecode argument is mutually exclusive with aotstats and can + # be added after qt_add_qml_module. Conditionally add aotstats flags via genex. + "$<$>:--dump-aot-stats>" + "$<$>:--module-id=${uri}(${target})>" + ) + + # For direct evaluation in if() below + get_target_property(cachegen_prop ${target} QT_QMLCACHEGEN_EXECUTABLE) + if(cachegen_prop) + if(cachegen_prop STREQUAL "qmlcachegen" OR cachegen_prop STREQUAL "qmlsc") + # If it's qmlcachegen or qmlsc, don't go looking for other programs of that name + set(qmlcachegen "$") + else() + find_program(${target}_QMLCACHEGEN ${cachegen_prop}) + if(${target}_QMLCACHEGEN) + set(qmlcachegen "${${target}_QMLCACHEGEN}") + else() + message(FATAL_ERROR "Invalid qmlcachegen binary ${cachegen_prop} for ${target}") + endif() + endif() + else() + set(have_qmlsc "$") + set(cachegen_name "$") + set(qmlcachegen "$") + endif() + endif() + + set(non_qml_cpp_files "") + set(non_qml_files "") + set(output_targets "") + set(copied_files "") + + # We want to set source file properties in the target's own scope if we can. + # That's the canonical place the properties will be read from. + if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.18) + set(scope_option TARGET_DIRECTORY ${target}) + else() + set(scope_option "") + endif() + + foreach(file_set IN ITEMS QML_FILES RESOURCES) + foreach(file_src IN LISTS arg_${file_set}) + get_filename_component(file_absolute ${file_src} ABSOLUTE) + + # Store the original files so the project can query them later. + set_property(TARGET ${target} APPEND PROPERTY + QT_QML_MODULE_${file_set} ${file_absolute} + ) + if(prefix_override) + set_source_files_properties(${file_absolute} ${scope_option} + PROPERTIES + QT_QML_MODULE_PREFIX_OVERRIDE "${prefix_override}" + ) + endif() + + # We need to copy the file to the build directory now so that when + # qmlimportscanner is run in qt6_import_qml_plugins() as part of + # target finalizers, the files will be there. We need to do this + # in a way that CMake doesn't create a dependency on the source or it + # will re-run CMake every time the file is modified. We also don't + # want to update the file's timestamp if its contents won't change. + # We still enforce the dependency on the source file by adding a + # build-time rule. This avoids having to re-run CMake just to re-copy + # the file. + __qt_get_relative_resource_path_for_file(file_resource_path ${file_src}) + set(file_out ${output_dir}/${file_resource_path}) + + # Don't generate or copy the file in an in-source build if the source + # and destination paths are the same, it will cause a ninja dependency + # cycle at build time. + if(NOT file_out STREQUAL file_absolute) + get_filename_component(file_out_dir ${file_out} DIRECTORY) + file(MAKE_DIRECTORY ${file_out_dir}) + + if(EXISTS "${file_absolute}") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.21") + # Significantly increases copying speed according to profiling, presumably + # because we bypass process creation. + file(COPY_FILE "${file_absolute}" "${file_out}" ONLY_IF_DIFFERENT) + else() + execute_process(COMMAND + ${CMAKE_COMMAND} -E copy_if_different ${file_absolute} ${file_out} + ) + endif() + endif() + + add_custom_command(OUTPUT ${file_out} + COMMAND ${CMAKE_COMMAND} -E copy ${file_absolute} ${file_out} + DEPENDS ${file_absolute} + WORKING_DIRECTORY $ + VERBATIM + COMMENT "Copying ${file_src} to ${file_out}" + ) + list(APPEND copied_files ${file_out}) + endif() + endforeach() + endforeach() + + set(generated_sources_other_scope) + set(extra_qmldirs) + foreach(qml_file_src IN LISTS arg_QML_FILES) + # This is to facilitate updating code that used the earlier tech preview + # API function qt6_target_qml_files() + if(NOT qml_file_src MATCHES "\\.(js|mjs|qml)$") + if(qml_file_src MATCHES "\\.(cpp|cxx|cc|c|c\\+\\+|h|hh|hxx|hpp|h\\+\\+)") + list(APPEND non_qml_cpp_files "${qml_file_src}") + else() + list(APPEND non_qml_files "${qml_file_src}") + endif() + continue() + endif() + + # Mark QML files as source files, so that they do not appear in in Creator + # or other IDEs + set_source_files_properties(${qml_file_src} HEADER_FILE_ONLY ON) + target_sources(${target} PRIVATE ${qml_file_src}) + + get_filename_component(file_absolute ${qml_file_src} ABSOLUTE) + __qt_get_relative_resource_path_for_file(file_resource_path ${qml_file_src}) + + get_filename_component(qml_file_resource_dir ${file_resource_path} DIRECTORY) + if(qml_file_resource_dir) + list(APPEND extra_qmldirs "${output_dir}/${qml_file_resource_dir}/qmldir") + endif() + + # For the tooling steps below, run the tools on the copied qml file in + # the build directory, not the source directory. This is required + # because the tools may need to reference imported modules from + # subdirectories, which would require those subdirectories to have + # their generated qmldir files present. They also need to use the right + # resource paths and the source locations might be structured quite + # differently. + + # Add file to those processed by qmllint + get_source_file_property(skip_qmllint ${qml_file_src} QT_QML_SKIP_QMLLINT) + if(NOT no_lint AND NOT skip_qmllint) + # The set of qml files to run qmllint on may be a subset of the + # full set of files, so record these in a separate property. + _qt_internal_target_enable_qmllint(${target}) + set_property(TARGET ${target} APPEND PROPERTY QT_QML_LINT_FILES ${file_absolute}) + endif() + + # Add qml file's type to qmldir + get_source_file_property(skip_qmldir ${qml_file_src} QT_QML_SKIP_QMLDIR_ENTRY) + if(NOT no_qmldir AND NOT skip_qmldir) + get_source_file_property(qml_file_typename ${qml_file_src} QT_QML_SOURCE_TYPENAME) + if (NOT qml_file_typename) + get_filename_component(qml_file_ext ${qml_file_src} EXT) + get_filename_component(qml_file_typename ${qml_file_src} NAME_WE) + endif() + + # Do not add qmldir entries for lowercase names. Those are not components. + if (qml_file_typename AND qml_file_typename MATCHES "^[A-Z]") + if (qml_file_ext AND NOT qml_file_ext STREQUAL ".qml" AND NOT qml_file_ext STREQUAL ".ui.qml" + AND NOT qml_file_ext STREQUAL ".js" AND NOT qml_file_ext STREQUAL ".mjs") + message(AUTHOR_WARNING + "${qml_file_src} has a file extension different from .qml, .ui.qml, .js, " + "and .mjs. This leads to unexpected component names." + ) + endif() + if(qml_file_ext AND qml_file_ext STREQUAL ".js" AND skip_qmldir STREQUAL "NOTFOUND") + file( + STRINGS ${qml_file_src} pragma_library + REGEX "^\\.pragma library$" + LIMIT_COUNT 1 + LIMIT_INPUT 128 + ) + if(NOT pragma_library) + message(AUTHOR_WARNING + "${qml_file_src} is not an ECMAScript module and also doesn't contain " + "'.pragma library'. It will be re-evaluated in the context of every " + "QML document that explicitly or implicitly imports ${uri}. Set its " + "QT_QML_SKIP_QMLDIR_ENTRY source file property to FALSE if you really " + "want this to happen. Set it to TRUE to prevent it." + ) + endif() + endif() + + # We previously accepted the singular form of this property name + # during tech preview. Issue a warning for that, but still + # honor it. The plural form will override it if both are set. + get_property(have_singular_property SOURCE ${qml_file_src} + PROPERTY QT_QML_SOURCE_VERSION SET + ) + if(have_singular_property) + message(AUTHOR_WARNING + "The QT_QML_SOURCE_VERSION source file property has been replaced " + "by QT_QML_SOURCE_VERSIONS (i.e. plural rather than singular). " + "The singular form will eventually be removed, please update " + "the project to use the plural form instead for the file at:\n" + " ${qml_file_src}" + ) + endif() + get_source_file_property(qml_file_versions ${qml_file_src} QT_QML_SOURCE_VERSIONS) + if(NOT qml_file_versions AND have_singular_property) + get_source_file_property(qml_file_versions ${qml_file_src} QT_QML_SOURCE_VERSION) + endif() + + get_source_file_property(qml_file_singleton ${qml_file_src} QT_QML_SINGLETON_TYPE) + get_source_file_property(qml_file_internal ${qml_file_src} QT_QML_INTERNAL_TYPE) + + if (qml_file_singleton AND qml_file_internal) + message(FATAL_ERROR + "${qml_file_src} is marked as both internal and as a " + "singleton, but singletons cannot be internal!") + endif() + + if (NOT qml_file_versions) + set(qml_file_versions ${qml_module_files_versions}) + endif() + + set(qmldir_file_contents "") + foreach(qml_file_version IN LISTS qml_file_versions) + if (qml_file_singleton) + string(APPEND qmldir_file_contents "singleton ") + elseif (qml_file_internal) + continue() + endif() + string(APPEND qmldir_file_contents "${qml_file_typename} ${qml_file_version} ${file_resource_path}\n") + endforeach() + + if (qml_file_internal) + # TODO: Remove when all qmldir parsers can parse internal types with versions. + # Instead handle internal types like singletons above. + # See QTCREATORBUG-28755 + string(APPEND qmldir_file_contents "internal ${qml_file_typename} ${file_resource_path}\n") + endif() + + set_property(TARGET ${target} APPEND_STRING PROPERTY + _qt_internal_qmldir_content "${qmldir_file_contents}" + ) + + if(ANDROID AND QT_ANDROID_GENERATE_JAVA_QML_COMPONENTS) + get_source_file_property(qml_file_generate_java_classes ${qml_file_src} + QT_QML_GENERATE_ANDROID_JAVA_CLASS + ) + if(qml_file_generate_java_classes) + get_target_property(qml_module_uri ${target} QT_QML_MODULE_URI) + set_property(TARGET ${target} APPEND PROPERTY + _qt_qml_files_for_java_generator "${qml_module_uri}.${qml_file_typename}") + endif() + endif() + endif() + endif() + + # Run cachegen on the qml file, or if disabled, store the raw qml file in the resources + get_source_file_property(skip_cachegen ${qml_file_src} QT_QML_SKIP_CACHEGEN) + if(NOT no_cachegen AND NOT skip_cachegen) + # We delay this to here to ensure that we only ever enable cachegen + # after we know there will be at least one file to compile. + get_target_property(is_cachegen_set_up ${target} _qt_cachegen_set_up) + if(NOT is_cachegen_set_up) + _qt_internal_target_enable_qmlcachegen(${target} ${qmlcachegen}) + endif() + + # We ensured earlier that arg_PREFIX always ends with "/" + file(TO_CMAKE_PATH "${arg_PREFIX}${file_resource_path}" file_resource_path) + + set_property(TARGET ${target} APPEND PROPERTY + QT_QML_MODULE_RESOURCE_PATHS ${file_resource_path} + ) + + file(RELATIVE_PATH file_relative ${CMAKE_CURRENT_SOURCE_DIR} ${file_absolute}) + string(REGEX REPLACE "\\.(js|mjs|qml)$" "_\\1" compiled_file ${file_relative}) + string(REGEX REPLACE "[$#?]+" "_" compiled_file ${compiled_file}) + + # The file name needs to be unique to work around an Integrity compiler issue. + # Search for INTEGRITY_SYMBOL_UNIQUENESS in this file for details. + set(compiled_file + "${CMAKE_CURRENT_BINARY_DIR}/.rcc/qmlcache/${target}_${compiled_file}.cpp") + get_filename_component(out_dir ${compiled_file} DIRECTORY) + + if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config" AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") + set(qmlcachegen_cmd "$") + else() + set(qmlcachegen_cmd "${qmlcachegen}") + endif() + + set(aotstats_file "") + if("${qml_file_src}" MATCHES ".+\\.qml") + set(aotstats_file "${compiled_file}.aotstats") + list(APPEND aotstats_files ${aotstats_file}) + endif() + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + add_custom_command( + OUTPUT + ${compiled_file} + ${aotstats_file} + COMMAND ${CMAKE_COMMAND} -E make_directory ${out_dir} + COMMAND + ${tool_wrapper} + ${qmlcachegen_cmd} + --bare + --resource-path "${file_resource_path}" + ${cachegen_args} + -o "${compiled_file}" + "${file_absolute}" + COMMAND_EXPAND_LISTS + DEPENDS + ${qmlcachegen_cmd} + "${file_absolute}" + $ + "$<$:${qmltypes_file}>" + "${qmldir_file}" + VERBATIM + ) + + target_sources(${target} PRIVATE ${compiled_file}) + set_source_files_properties(${compiled_file} PROPERTIES + SKIP_AUTOGEN ON + ) + # The current scope automatically sees the file as generated, but the + # target scope may not if it is different. Force it where we can. + # We will also have to add the generated file to a target in this + # scope at the end to ensure correct dependencies. + get_target_property(target_source_dir ${target} SOURCE_DIR) + if(NOT target_source_dir STREQUAL CMAKE_CURRENT_SOURCE_DIR) + list(APPEND generated_sources_other_scope ${compiled_file}) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set_source_files_properties( + ${compiled_file} + TARGET_DIRECTORY ${target} + PROPERTIES + SKIP_AUTOGEN TRUE + GENERATED TRUE + ) + endif() + endif() + endif() + endforeach() + + if(arg_ADDING_QML_MODULE AND "${CMAKE_VERSION}" VERSION_GREATER_EQUAL "3.19.0") + set_property(GLOBAL APPEND PROPERTY _qt_qml_aotstats_module_targets ${target}) + set_target_properties(${target} PROPERTIES + QT_QML_MODULE_AOTSTATS_FILES "${aotstats_files}" + QT_QML_MODULE_RCC_QMLCACHE_PATH "${CMAKE_CURRENT_BINARY_DIR}/.rcc/qmlcache" + ) + endif() + + if(ANDROID) + _qt_internal_collect_qml_root_paths("${target}" ${arg_QML_FILES}) + endif() + + if(non_qml_files OR non_qml_cpp_files) + if(non_qml_cpp_files) + list(JOIN non_qml_cpp_files "\n " file_list) + set(wrong_sources "\nwith SOURCES:\n ${file_list}" + ) + endif() + if(non_qml_files) + list(JOIN non_qml_files "\n " file_list) + set(wrong_resources "\nwith RESOURCES:\n ${file_list}") + endif() + + message(WARNING "Only .qml, .js or .mjs files should be added with QML_FILES. " + "The following files should be added${wrong_sources}${wrong_resources}") + endif() + + if(copied_files OR generated_sources_other_scope) + if(CMAKE_VERSION VERSION_LESS 3.19) + # Called from qt6_add_qml_module() and we know there can only be + # this one call. With those constraints, we can use a custom target + # to implement the necessary dependencies to get files copied to the + # build directory when their source files change. + add_custom_target(${target}_tooling ALL + DEPENDS + ${copied_files} + ${generated_sources_other_scope} + ) + add_dependencies(${target} ${target}_tooling) + else() + # We could be called multiple times and a custom target can only + # have file-level dependencies added at the time the target is + # created. Use an interface library instead, since we can add + # private sources to those and have the library act as a build + # system target from CMake 3.19 onward, and we can add the sources + # progressively over multiple calls. + if(NOT TARGET ${target}_tooling) + add_library(${target}_tooling INTERFACE) + add_dependencies(${target} ${target}_tooling) + set_target_properties(${target}_tooling PROPERTIES QT_EXCLUDE_FROM_TRANSLATION ON) + endif() + target_sources(${target}_tooling PRIVATE + ${copied_files} + ${generated_sources_other_scope} + ) + endif() + _qt_internal_assign_to_internal_targets_folder(${target}_tooling) + endif() + + # Batch all the non-compiled qml sources into a single resource for this + # call. Subsequent calls for the same target will be in their own separate + # resource file. + get_target_property(counter ${target} QT_QML_MODULE_RAW_QML_SETS) + if(NOT counter) + set(counter 0) + endif() + set(resource_name ${target}_raw_qml_${counter}) + set(resource_targets) + qt6_add_resources(${target} ${resource_name} + PREFIX ${arg_PREFIX} + FILES ${arg_QML_FILES} ${arg_RESOURCES} + OUTPUT_TARGETS resource_targets + ) + list(APPEND output_targets ${resource_targets}) + + # Save the resource name in a property so we can reference it later in a qml plugin + # constructor, to avoid discarding the resource if it's in a static library. + __qt_internal_sanitize_resource_name( + sanitized_resource_name "${resource_name}") + set_property(TARGET ${target} + APPEND PROPERTY _qt_qml_module_sanitized_resource_names "${sanitized_resource_name}") + + if(extra_qmldirs AND NOT no_extra_qmldirs) + list(REMOVE_DUPLICATES extra_qmldirs) + __qt_internal_setup_policy(QTP0004 "6.8.0" +"You need qmldir files for each extra directory that contains .qml files for your module. \ +Check https://doc.qt.io/qt-6/qt-cmake-policy-qtp0004.html for policy details." + ) + qt6_policy(GET QTP0004 generate_extra_qmldirs_policy) + if ("${generate_extra_qmldirs_policy}" STREQUAL "NEW" AND NOT no_qmldir) + foreach(extra_qmldir IN LISTS extra_qmldirs) + set(__qt_qmldir_content "prefer :${arg_PREFIX}") + configure_file( + ${__qt_qml_macros_module_base_dir}/Qt6qmldirTemplate.cmake.in + "${extra_qmldir}" + @ONLY + ) + + set_source_files_properties("${extra_qmldir}" + PROPERTIES GENERATED TRUE + ) + endforeach() + + set(extra_qmldirs_targets) + qt6_add_resources(${target} "${resource_name}_extra_qmldirs" + PREFIX ${arg_PREFIX} + FILES ${extra_qmldirs} + BASE ${output_dir} + OUTPUT_TARGETS extra_qmldirs_targets + ) + list(APPEND output_targets ${extra_qmldirs_targets}) + + set_property(TARGET ${target} PROPERTY _qt_internal_extra_qmldirs ${extra_qmldirs}) + + # Save the resource name in a property so we can reference it later in a qml plugin + # constructor, to avoid discarding the resource if it's in a static library. + __qt_internal_sanitize_resource_name( + sanitized_extra_qmldirs_resource_name "${resource_name}_extra_qmldirs") + set_property(TARGET ${target} + APPEND PROPERTY _qt_qml_module_sanitized_resource_names + "${sanitized_extra_qmldirs_resource_name}") + endif() + endif() + + math(EXPR counter "${counter} + 1") + set_target_properties(${target} PROPERTIES QT_QML_MODULE_RAW_QML_SETS ${counter}) + + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${output_targets} PARENT_SCOPE) + endif() + +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_target_qml_sources) + qt6_target_qml_sources(${ARGV}) + cmake_parse_arguments(PARSE_ARGV 1 arg "" "OUTPUT_TARGETS" "") + if(arg_OUTPUT_TARGETS) + set(${arg_OUTPUT_TARGETS} ${${arg_OUTPUT_TARGETS}} PARENT_SCOPE) + endif() + endfunction() +endif() + +function(qt6_generate_foreign_qml_types source_target destination_qml_target) + qt6_extract_metatypes(${source_target}) + get_target_property(target_metatypes_json_file ${source_target} + INTERFACE_QT_META_TYPES_BUILD_FILE) + if (NOT target_metatypes_json_file) + message(FATAL_ERROR "Need target metatypes.json file") + endif() + + get_target_property(automoc_enabled ${destination_qml_target} AUTOMOC) + if(NOT automoc_enabled) + message(FATAL_ERROR "qt6_generate_foreign_qml_types requires AUTOMOC to be enabled " + "on target '${destination_qml_target}'.") + endif() + + set(registration_files_base ${source_target}_${destination_qml_target}) + set(additional_sources + "${CMAKE_CURRENT_BINARY_DIR}/${registration_files_base}.cpp" + "${CMAKE_CURRENT_BINARY_DIR}/${registration_files_base}.h" + ) + + set(namespace_args "") + get_target_property(namespace ${destination_qml_target} QT_QML_MODULE_NAMESPACE) + if (namespace) + list(APPEND namespace_args "--namespace" "${namespace}") + endif() + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + add_custom_command( + OUTPUT + ${additional_sources} + DEPENDS + ${source_target} + ${target_metatypes_json_file} + ${QT_CMAKE_EXPORT_NAMESPACE}::qmltyperegistrar + COMMAND + ${tool_wrapper} + $ + "--extract" + ${namespace_args} + -o ${registration_files_base} + ${target_metatypes_json_file} + COMMENT "Generate QML registration code for target ${source_target}" + VERBATIM + ) + + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.27") + set_source_files_properties(${additional_sources} PROPERTIES SKIP_LINTING ON) + endif() + target_sources(${destination_qml_target} PRIVATE ${additional_sources}) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + function(qt_generate_foreign_qml_types) + qt6_generate_foreign_qml_types(${ARGV}) + endfunction() + else() + message(FATAL_ERROR "qt_generate_foreign_qml_types() is only available in Qt 6.") + endif() +endif() + +# target: Expected to be the backing target for a qml module. Certain target +# properties normally set by qt6_add_qml_module() will be retrieved from this +# target. (REQUIRED) +# +# MANUAL_MOC_JSON_FILES: Specifies a list of json files, generated by a manual +# moc call, to extract metatypes. (OPTIONAL) +# +# NAMESPACE: Specifies a namespace the type registration function shall be +# generated into. (OPTIONAL) +# +# REGISTRATIONS_TARGET: Specifies a separate target the generated .cpp file +# shall be added to. If not given, the main backing target is used. (OPTIONAL) +# +function(_qt_internal_qml_type_registration target) + set(args_option) + set(args_single NAMESPACE REGISTRATIONS_TARGET) + set(args_multi MANUAL_MOC_JSON_FILES) + + get_target_property(skipped ${target} _qt_is_skipped_test) + if(skipped) + return() + endif() + + cmake_parse_arguments(PARSE_ARGV 1 arg + "${args_option}" "${args_single}" "${args_multi}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown/unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + get_target_property(import_name ${target} QT_QML_MODULE_URI) + if (NOT import_name) + message(FATAL_ERROR "Target ${target} is not a QML module") + endif() + get_target_property(qmltypes_output_name ${target} QT_QML_MODULE_TYPEINFO) + if (NOT qmltypes_output_name) + get_target_property(compile_definitions_list ${target} COMPILE_DEFINITIONS) + list(FIND compile_definitions_list QT_PLUGIN is_a_plugin) + if (is_a_plugin GREATER_EQUAL 0) + set(qmltypes_output_name "plugins.qmltypes") + else() + set(qmltypes_output_name ${target}.qmltypes) + endif() + endif() + + set(meta_types_json_args "") + if(arg_MANUAL_MOC_JSON_FILES) + list(APPEND meta_types_json_args "MANUAL_MOC_JSON_FILES" ${arg_MANUAL_MOC_JSON_FILES}) + endif() + qt6_extract_metatypes(${target} ${meta_types_json_args}) + + get_target_property(import_version ${target} QT_QML_MODULE_VERSION) + get_target_property(output_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + get_target_property(target_source_dir ${target} SOURCE_DIR) + get_target_property(target_binary_dir ${target} BINARY_DIR) + get_target_property(target_metatypes_file ${target} INTERFACE_QT_META_TYPES_BUILD_FILE) + if (NOT target_metatypes_file) + message(FATAL_ERROR "Target ${target} does not have a meta types file") + endif() + + # Extract major and minor version (could also have patch part, but we don't + # need that here) + if (import_version MATCHES "^([0-9]+)\\.([0-9]+)") + set(major_version ${CMAKE_MATCH_1}) + set(minor_version ${CMAKE_MATCH_2}) + else() + message(FATAL_ERROR + "Invalid module version number '${import_version}'. " + "Expected VersionMajor.VersionMinor." + ) + endif() + + # check if plugins.qmltypes is already defined + get_target_property(target_plugin_qmltypes ${target} QT_QML_MODULE_PLUGIN_TYPES_FILE) + if (target_plugin_qmltypes) + message(FATAL_ERROR "Target ${target} already has a qmltypes file set.") + endif() + + set(cmd_args) + set(plugin_types_file "${output_dir}/${qmltypes_output_name}") + set(generated_marker_file "${target_binary_dir}/.qt/qmltypes/${qmltypes_output_name}") + get_filename_component(generated_marker_dir "${generated_marker_file}" DIRECTORY) + set_target_properties(${target} PROPERTIES + QT_QML_MODULE_PLUGIN_TYPES_FILE ${plugin_types_file} + ) + + if (arg_NAMESPACE) + list(APPEND cmd_args + --namespace=${arg_NAMESPACE} + ) + endif() + + list(APPEND cmd_args + --generate-qmltypes=${plugin_types_file} + --import-name=${import_name} + --major-version=${major_version} + --minor-version=${minor_version} + ) + + + # Add --follow-foreign-versioning if requested + get_target_property(follow_foreign_versioning ${target} + _qt_qml_module_follow_foreign_versioning) + + if (follow_foreign_versioning) + list(APPEND cmd_args + --follow-foreign-versioning + ) + endif() + + # Add past minor versions + get_target_property(past_major_versions ${target} QT_QML_MODULE_PAST_MAJOR_VERSIONS) + + if (past_major_versions OR past_major_versions STREQUAL "0") + foreach (past_major_version ${past_major_versions}) + list(APPEND cmd_args + --past-major-version ${past_major_version} + ) + endforeach() + endif() + + # Run a script to recursively evaluate all the metatypes.json files in order + # to collect all foreign types. + string(TOLOWER "${target}_qmltyperegistrations.cpp" type_registration_cpp_file_name) + set(foreign_types_file "${target_binary_dir}/qmltypes/${target}_foreign_types.txt") + set(type_registration_cpp_file "${target_binary_dir}/${type_registration_cpp_file_name}") + + # Enable evaluation of metatypes.json source interfaces + set_target_properties(${target} PROPERTIES QT_CONSUMES_METATYPES TRUE) + set(genex_list "$,INCLUDE,metatypes.json$>>") + set(genex_main "$>") + file(GENERATE OUTPUT "${foreign_types_file}" + CONTENT "$,--foreign-types=${genex_main},\n>" + ) + + list(APPEND cmd_args + "@${foreign_types_file}" + ) + + if (TARGET ${target}Private) + list(APPEND cmd_args --private-includes) + else() + string(REGEX MATCH "Private$" privateSuffix ${target}) + if (privateSuffix) + list(APPEND cmd_args --private-includes) + endif() + endif() + + get_target_property(target_metatypes_json_file ${target} INTERFACE_QT_META_TYPES_BUILD_FILE) + if (NOT target_metatypes_json_file) + message(FATAL_ERROR "Need target metatypes.json file") + endif() + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + add_custom_command( + OUTPUT + ${type_registration_cpp_file} + ${plugin_types_file} + DEPENDS + ${foreign_types_file} + ${target_metatypes_json_file} + ${QT_CMAKE_EXPORT_NAMESPACE}::qmltyperegistrar + "$<$:${genex_list}>" + COMMAND + ${tool_wrapper} + $ + ${cmd_args} + -o ${type_registration_cpp_file} + ${target_metatypes_json_file} + COMMAND + ${CMAKE_COMMAND} -E make_directory "${generated_marker_dir}" + COMMAND + ${CMAKE_COMMAND} -E touch "${generated_marker_file}" + COMMENT "Automatic QML type registration for target ${target}" + VERBATIM + ) + + # The ${target}_qmllint targets need to depend on the generation of all + # *.qmltypes files in the build. We have no way of reliably working out + # which QML modules a given target depends on at configure time, so we + # have to be conservative and make ${target}_qmllint targets depend on all + # *.qmltypes files. We need to provide a target for those dependencies + # here. Note that we can't use ${target} itself for those dependencies + # because the user might want to run qmllint without having to build the + # QML module. + add_custom_target(${target}_qmltyperegistration + DEPENDS + ${type_registration_cpp_file} + ${plugin_types_file} + ) + _qt_internal_assign_to_internal_targets_folder(${target}_qmltyperegistration) + if(NOT TARGET all_qmltyperegistrations) + add_custom_target(all_qmltyperegistrations) + _qt_internal_assign_to_internal_targets_folder(all_qmltyperegistrations) + endif() + add_dependencies(all_qmltyperegistrations ${target}_qmltyperegistration) + + set(effective_target ${target}) + if(arg_REGISTRATIONS_TARGET) + set(effective_target ${arg_REGISTRATIONS_TARGET}) + endif() + + # Both ${effective_target} (via target_sources) and ${target}_qmltyperegistration (via + # add_custom_target DEPENDS option) depend on ${type_registration_cpp_file}. + # The new Xcode build system requires a common target to drive the generation of files, + # otherwise project configuration fails. + # Make ${effective_target} the common target, by adding it as a dependency for + # ${target}_qmltyperegistration. + # The consequence is that the ${target}_qmllint target will now first build ${effective_target} + # when using the Xcode generator (mostly only relevant for projects using Qt for iOS). + # See QTBUG-95763. + if(CMAKE_GENERATOR STREQUAL "Xcode") + add_dependencies(${target}_qmltyperegistration ${effective_target}) + endif() + + target_sources(${effective_target} PRIVATE ${type_registration_cpp_file}) + + # FIXME: The generated .cpp file has usually lost the path information for + # the headers it #include's. Since these generated .cpp files are in + # the build directory away from those headers, the header search path + # has to be augmented to ensure they can be found. We don't know what + # paths are needed, but add the source directory to at least handle + # the common case of headers in the same directory as the target. + # See QTBUG-93443. + target_include_directories(${effective_target} PRIVATE ${target_source_dir}) + + # Circumvent "too many sections" error when doing a 32 bit debug build on Windows with + # MinGW. + set(additional_source_files_properties "") + if(MINGW) + set(additional_source_files_properties "COMPILE_OPTIONS" "-Wa,-mbig-obj") + elseif(MSVC) + set(additional_source_files_properties "COMPILE_OPTIONS" "/bigobj") + endif() + set_source_files_properties(${type_registration_cpp_file} PROPERTIES + SKIP_AUTOGEN ON + ${additional_source_files_properties} + ) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18") + set_source_files_properties( + ${type_registration_cpp_file} + TARGET_DIRECTORY ${effective_target} + PROPERTIES + SKIP_AUTOGEN TRUE + GENERATED TRUE + ${additional_source_files_properties} + ) + endif() + + target_include_directories(${effective_target} PRIVATE + $ + ) +endfunction() + +function(qt6_qml_type_registration) + message(FATAL_ERROR + "This function, previously available under Technical Preview, has been removed. " + "Please use qt6_add_qml_module() instead." + ) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_qml_type_registration) + message(FATAL_ERROR + "This function, previously available under Technical Preview, has been removed. " + "Please use qt_add_qml_module() instead." + ) + endfunction() +endif() + +# Get Qt provided QML import paths. +# The appending order is important. Build dirs are preferred over install dirs. +function(_qt_internal_get_main_qt_qml_import_paths out_var) + set(qml_import_paths "") + + # When building a qml module as part of a prefix Qt build that is not yet installed, add an + # extra import path which is the current module's build dir: we need + # this to ensure correct importing of QML modules when having a prefix-build + # with QLibraryInfo::path(QLibraryInfo::QmlImportsPath) pointing to the + # install location. + if(QT_BUILDING_QT AND QT_WILL_INSTALL) + set(build_dir_import_path "${QT_BUILD_DIR}/${INSTALL_QMLDIR}") + if(IS_DIRECTORY "${build_dir_import_path}") + list(APPEND qml_import_paths "${build_dir_import_path}") + endif() + endif() + + # We could have multiple additional installation prefixes: one per Qt repository (conan). + # Or just extra ones, that might be needed during cross-compilation or example building. + # Add those that have a "qml" subdirectory. + # The additional prefixes have priority over the main Qt prefix, so they come first. + if(NOT "${_qt_additional_packages_prefix_paths}" STREQUAL "") + __qt_internal_prefix_paths_to_roots( + additional_root_paths "${_qt_additional_packages_prefix_paths}") + foreach(root IN ITEMS ${additional_root_paths}) + set(candidate "${root}/${QT6_INSTALL_QML}") + if(IS_DIRECTORY "${candidate}") + list(APPEND qml_import_paths "${candidate}") + endif() + endforeach() + endif() + + # Add the main Qt "/qml" import path. + if(QT6_INSTALL_PREFIX) + set(main_import_path "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_QML}") + if(IS_DIRECTORY "${main_import_path}") + list(APPEND qml_import_paths "${main_import_path}") + endif() + endif() + + set(${out_var} "${qml_import_paths}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_collect_target_qml_import_paths out_var target) + set(qml_import_paths "") + # Get custom import paths provided during qt_add_qml_module call. + get_target_property(qml_import_path ${target} QT_QML_IMPORT_PATH) + if(qml_import_path) + list(APPEND qml_import_paths ${qml_import_path}) + endif() + + # Facilitate self-import so we can find the qmldir file + get_target_property(module_out_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + if(module_out_dir) + list(APPEND qml_import_paths "${module_out_dir}") + endif() + + # Find qmldir files we copied to the build directory + if(NOT "${QT_QML_OUTPUT_DIRECTORY}" STREQUAL "") + if(EXISTS "${QT_QML_OUTPUT_DIRECTORY}") + list(APPEND qml_import_paths "${QT_QML_OUTPUT_DIRECTORY}") + endif() + else() + list(APPEND qml_import_paths "${CMAKE_CURRENT_BINARY_DIR}") + endif() + + set(${out_var} "${qml_import_paths}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_collect_qml_import_paths out_var target) + _qt_internal_collect_target_qml_import_paths(qml_import_paths ${target}) + + # Add the Qt import paths last. + _qt_internal_get_main_qt_qml_import_paths(qt_main_import_paths) + list(APPEND qml_import_paths ${qt_main_import_paths}) + + set(${out_var} "${qml_import_paths}" PARENT_SCOPE) +endfunction() + +# This function returns the path to the qmlimportscanner executable. +# The are a few cases to handle: +# When used in a user project, the tool should already be built and we can find the path +# via the imported target. +# When used in an example that is built as part of the qtdeclarative build (or top-level build), +# there is no imported target yet. Here we have to differentiate whether the tool will be run at +# build time or configure time. +# If at configure time, we show an error, there is nothing to run yet. Such a setup is currently not +# supported. +# If at build time, we return the path where the built tool will be located after it is built. +function(_qt_internal_find_qmlimportscanner_path out_path scan_at_configure_time) + # Find location of qmlimportscanner via the imported target. + set(tool_path "") + set(tool_name "qmlimportscanner") + set(import_scanner_target "${QT_CMAKE_EXPORT_NAMESPACE}::${tool_name}") + if(TARGET "${import_scanner_target}") + get_target_property(tool_path "${import_scanner_target}" IMPORTED_LOCATION) + if(NOT tool_path) + set(configs "RELWITHDEBINFO;RELEASE;MINSIZEREL;DEBUG") + foreach(config ${configs}) + get_target_property(tool_path + "${import_scanner_target}" IMPORTED_LOCATION_${config}) + if(tool_path) + break() + endif() + endforeach() + endif() + endif() + + if(NOT QT_BUILDING_QT) + set(building_user_project TRUE) + else() + set(building_user_project FALSE) + endif() + + if(NOT EXISTS "${tool_path}" + AND (building_user_project OR scan_at_configure_time)) + message(FATAL_ERROR "The qmlimportscanner tool could not be found. +Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation was faulty. +") + endif() + + # We are building Qt, the tool is not built yet and we need to run it at build time. + if(NOT tool_path) + qt_path_join(tool_path + "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}" + "${tool_name}${CMAKE_EXECUTABLE_SUFFIX}") + endif() + + set(${out_path} "${tool_path}" PARENT_SCOPE) +endfunction() + +function(_qt_internal_scan_qml_imports target imports_file_var when_to_scan) + if(NOT "${ARGN}" STREQUAL "") + message(FATAL_ERROR "Unknown/unexpected arguments: ${ARGN}") + endif() + + if(when_to_scan STREQUAL "BUILD_PHASE") + set(scan_at_build_time TRUE) + set(scan_at_configure_time FALSE) + set(imports_file_infix "build") + elseif(when_to_scan STREQUAL "IMMEDIATELY") + set(scan_at_build_time FALSE) + set(scan_at_configure_time TRUE) + set(imports_file_infix "conf") + else() + message(FATAL_ERROR "Unexpected value for when_to_scan: ${when_to_scan}") + endif() + + _qt_internal_find_qmlimportscanner_path(tool_path "${scan_at_configure_time}") + + get_target_property(target_source_dir ${target} SOURCE_DIR) + get_target_property(target_binary_dir ${target} BINARY_DIR) + set(out_dir "${target_binary_dir}/.qt/qml_imports") + + # Create separate files for scanning at build time vs configure time. Otherwise calling + # ninja clean will re-run qmlimportscanner directly after the clean, which is + # both weird and sometimes prints warnings due to the tool not finding qml files that were + # cleaned from the build dir. + set(file_base_name "${target}_${imports_file_infix}") + + set(imports_file "${out_dir}/${file_base_name}.cmake") + set(${imports_file_var} "${imports_file}" PARENT_SCOPE) + file(MAKE_DIRECTORY ${out_dir}) + + set(cmd_args + -rootPath "${target_source_dir}" + -cmake-output + -output-file "${imports_file}" + ) + + _qt_internal_collect_qml_import_paths(qml_import_paths ${target}) + list(REMOVE_DUPLICATES qml_import_paths) + + # Construct the -importPath arguments. + set(import_path_arguments) + foreach(path IN LISTS qml_import_paths) + if(EXISTS "${path}" OR scan_at_build_time) + list(APPEND import_path_arguments -importPath ${path}) + else() + message(DEBUG "The import path ${path} is mentioned for ${target}, but it doesn't" + " exists.") + endif() + endforeach() + + list(APPEND cmd_args ${import_path_arguments}) + + # All of the module's .qml files will be listed in one of the generated + # .qrc files, so there's no need to list the files individually. We provide + # the .qrc files instead because they have the additional information for + # each file's resource alias. + get_property(qrc_files TARGET ${target} PROPERTY _qt_generated_qrc_files) + if (qrc_files) + list(APPEND cmd_args "-qrcFiles" ${qrc_files}) + endif() + + # Use a response file to avoid command line length issues if we have a lot + # of arguments on the command line + string(LENGTH "${cmd_args}" length) + if(length GREATER 240) + set(rsp_file "${out_dir}/${file_base_name}.rsp") + list(JOIN cmd_args "\n" rsp_file_content) + file(WRITE ${rsp_file} "${rsp_file_content}") + set(cmd_args "@${rsp_file}") + endif() + + _qt_internal_get_tool_wrapper_script_path(tool_wrapper) + set(import_scanner_args ${tool_wrapper} ${tool_path} ${cmd_args}) + + # Run qmlimportscanner to generate the cmake file that records the import entries + if(scan_at_build_time) + add_custom_command( + OUTPUT "${imports_file}" + COMMENT "Running qmlimportscanner for ${target}" + COMMAND ${import_scanner_args} + WORKING_DIRECTORY ${target_source_dir} + DEPENDS + ${tool_path} + ${qrc_files} + $ + VERBATIM + ) + add_custom_target(${target}_qmlimportscan DEPENDS "${imports_file}") + _qt_internal_assign_to_internal_targets_folder(${target}_qmlimportscan) + add_dependencies(${target} ${target}_qmlimportscan) + else() + message(VERBOSE "Running qmlimportscanner for ${target}.") + list(JOIN import_scanner_args " " import_scanner_args_string) + message(DEBUG "qmlimportscanner command: ${import_scanner_args_string}") + execute_process( + COMMAND ${import_scanner_args} + WORKING_DIRECTORY ${target_source_dir} + RESULT_VARIABLE result + ) + if(result) + message(FATAL_ERROR + "Failed to scan target ${target} for QML imports: ${result}" + ) + endif() + endif() +endfunction() + +# Parse the entry at the specified index, assuming the caller already included +# the file generated by a call to _qt_internal_scan_qml_imports() +macro(_qt_internal_parse_qml_imports_entry prefix index) + cmake_parse_arguments("${prefix}" + "" + "CLASSNAME;NAME;PATH;PLUGIN;RELATIVEPATH;TYPE;VERSION;LINKTARGET;PREFER" + "COMPONENTS;SCRIPTS" + ${qml_import_scanner_import_${index}} + ) +endmacro() + + +# This function is called as a finalizer in qt6_finalize_executable() for any +# target that links against the Qml library. +function(qt6_import_qml_plugins target) + if(NOT TARGET ${QT_CMAKE_EXPORT_NAMESPACE}::qmlimportscanner) + return() + endif() + + get_target_property(is_imported ${QT_CMAKE_EXPORT_NAMESPACE}::qmlimportscanner IMPORTED) + if(NOT is_imported) + message(DEBUG "qt6_import_qml_plugins is called before qmlimportscanner is built." + " Skip calling qmlimportscanner because it doesn't yet exist.") + return() + endif() + + # Protect against being called multiple times in case we are being called + # explicitly before the finalizer is invoked. + get_target_property(already_imported ${target} _QT_QML_PLUGINS_IMPORTED) + get_target_property(no_import_scan ${target} QT_QML_MODULE_NO_IMPORT_SCAN) + if(already_imported OR no_import_scan) + return() + endif() + set_target_properties(${target} PROPERTIES _QT_QML_PLUGINS_IMPORTED TRUE) + + _qt_internal_scan_qml_imports(${target} imports_file IMMEDIATELY) + include("${imports_file}") + + # Parse the generated cmake file. + # It is possible for the scanner to find no usage of QML, in which case the import count is 0. + if(qml_import_scanner_imports_count GREATER 0) + set(added_plugins "") + set(plugins_to_link "") + set(plugin_inits_to_link "") + + math(EXPR last_index "${qml_import_scanner_imports_count} - 1") + foreach(index RANGE 0 ${last_index}) + _qt_internal_parse_qml_imports_entry(entry ${index}) + if(entry_PATH) + if(NOT entry_PLUGIN) + # Check if qml module is built within the build tree, and should have a plugin + # target, but its qmldir file is not generated yet. + _qt_internal_find_qml_module(qml_module BY_OUTPUT_DIRS "${entry_PATH}") + if(qml_module) + get_target_property(entry_LINKTARGET + ${qml_module} QT_QML_MODULE_PLUGIN_TARGET) + if(entry_LINKTARGET AND TARGET ${entry_LINKTARGET}) + get_target_property(entry_PLUGIN ${entry_LINKTARGET} OUTPUT_NAME) + endif() + endif() + endif() + + if(entry_PLUGIN) + # Sometimes a plugin appears multiple times with different versions. + # Make sure to process it only once. + list(FIND added_plugins "${entry_PLUGIN}" _index) + if(NOT _index EQUAL -1) + continue() + endif() + list(APPEND added_plugins "${entry_PLUGIN}") + + # Link against the Qml plugin. + # For plugins provided by Qt, we assume those plugin targets are already defined + # (typically brought in via find_package(Qt6...) ). + # For other plugins, the targets can come from the project itself. + # + if(entry_LINKTARGET) + if(TARGET ${entry_LINKTARGET}) + get_target_property(target_type ${entry_LINKTARGET} TYPE) + if(target_type STREQUAL "STATIC_LIBRARY") + list(APPEND plugins_to_link "${entry_LINKTARGET}") + endif() + else() + message(WARNING + "The qml plugin '${entry_PLUGIN}' is a dependency of '${target}', " + "but the link target it defines (${entry_LINKTARGET}) does not " + "exist in the current scope. The plugin will not be linked." + ) + endif() + elseif(TARGET ${entry_PLUGIN}) + get_target_property(target_type ${entry_PLUGIN} TYPE) + if(target_type STREQUAL "STATIC_LIBRARY") + list(APPEND plugins_to_link "${entry_PLUGIN}") + endif() + else() + # TODO: QTBUG-94605 Figure out if this is a reasonable scenario to support + message(WARNING + "The qml plugin '${entry_PLUGIN}' is a dependency of '${target}', " + "but there is no target by that name in the current scope. The plugin " + "will not be linked." + ) + endif() + endif() + endif() + endforeach() + + if(plugins_to_link) + # If ${target} is an executable or a shared library, link the plugins directly to + # the target. + # If ${target} is a static or INTERFACE library, the plugins should be propagated + # across those libraries to the end target (executable or shared library). + # The plugin initializers will be linked via usage requirements from the plugin target. + get_target_property(target_type ${target} TYPE) + if(target_type STREQUAL "EXECUTABLE" OR target_type STREQUAL "SHARED_LIBRARY" + OR target_type STREQUAL "MODULE_LIBRARY") + set(link_type "PRIVATE") + else() + set(link_type "INTERFACE") + endif() + target_link_libraries("${target}" ${link_type} ${plugins_to_link}) + endif() + endif() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + function(qt_import_qml_plugins) + if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) + qt5_import_qml_plugins(${ARGV}) + elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) + qt6_import_qml_plugins(${ARGV}) + endif() + endfunction() +endif() + +function(_qt_internal_add_qml_deploy_info_finalizer target) + get_property(finalizer_added TARGET ${target} PROPERTY _qt_qml_deploy_finalizer_added) + if(NOT finalizer_added) + set_property(TARGET ${target} APPEND PROPERTY + INTERFACE_QT_EXECUTABLE_FINALIZERS + _qt_internal_generate_deploy_qml_imports_script + ) + set_property(TARGET ${target} PROPERTY _qt_qml_deploy_finalizer_added TRUE) + endif() +endfunction() + +# This function may be called as a finalizer in qt6_finalize_executable() for any +# target that links against the Qml library for a shared Qt. +function(_qt_internal_generate_deploy_qml_imports_script target) + if(NOT QT6_IS_SHARED_LIBS_BUILD) + return() + endif() + get_target_property(target_type ${target} TYPE) + # TODO: Handle Android where executables are module libraries instead + if(NOT target_type STREQUAL "EXECUTABLE") + return() + endif() + + # Protect against being called multiple times in case we are being called + # explicitly before the finalizer is invoked. + get_target_property(already_generated ${target} _QT_QML_PLUGIN_SCAN_GENERATED) + get_target_property(no_import_scan ${target} QT_QML_MODULE_NO_IMPORT_SCAN) + if(already_generated OR no_import_scan) + return() + endif() + set_target_properties(${target} PROPERTIES _QT_QML_PLUGIN_SCAN_GENERATED TRUE) + + # Defer actually running qmlimportscanner until build time. This keeps the + # configure step fast and takes advantage of the build step supporting + # parallel execution if there are multiple targets that need scanning. + _qt_internal_scan_qml_imports(${target} imports_file BUILD_PHASE) + + set(is_bundle FALSE) + if(APPLE) + if(IOS) + message(FATAL_ERROR "Install support not available for iOS builds") + endif() + get_target_property(is_bundle ${target} MACOSX_BUNDLE) + endif() + set(is_bundle "$") + + # For macOS app bundles, the directory layout must conform to Apple's + # requirements, so we hard-code the required structure. This assumes the + # app bundle is installed to the base dir with an install command like: + # install(TARGETS ${target} BUNDLE DESTINATION .) + set(bundle_qml_dir "$.app/Contents/Resources/qml") + set(bundle_plugins_dir "$.app/Contents/PlugIns") + + _qt_internal_get_deploy_impl_dir(deploy_impl_dir) + string(MAKE_C_IDENTIFIER "${target}" target_id) + set(filename "${deploy_impl_dir}/deploy_qml_imports/${target_id}") + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + string(APPEND filename "-$") + endif() + string(APPEND filename ".cmake") + + # TODO: Fix macOS multi-config bundles to work. + file(GENERATE OUTPUT "${filename}" CONTENT +"# Auto-generated deploy QML imports script for target \"${target}\". +# Do not edit, all changes will be lost. +# This file should only be included by qt6_deploy_qml_imports(). + +set(__qt_opts $<${is_bundle}:BUNDLE>) +if(arg_NO_QT_IMPORTS) + list(APPEND __qt_opts NO_QT_IMPORTS) +endif() + +_qt_internal_deploy_qml_imports_for_target( + \${__qt_opts} + IMPORTS_FILE \"${imports_file}\" + PLUGINS_FOUND __qt_internal_plugins_found + QML_DIR \"$\" + PLUGINS_DIR \"$\" +) + +if(arg_PLUGINS_FOUND) + set(\${arg_PLUGINS_FOUND} \"\${__qt_internal_plugins_found}\" PARENT_SCOPE) +endif() +") + +endfunction() + +function(qt6_generate_deploy_qml_app_script) + # We take the target using a TARGET keyword instead of as the first + # positional argument so that we have a consistent signature with the + # qt6_generate_deploy_app_script() from qtbase. That function might accept + # an executable instead of a target in the future, but we can't because we + # need information associated with the target (scanning all its .qml files + # for imported QML modules). + set(no_value_options + NO_UNSUPPORTED_PLATFORM_ERROR + NO_TRANSLATIONS + NO_COMPILER_RUNTIME + MACOS_BUNDLE_POST_BUILD + DEPLOY_USER_QML_MODULES_ON_UNSUPPORTED_PLATFORM + ) + set(single_value_options + TARGET + OUTPUT_SCRIPT + + # TODO: For backward compatibility / transitional use only, + # remove at some point + FILENAME_VARIABLE + ) + set(qt_deploy_runtime_dependencies_options + # These options are forwarded as is to qt_deploy_runtime_dependencies. + PRE_INCLUDE_REGEXES + PRE_EXCLUDE_REGEXES + POST_INCLUDE_REGEXES + POST_EXCLUDE_REGEXES + POST_INCLUDE_FILES + POST_EXCLUDE_FILES + DEPLOY_TOOL_OPTIONS + ) + set(multi_value_options + ${qt_deploy_runtime_dependencies_options} + ) + cmake_parse_arguments(PARSE_ARGV 0 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + if(NOT arg_TARGET) + message(FATAL_ERROR "TARGET must be specified") + endif() + + # TODO: Remove when FILENAME_VARIABLE is fully removed + # Handle the slow deprecation of FILENAME_VARIABLE + if(arg_FILENAME_VARIABLE) + if(arg_OUTPUT_SCRIPT AND NOT arg_FILENAME_VARIABLE STREQUAL arg_OUTPUT_SCRIPT) + message(FATAL_ERROR + "Both FILENAME_VARIABLE and OUTPUT_SCRIPT were given and were different. " + "Only one of the two should be used." + ) + endif() + message(AUTHOR_WARNING + "The FILENAME_VARIABLE keyword is deprecated and will be removed soon. " + "Please use OUTPUT_SCRIPT instead.") + set(arg_OUTPUT_SCRIPT "${arg_FILENAME_VARIABLE}") + unset(arg_FILENAME_VARIABLE) + endif() + + if(NOT arg_OUTPUT_SCRIPT) + message(FATAL_ERROR "OUTPUT_SCRIPT must be specified") + endif() + + # Check that the target was defer-finalized, and not immediately finalized when using + # CMake < 3.19. This is important because if it's immediately finalized, Qt::Qml is likely + # not in the dependency list, and thus _qt_internal_generate_deploy_qml_imports_script will + # not be executed, leading to an error at install time + # 'No QML imports information recorded for target X'. + # _qt_is_immediately_finalized is set by qt6_add_executable. + # TODO: Remove once minimum required CMAKE_VERSION is 3.19+. + get_target_property(is_immediately_finalized "${arg_TARGET}" _qt_is_immediately_finalized) + if(is_immediately_finalized) + message(FATAL_ERROR + "QML app deployment requires CMake version 3.19, or later, or manual executable " + "finalization. For manual finalization, pass the MANUAL_FINALIZATION option to " + "qt_add_executable() and then call qt_finalize_target(${arg_TARGET}) just before + calling qt_generate_deploy_qml_app_script().") + endif() + + # Generate a descriptive deploy script name. + string(MAKE_C_IDENTIFIER "${arg_TARGET}" target_id) + set(deploy_script_name "qml_app_${target_id}") + + get_target_property(is_bundle ${arg_TARGET} MACOSX_BUNDLE) + + set(unsupported_platform_extra_message "") + if(QT6_IS_SHARED_LIBS_BUILD) + set(qt_build_type_string "shared Qt libs") + else() + set(qt_build_type_string "static Qt libs") + endif() + + if(CMAKE_CROSSCOMPILING) + string(APPEND qt_build_type_string ", cross-compiled") + endif() + + if(NOT is_bundle) + string(APPEND qt_build_type_string ", non-bundle app") + set(unsupported_platform_extra_message + "Executable targets have to be app bundles to use this command on Apple platforms.") + endif() + + set(skip_message + "_qt_internal_show_skip_runtime_deploy_message(\"${qt_build_type_string}\"") + if(unsupported_platform_extra_message) + string(APPEND skip_message + "\n EXTRA_MESSAGE \"${unsupported_platform_extra_message}\"") + endif() + string(APPEND skip_message "\n)") + + set(common_deploy_args "") + if(arg_NO_TRANSLATIONS) + string(APPEND common_deploy_args " NO_TRANSLATIONS\n") + endif() + if(arg_NO_COMPILER_RUNTIME) + string(APPEND common_deploy_args " NO_COMPILER_RUNTIME\n") + endif() + + # Forward the arguments that are exactly the same for qt_deploy_runtime_dependencies. + foreach(var IN LISTS qt_deploy_runtime_dependencies_options) + if(NOT "${arg_${var}}" STREQUAL "") + list(APPEND common_deploy_args ${var} ${arg_${var}}) + endif() + endforeach() + + _qt_internal_should_skip_deployment_api(skip_deployment skip_reason) + _qt_internal_should_skip_post_build_deployment_api(skip_post_build_deployment + post_build_skip_reason) + + if(APPLE AND NOT IOS AND QT6_IS_SHARED_LIBS_BUILD AND is_bundle) + # TODO: Consider handling non-bundle applications in the future using the generic cmake + # runtime dependency feature. + + set(should_post_build FALSE) + if(arg_MACOS_BUNDLE_POST_BUILD AND NOT skip_post_build_deployment) + set(should_post_build TRUE) + endif() + + # Generate the real deployment script when both post build step either deployment are + # enabled. + # If we skip deployment, but not the POST_BUILD step, we still need to generate the + # regular deploy script to run it during POST_BUILD time. + if(NOT skip_deployment OR should_post_build) + qt6_generate_deploy_script( + TARGET ${arg_TARGET} + NAME ${deploy_script_name} + OUTPUT_SCRIPT real_deploy_script + CONTENT " +qt6_deploy_qml_imports(TARGET ${arg_TARGET} PLUGINS_FOUND plugins_found) +if(NOT DEFINED __QT_DEPLOY_POST_BUILD) + qt6_deploy_runtime_dependencies( + EXECUTABLE $.app + ADDITIONAL_MODULES \${plugins_found} + ${common_deploy_args}) +endif()") + endif() + + # Generate a no-op script either if we skip deployment or the post build step. + if(skip_deployment) + _qt_internal_generate_no_op_deploy_script( + FUNCTION_NAME "qt6_generate_deploy_qml_app_script" + SKIP_REASON "${skip_reason}" + TARGET ${arg_TARGET} + NAME ${deploy_script_name} + OUTPUT_SCRIPT no_op_deploy_script + ) + endif() + + if(skip_post_build_deployment) + _qt_internal_generate_no_op_deploy_script( + FUNCTION_NAME "qt6_generate_deploy_qml_app_script" + SKIP_REASON "${post_build_skip_reason}" + TARGET ${arg_TARGET} + NAME ${deploy_script_name} + OUTPUT_SCRIPT no_op_post_build_script + ) + endif() + + # Choose which deployment script to use during installation. + if(skip_deployment) + set(deploy_script "${no_op_deploy_script}") + else() + set(deploy_script "${real_deploy_script}") + endif() + + # Choose which deployment script to use during the post build step. + if(should_post_build) + set(post_build_deploy_script "${real_deploy_script}") + elseif(skip_post_build_deployment) + # Explicitly asked to skip post build, show a no-op message. + set(post_build_deploy_script "${no_op_post_build_script}") + endif() + + if(should_post_build OR skip_post_build_deployment) + # We must not deploy the runtime dependencies, otherwise we interfere + # with CMake's RPATH rewriting at install time. We only need the QML + # imports deployed to the bundle anyway, the build RPATHs will allow + # the regular libraries, frameworks and non-QML plugins to still be + # found, even if they are outside the app bundle. + + # Support Xcode, which places the application build dir into a configuration specific + # subdirectory. Override both the deploy prefix and install prefix, because we + # differentiate them in the qml installation implementation due to ENV{DESTDIR} + # handling. + set(deploy_path_suffix "") + get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + set(deploy_path_suffix "/$") + endif() + + set(target_binary_dir_with_config_prefix + "$${deploy_path_suffix}") + + set(post_build_install_prefix + "CMAKE_INSTALL_PREFIX=${target_binary_dir_with_config_prefix}") + + set(post_build_deploy_prefix + "QT_DEPLOY_PREFIX=${target_binary_dir_with_config_prefix}") + + add_custom_command(TARGET ${arg_TARGET} POST_BUILD + COMMAND ${CMAKE_COMMAND} + -D "${post_build_install_prefix}" + -D "${post_build_deploy_prefix}" + -D "__QT_DEPLOY_POST_BUILD=TRUE" + -P "${post_build_deploy_script}" + VERBATIM + ) + endif() + elseif(skip_deployment) + _qt_internal_generate_no_op_deploy_script( + FUNCTION_NAME "qt6_generate_deploy_qml_app_script" + SKIP_REASON "${skip_reason}" + TARGET ${arg_TARGET} + NAME ${deploy_script_name} + OUTPUT_SCRIPT deploy_script + ) + elseif(WIN32 AND QT6_IS_SHARED_LIBS_BUILD) + qt6_generate_deploy_script( + TARGET ${arg_TARGET} + NAME ${deploy_script_name} + OUTPUT_SCRIPT deploy_script + CONTENT " +qt6_deploy_qml_imports(TARGET ${arg_TARGET} PLUGINS_FOUND plugins_found) +qt6_deploy_runtime_dependencies( + EXECUTABLE $ + ADDITIONAL_MODULES \${plugins_found} + GENERATE_QT_CONF +${common_deploy_args})") + elseif(UNIX AND NOT APPLE AND NOT ANDROID AND NOT CMAKE_CROSSCOMPILING + AND QT6_IS_SHARED_LIBS_BUILD) + qt6_generate_deploy_script( + TARGET ${arg_TARGET} + NAME ${deploy_script_name} + OUTPUT_SCRIPT deploy_script + CONTENT " +qt6_deploy_qml_imports(TARGET ${arg_TARGET} PLUGINS_FOUND plugins_found) +qt6_deploy_runtime_dependencies( + EXECUTABLE $ + ADDITIONAL_MODULES \${plugins_found} + GENERATE_QT_CONF +${common_deploy_args})") + elseif((arg_NO_UNSUPPORTED_PLATFORM_ERROR OR + QT_INTERNAL_NO_UNSUPPORTED_PLATFORM_ERROR) + AND (arg_DEPLOY_USER_QML_MODULES_ON_UNSUPPORTED_PLATFORM + OR QT_INTERNAL_DEPLOY_USER_QML_MODULES_ON_UNSUPPORTED_PLATFORM) + AND QT6_IS_SHARED_LIBS_BUILD) + # User project explicitly requested to deploy only user QML modules on a shared Qt libs + # platform where qt_deploy_runtime_dependencies does not work. + # This is useful for projects that will deploy the Qt QML and runtime libraries manually. + # This also offers a migration path to enable qt_deploy_runtime_dependencies for + # unsupported platforms without breaking projects that already handle runtime libs manually. + # But for it to work cleanly, projects will have to enable both + # NO_UNSUPPORTED_PLATFORM_ERROR and DEPLOY_USER_QML_MODULES_ON_UNSUPPORTED_PLATFORM + # conditionally per platform. + qt6_generate_deploy_script( + TARGET ${arg_TARGET} + NAME ${deploy_script_name} + OUTPUT_SCRIPT deploy_script + CONTENT " +${skip_message} +qt6_deploy_qml_imports(TARGET ${arg_TARGET} NO_QT_IMPORTS) +") + elseif(NOT arg_NO_UNSUPPORTED_PLATFORM_ERROR AND NOT QT_INTERNAL_NO_UNSUPPORTED_PLATFORM_ERROR) + # Currently we don't deploy runtime dependencies if cross-compiling or using a static Qt. + # Error out by default unless the project opted out of the error. + # This provides us a migration path in the future without breaking compatibility promises. + message(FATAL_ERROR + "Support for installing runtime dependencies is not implemented for " + "this target platform (${CMAKE_SYSTEM_NAME}, ${qt_build_type_string}). " + ${unsupported_platform_extra_message} + ) + else() + qt6_generate_deploy_script( + TARGET ${arg_TARGET} + NAME ${deploy_script_name} + OUTPUT_SCRIPT deploy_script + CONTENT " +${skip_message} +_qt_internal_show_skip_qml_runtime_deploy_message() +") + endif() + + set(${arg_OUTPUT_SCRIPT} ${deploy_script} PARENT_SCOPE) +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + macro(qt_generate_deploy_qml_app_script) + qt6_generate_deploy_qml_app_script(${ARGV}) + endmacro() +endif() + +function(qt6_query_qml_module target) + + if(NOT TARGET ${target}) + message(FATAL_ERROR "\"${target}\" is not a target") + endif() + + get_target_property(is_imported ${target} IMPORTED) + if(is_imported) + message(FATAL_ERROR + "Only targets built by the project can be used with this command, " + "but target \"${target}\" is imported." + ) + endif() + + get_target_property(uri ${target} QT_QML_MODULE_URI) + if(NOT uri) + message(FATAL_ERROR + "Target \"${target}\" does not appear to be a QML module" + ) + endif() + + set(no_value_options "") + set(single_value_options + URI + VERSION + PLUGIN_TARGET + MODULE_RESOURCE_PATH + TARGET_PATH + QMLDIR + TYPEINFO + QML_FILES + QML_FILES_DEPLOY_PATHS # relative to target path + QML_FILES_PREFIX_OVERRIDES + RESOURCES + RESOURCES_DEPLOY_PATHS # relative to target path + RESOURCES_PREFIX_OVERRIDES + ) + set(multi_value_options "") + cmake_parse_arguments(PARSE_ARGV 1 arg + "${no_value_options}" "${single_value_options}" "${multi_value_options}" + ) + if(arg_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unexpected arguments: ${arg_UNPARSED_ARGUMENTS}") + endif() + + if(arg_URI) + set(${arg_URI} "${uri}" PARENT_SCOPE) + endif() + + if(arg_VERSION) + get_property(version TARGET ${target} PROPERTY QT_QML_MODULE_VERSION) + set(${arg_VERSION} "${version}" PARENT_SCOPE) + endif() + + if(arg_PLUGIN_TARGET) + # There might not be a plugin target, so return an empty string for that + get_property(plugin_target TARGET ${target} PROPERTY QT_QML_MODULE_PLUGIN_TARGET) + set(${arg_PLUGIN_TARGET} "${plugin_target}" PARENT_SCOPE) + endif() + + if(arg_MODULE_RESOURCE_PATH) + # Note that QT_QML_MODULE_RESOURCE_PREFIX is not the RESOURCE_PREFIX + # passed to qt6_add_qml_module(). It is that plus the target path, which + # corresponds to what we mean by the MODULE_RESOURCE_PATH. + get_property(prefix TARGET ${target} PROPERTY QT_QML_MODULE_RESOURCE_PREFIX) + set(${arg_MODULE_RESOURCE_PATH} "${prefix}" PARENT_SCOPE) + endif() + + string(REPLACE "." "/" target_path "${uri}") + if(arg_TARGET_PATH) + set(${arg_TARGET_PATH} "${target_path}" PARENT_SCOPE) + endif() + + get_target_property(output_dir ${target} QT_QML_MODULE_OUTPUT_DIRECTORY) + + if(arg_QMLDIR) + set(${arg_QMLDIR} "${output_dir}/qmldir" PARENT_SCOPE) + endif() + + # This should always be set to something non-empty + # unless we've explicitly said NO_GENERATE_QMLTYPES + get_target_property(typeinfo ${target} QT_QML_MODULE_TYPEINFO) + if(arg_TYPEINFO AND typeinfo) + set(${arg_TYPEINFO} "${output_dir}/${typeinfo}" PARENT_SCOPE) + endif() + + get_target_property(target_source_dir ${target} SOURCE_DIR) + if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.18) + set(scope_option TARGET_DIRECTORY ${target}) + else() + set(scope_option "") + if(NOT target_source_dir STREQUAL CMAKE_CURRENT_SOURCE_DIR AND + (arg_QML_FILES_DEPLOY_PATHS OR arg_RESOURCES_DEPLOY_PATHS)) + # This isn't a fatal error because it will only be a problem if any + # qml or resource files actually have source file properties set. + message(WARNING + "Calling qt6_query_qml_module() from a different directory scope " + "to the one in which target \"${target}\" was created. " + "This requires CMake 3.18 or later to be robust, but you are using " + "CMake ${CMAKE_VERSION}. Deployment paths may not be correct." + ) + endif() + endif() + + # Because of how CMake lists work, in particular appending empty strings, + # we have to use a placeholder to represent empty values and then replace + # them at the end. If we don't do this, any list that starts with an empty + # value ends up discarding that empty value because it is indistinguishable + # from an empty list. + set(empty_placeholder "__qt_empty_placeholder__") + + foreach(file_set IN ITEMS QML_FILES RESOURCES) + # NOTE: We converted these files to absolute paths already when storing them + get_target_property(files ${target} QT_QML_MODULE_${file_set}) + + if(arg_${file_set}) + set(${arg_${file_set}} "${files}" PARENT_SCOPE) + endif() + + if(arg_${file_set}_DEPLOY_PATHS OR arg_${file_set}_PREFIX_OVERRIDES) + set(deploy_paths "") + set(prefix_overrides "") + foreach(abs_file IN LISTS files) + # The QT_QML_MODULE_PREFIX_OVERRIDE is the PREFIX value that was passed to + # qt_target_qml_sources. It has no relation to the QT_QML_MODULE_RESOURCE_PREFIX + # property or the computed MODULE_RESOURCE_PATH variable above. + get_property(prefix_override SOURCE ${abs_file} ${scope_option} + PROPERTY QT_QML_MODULE_PREFIX_OVERRIDE + ) + if("${prefix_override}" STREQUAL "") + list(APPEND prefix_overrides "${empty_placeholder}") + else() + list(APPEND prefix_overrides "${prefix_override}") + endif() + + # We can't provide a deploy path when the resource prefix is + # overridden. We still need to store an empty deploy path for it + # though so that the file lists all line up correctly. + if(NOT "${prefix_override}" STREQUAL "") + list(APPEND deploy_paths "${empty_placeholder}") + else() + # Careful how we check whether this property is set. Projects might + # use a resource alias that matches one of CMake's false constants, + # so we must use get_property(), not get_source_file_property(), + # then compare the result with an empty string. + get_property(alias + SOURCE ${abs_file} ${scope_option} PROPERTY QT_RESOURCE_ALIAS) + if(NOT "${alias}" STREQUAL "") + list(APPEND deploy_paths "${alias}") + else() + file(RELATIVE_PATH rel_file ${target_source_dir} ${abs_file}) + list(APPEND deploy_paths "${rel_file}") + endif() + endif() + endforeach() + string(REPLACE "${empty_placeholder}" "" deploy_paths "${deploy_paths}") + string(REPLACE "${empty_placeholder}" "" prefix_overrides "${prefix_overrides}") + if(arg_${file_set}_DEPLOY_PATHS) + set(${arg_${file_set}_DEPLOY_PATHS} "${deploy_paths}" PARENT_SCOPE) + endif() + if(arg_${file_set}_PREFIX_OVERRIDES) + set(${arg_${file_set}_PREFIX_OVERRIDES} "${prefix_overrides}" PARENT_SCOPE) + endif() + endif() + endforeach() +endfunction() + +if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) + macro(qt_query_qml_module) + qt6_query_qml_module(${ARGV}) + endmacro() +endif() + + +function(_qt_internal_add_static_qml_plugin_dependencies plugin_target backing_target) + # Protect against multiple calls of qt_add_qml_plugin. + get_target_property(plugin_deps_added "${plugin_target}" _qt_extra_static_qml_plugin_deps_added) + if(plugin_deps_added) + return() + endif() + set_target_properties("${plugin_target}" PROPERTIES _qt_extra_static_qml_plugin_deps_added TRUE) + + # Get the install plugin target name, which we will need for filtering later on. + if(TARGET "${backing_target}") + get_target_property(installed_plugin_target + "${backing_target}" _qt_qml_module_installed_plugin_target) + endif() + + if(NOT backing_target STREQUAL plugin_target AND TARGET "${backing_target}") + set(has_backing_lib TRUE) + else() + set(has_backing_lib FALSE) + endif() + + get_target_property(plugin_type ${plugin_target} TYPE) + set(skip_prl_marker "$") + + # If ${plugin_target} is a static qml plugin, recursively get its private dependencies (and its + # backing lib private deps), identify which of those are qml modules, extract any associated qml + # plugin target from those qml modules and make them dependencies of ${plugin_target}. + # + # E.g. this ensures that if a user project links directly to the static qtquick2plugin plugin + # target (note the plugin target, not the backing lib) it will automatically also link to + # Quick's transitive plugin dependencies: qmlplugin, modelsplugin and workerscriptplugin, in + # addition to the the Qml, QmlModels and QmlWorkerScript backing libraries. + # + # Note this logic is not specific to qtquick2plugin, it applies to all static qml plugins. + # + # This eliminates the needed boilerplate to link to the full transitive closure of qml plugins + # in user projects that don't want to use qmlimportscanner / qt_import_qml_plugins. + set(additional_plugin_deps "") + + if(plugin_type STREQUAL "STATIC_LIBRARY") + set(all_private_deps "") + + # We walk both plugin_target and backing_lib private deps because they can have differing + # dependencies and we want to consider all of them. + __qt_internal_collect_all_target_dependencies( + "${plugin_target}" plugin_private_deps) + if(plugin_private_deps) + list(APPEND all_private_deps ${plugin_private_deps}) + endif() + + if(has_backing_lib) + __qt_internal_collect_all_target_dependencies( + "${backing_target}" backing_lib_private_deps) + if(backing_lib_private_deps) + list(APPEND all_private_deps ${backing_lib_private_deps}) + endif() + endif() + + foreach(dep IN LISTS all_private_deps) + if(NOT TARGET "${dep}") + continue() + endif() + get_target_property(dep_type ${dep} TYPE) + if(dep_type STREQUAL "STATIC_LIBRARY") + set(associated_qml_plugin "") + + # Check if the target has an associated imported qml plugin (like a Qt-provided + # one). + get_target_property(associated_qml_plugin_candidate ${dep} + _qt_qml_module_installed_plugin_target) + + if(associated_qml_plugin_candidate AND TARGET "${associated_qml_plugin_candidate}") + set(associated_qml_plugin "${associated_qml_plugin_candidate}") + endif() + + # Check if the target has an associated qml plugin that's built as part of the + # current project (non-installed one, so without a target namespace prefix). + get_target_property(associated_qml_plugin_candidate ${dep} + _qt_qml_module_plugin_target) + + if(NOT associated_qml_plugin AND + associated_qml_plugin_candidate + AND TARGET "${associated_qml_plugin_candidate}") + set(associated_qml_plugin "${associated_qml_plugin_candidate}") + endif() + + # We need to filter out adding the plugin_target as a dependency to itself, + # when walking the backing lib of the plugin_target. + if(associated_qml_plugin + AND NOT associated_qml_plugin STREQUAL plugin_target + AND NOT associated_qml_plugin STREQUAL installed_plugin_target) + # Abuse a genex marker, to skip the dependency to be added into prl files. + # TODO: Introduce a more generic marker name in qtbase specifically + # for skipping deps in prl file deps generation. + set(wrapped_associated_qml_plugin + "$<${skip_prl_marker}:$>") + + if(NOT wrapped_associated_qml_plugin IN_LIST additional_plugin_deps) + list(APPEND additional_plugin_deps "${wrapped_associated_qml_plugin}") + endif() + endif() + endif() + endforeach() + endif() + + if(additional_plugin_deps) + target_link_libraries(${plugin_target} PRIVATE ${additional_plugin_deps}) + endif() +endfunction() + +# The function returns the output name of a qml plugin that will be used as library output +# name and in a qmldir file as the 'plugin ' record. +function(_qt_internal_get_qml_plugin_output_name out_var plugin_target) + cmake_parse_arguments(arg + "" + "BACKING_TARGET;TARGET_PATH;URI" + "" + ${ARGN} + ) + set(plugin_name) + if(TARGET ${plugin_target}) + get_target_property(plugin_name ${plugin_target} OUTPUT_NAME) + endif() + if(NOT plugin_name) + set(plugin_name "${plugin_target}") + endif() + + if(ANDROID) + # In Android all plugins are stored in directly the /libs directory. This means that plugin + # names must be unique in scope of apk. To make this work we prepend uri-based prefix to + # each qml plugin in case if users don't use the manually written qmldir files. + get_target_property(no_generate_qmldir ${target} QT_QML_MODULE_NO_GENERATE_QMLDIR) + if(TARGET "${arg_BACKING_TARGET}") + get_target_property(no_generate_qmldir ${arg_BACKING_TARGET} + QT_QML_MODULE_NO_GENERATE_QMLDIR) + + # Adjust Qml plugin names on Android similar to qml_plugin.prf which calls + # $$qt5LibraryTarget($$TARGET, "qml/$$TARGETPATH/"). + # Example plugin names: + # qtdeclarative + # TARGET_PATH: QtQml/Models + # file name: libqml_QtQml_Models_modelsplugin_x86_64.so + # qtquickcontrols2 + # TARGET_PATH: QtQuick/Controls.2/Material + # file name: + # libqml_QtQuick_Controls.2_Material_qtquickcontrols2materialstyleplugin_x86_64.so + if(NOT arg_TARGET_PATH) + get_target_property(arg_TARGET_PATH ${arg_BACKING_TARGET} + QT_QML_MODULE_TARGET_PATH) + endif() + endif() + if(arg_TARGET_PATH) + string(REPLACE "/" "_" android_plugin_name_infix_name "${arg_TARGET_PATH}") + else() + string(REPLACE "." "_" android_plugin_name_infix_name "${arg_URI}") + endif() + + # If plugin supposed to use manually written qmldir file we don't prepend the uri-based + # prefix to the plugin output name. User should keep the file name of a QML plugin in + # qmldir the same as the name of plugin on a file system. Exception is the + # ABI-/platform-specific suffix that has the separate processing and should not be + # a part of plugin name in qmldir. + if(NOT no_generate_qmldir) + set(plugin_name + "qml_${android_plugin_name_infix_name}_${plugin_name}") + endif() + endif() + + set(${out_var} "${plugin_name}" PARENT_SCOPE) +endfunction() + +# Used to add extra dependencies between ${target} and ${dep_target} qml plugins in a static +# Qt build, without creating a dependency in the genereated qmake .prl files. +# These dependencies make manual linking to static plugins a nicer experience for users that don't +# want to use qt_import_qml_plugins. +function(_qt_internal_add_qml_static_plugin_dependency target dep_target) + if(NOT BUILD_SHARED_LIBS) + # Abuse a genex marker, to skip the dependency to be added into prl files. + # TODO: Introduce a more generic marker name in qtbase specifically + # for skipping deps in prl file deps generation. + set(skip_prl_marker "$") + target_link_libraries("${target}" PRIVATE + "$<${skip_prl_marker}:$>") + endif() +endfunction() + +function(_qt_internal_collect_qml_module_dependencies target) + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.19.0") + string(JOIN " " collect_qml_module_dependencies_code + "cmake_language(DEFER DIRECTORY \"${CMAKE_BINARY_DIR}\"" + "CALL _qt_internal_collect_qml_module_dependencies_deferred \"${target}\")" + ) + cmake_language(EVAL CODE "${collect_qml_module_dependencies_code}") + else() + _qt_internal_collect_qml_module_dependencies_deferred("${target}") + endif() +endfunction() + +function(_qt_internal_collect_qml_module_dependencies_deferred target) + # Add all dependencies that are known as targets first + get_target_property(dep_targets ${target} QT_QML_DEPENDENT_QML_MODULE_TARGETS) + set(known_dep_ids "") + if(dep_targets) + foreach(dep_target IN LISTS dep_targets) + if(NOT TARGET "${dep_target}") + message(FATAL_ERROR "${dep_target} is listed in" + " QT_QML_DEPENDENT_QML_MODULE_TARGETS property of ${target}, but not a target") + endif() + get_target_property(is_imported ${dep_target} IMPORTED) + if(NOT is_imported) + add_dependencies(${target} ${dep_target}) + qt6_query_qml_module(${dep_target} VERSION dep_target_version URI dep_target_URI) + if(dep_target_version) + list(APPEND known_dep_ids "${dep_target_URI} ${dep_target_version}") + else() + list(APPEND known_dep_ids "${dep_target_URI}") + endif() + endif() + endforeach() + endif() + + # Attempt adding the dependencies that are specified as URI's next. + get_target_property(deps ${target} QT_QML_MODULE_DEPENDENCIES) + if(NOT deps) + return() + endif() + if(known_dep_ids) + list(REMOVE_ITEM deps ${known_dep_ids}) + endif() + foreach(dep IN LISTS deps) + string(REPLACE " " ";" dep "${dep}") + list(GET dep 0 dep_module_uri) + + list(LENGTH dep dep_length) + if(dep_length GREATER_EQUAL 2) + list(GET dep 1 dev_module_version) + if(dev_module_version MATCHES "^[0-9]+\\.[0-9]+$") + set(dev_module_version_arg VERSION "${dev_module_version}") + endif() + endif() + _qt_internal_find_qml_module(dep_module BY_URI "${dep_module_uri}" + ${dev_module_version_arg}) + if(dep_module) + add_dependencies(${target} ${dep_module}) + endif() + endforeach() +endfunction() + +# Function searches the qml module target by the bound 'by' property. +# +# The supported 'by' arguments: +# BY_OUTPUT_DIR - searches the module using the _qt_all_qml_output_dirs GLOBAL property +# BY_URI - searches the module using _qt_all_qml_uris GLOBAL property +# Single value arguments: +# VERSION - look for the exact version or version higher then the VERSION +# EXACT_VERSION - look for the exact version +function(_qt_internal_find_qml_module out_target by filter) + if(NOT by MATCHES "^BY_(URI|OUTPUT_DIR)") + message(FATAL_ERROR "Unknow lookup argument ${by}") + else() + string(TOLOWER "${CMAKE_MATCH_1}" lookup_property) + set(lookup_property "_qt_all_qml_${lookup_property}s") + endif() + + cmake_parse_arguments(arg "" "VERSION;EXACT_VERSION" "" ${ARGN}) + + if(arg_EXACT_VERSION AND arg_VERSION) + message(FATAL_ERROR "Both VERSION and EXACT_VERSION are specified.") + endif() + + get_property(lookup_property_value GLOBAL PROPERTY ${lookup_property}) + set(${out_target} "${out_target}-NOTFOUND") + set(prev_module_version 0) + if(lookup_property_value) + set(index 0) + foreach(lookup_value IN LISTS lookup_property_value) + set(module_index "${index}") + math(EXPR index "${index} + 1") + if(NOT "${lookup_value}" STREQUAL "${filter}") + continue() + endif() + get_property(qml_targets GLOBAL PROPERTY _qt_all_qml_targets) + list(GET qml_targets ${module_index} qml_target) + if(NOT TARGET "${qml_target}") + continue() + endif() + if(NOT arg_VERSION AND NOT arg_EXACT_VERSION) + set(${out_target} "${qml_target}") + break() + endif() + + qt6_query_qml_module("${qml_target}" VERSION module_version) + if(arg_EXACT_VERSION) + if(module_version VERSION_EQUAL arg_EXACT_VERSION) + set(${out_target} "${qml_target}") + break() + endif() + else() + if(prev_module_version VERSION_GREATER module_version AND ${out_target}) + continue() + endif() + set(prev_module_version "${module_version}") + if(module_version VERSION_GREATER_EQUAL arg_VERSION) + set(${out_target} "${qml_target}") + if(module_version VERSION_EQUAL arg_VERSION) + break() + endif() + endif() + endif() + endforeach() + endif() + + set(${out_target} "${${out_target}}" PARENT_SCOPE) +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlModuleDirMappingTemplate.qrc.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlModuleDirMappingTemplate.qrc.in new file mode 100644 index 0000000000000000000000000000000000000000..afccaa0ab68e15e11f01c8fd2865be49e62ea4d5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlModuleDirMappingTemplate.qrc.in @@ -0,0 +1,5 @@ + + +@qt_qml_module_dir_mapping_contents@ + + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPluginTemplate.cpp.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPluginTemplate.cpp.in new file mode 100644 index 0000000000000000000000000000000000000000..058a5c660b256b6c8ba92ccd5b8a7a356c68a951 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPluginTemplate.cpp.in @@ -0,0 +1,22 @@ +// This file is autogenerated by CMake. Do not edit. + +#include +#include + +@qt_qml_plugin_intro@ + +class @qt_qml_plugin_class_name@ : public QQmlEngineExtensionPlugin +{ + Q_OBJECT + Q_PLUGIN_METADATA(IID QQmlEngineExtensionInterface_iid) + +public: + @qt_qml_plugin_class_name@(QObject *parent = nullptr) : QQmlEngineExtensionPlugin(parent) + { +@qt_qml_plugin_constructor_content@ + } +}; + +@qt_qml_plugin_outro@ + +#include "@qt_qml_plugin_moc_include_name@" diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPlugins.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPlugins.cmake new file mode 100644 index 0000000000000000000000000000000000000000..325e6fc1a572c1b7463a60eaa381ecc8ef6cf085 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPlugins.cmake @@ -0,0 +1,76 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +# Qml plugin targets might have dependencies on other qml plugin targets, but the Targets.cmake +# files are included in the order that file(GLOB) returns, which means certain targets that are +# referenced might not have been created yet, and ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE +# might be set to a message saying those targets don't exist. +# +# Postpone checking of which targets don't exist until all Qml PluginConfig.cmake files have been +# included, by including all the files one more time and checking for errors at each step. +# +# TODO: Find a better way to deal with this, perhaps by using find_package() instead of include +# for the Qml PluginConfig.cmake files. + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_QML_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_QML_PLUGIN_INCLUSION OFF) +endif() + +set(__qt_qml_plugins_config_file_list "") +set(__qt_qml_plugins_glob_prefixes "${CMAKE_CURRENT_LIST_DIR}") + +# Allow passing additional prefixes where we will glob for PluginConfig.cmake files. +if(QT_ADDITIONAL_QML_PLUGIN_GLOB_PREFIXES) + foreach(__qt_qml_plugin_glob_prefix IN LISTS QT_ADDITIONAL_QML_PLUGIN_GLOB_PREFIXES) + if(__qt_qml_plugin_glob_prefix) + list(APPEND __qt_qml_plugins_glob_prefixes "${__qt_qml_plugin_glob_prefix}") + endif() + endforeach() +endif() + +list(REMOVE_DUPLICATES __qt_qml_plugins_glob_prefixes) + +foreach(__qt_qml_plugin_glob_prefix IN LISTS __qt_qml_plugins_glob_prefixes) + file(GLOB __qt_qml_plugins_glob_config_file_list + "${__qt_qml_plugin_glob_prefix}/QmlPlugins/Qt6*Config.cmake") + if(__qt_qml_plugins_glob_config_file_list) + list(APPEND __qt_qml_plugins_config_file_list ${__qt_qml_plugins_glob_config_file_list}) + endif() +endforeach() + +if (__qt_qml_plugins_config_file_list AND NOT QT_SKIP_AUTO_QML_PLUGIN_INCLUSION) + # First round of inclusions ensure all qml plugin targets are brought into scope. + foreach(__qt_qml_plugin_config_file ${__qt_qml_plugins_config_file_list}) + include(${__qt_qml_plugin_config_file}) + + # Temporarily unset any failure markers and mark the Qml package as found. + unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) + set(${CMAKE_FIND_PACKAGE_NAME}_FOUND TRUE) + endforeach() + + # For the second round of inclusions, check and bail out early if there are errors. + foreach(__qt_qml_plugin_config_file ${__qt_qml_plugins_config_file_list}) + include(${__qt_qml_plugin_config_file}) + + if(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) + string(APPEND ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE + " +The message was set in ${__qt_qml_plugin_config_file} ") + set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + return() + endif() + endforeach() + +endif() + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_PLUGIN_INCLUSION OFF) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION) + __qt_internal_include_plugin_packages(Qml) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPublicCMakeHelpers.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPublicCMakeHelpers.cmake new file mode 100644 index 0000000000000000000000000000000000000000..18ce2cebb5944206fd302e6af7475be562377397 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlPublicCMakeHelpers.cmake @@ -0,0 +1,20 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Ensures that the provided uri matches the URI requirements. Write the result to the result +# variable. +function(_qt_internal_is_qml_uri_valid result uri) + if("${uri}" MATCHES "^[a-zA-Z].*") + set(${result} TRUE PARENT_SCOPE) + else() + set(${result} FALSE PARENT_SCOPE) + endif() +endfunction() + +# Ensures that the provided uri matches the URI requirements. Errors out if the URI is malformed. +function(_qt_internal_require_qml_uri_valid uri) + _qt_internal_is_qml_uri_valid(ok "${uri}") + if(NOT ok) + message(FATAL_ERROR "URI must start with letter. Please specify a valid URI for ${target}.") + endif() +endfunction() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..66949b6c1d5de42c1fa960b8eadc4e3aefb86fc0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Qml" for configuration "Debug" +set_property(TARGET Qt6::Qml APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::Qml PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6Qmld.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6Qmld.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Qml ) +list(APPEND _cmake_import_check_files_for_Qt6::Qml "${_IMPORT_PREFIX}/lib/Qt6Qmld.lib" "${_IMPORT_PREFIX}/bin/Qt6Qmld.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..096794c8ac60e27605457142caf227bb7cb953a6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::Qml" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::Qml APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::Qml PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6Qml.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6Qml.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::Qml ) +list(APPEND _cmake_import_check_files_for_Qt6::Qml "${_IMPORT_PREFIX}/lib/Qt6Qml.lib" "${_IMPORT_PREFIX}/bin/Qt6Qml.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..04e4b8f91b4676e640e0a7ca6c90b3ff6131e238 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlTargets.cmake @@ -0,0 +1,170 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::Qml Qt6::QmlPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::Qml +add_library(Qt6::Qml SHARED IMPORTED) + +set_target_properties(Qt6::Qml PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_QML_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQml;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::QmlIntegration;Qt6::Network;shell32" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6qml_metatypes.json>" + MODULE_PLUGIN_TYPES "qmltooling" + QT_DISABLED_PRIVATE_FEATURES "" + QT_DISABLED_PUBLIC_FEATURES "" + QT_ENABLED_PRIVATE_FEATURES "qml_jit;qml_profiler;qml_preview;qml_xml_http_request;qml_locale;qml_animation;qml_worker_script;qml_itemmodel;qml_xmllistmodel;qml_python" + QT_ENABLED_PUBLIC_FEATURES "qml_network;qml_ssl;qml_debug" + QT_QMAKE_PRIVATE_CONFIG "" + QT_QMAKE_PUBLIC_CONFIG "" + QT_QMAKE_PUBLIC_QT_CONFIG "" + _qt_config_module_name "qml" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtQml" + _qt_module_interface_name "Qml" + _qt_package_name "Qt6Qml" + _qt_package_version "6.8.1" + _qt_private_module_target_name "QmlPrivate" + _qt_qml_module_installed_plugin_target "" + _qt_qml_module_plugin_target "" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-Qml" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::QmlPrivate +add_library(Qt6::QmlPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::QmlPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQml/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQml/6.8.1/QtQml>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::Qml" + _qt_config_module_name "qml_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6Qml" + _qt_package_version "6.8.1" + _qt_public_module_target_name "Qml" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-Qml" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::QmlIntegration" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..16a9116fbe683df5ab41bf95d6f2939d6f403527 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Qml;QmlPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..77083c48ed98a237d38c46e9be642318da5fe327 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmlVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "Qml;QmlPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmltcFileMappingTemplate.qrc.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmltcFileMappingTemplate.qrc.in new file mode 100644 index 0000000000000000000000000000000000000000..6c037b79bebec77403e15db5ef338c037f5f5731 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6QmltcFileMappingTemplate.qrc.in @@ -0,0 +1,5 @@ + + +@qt_qml_qmltc_file_mapping_contents@ + + diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6qmldirTemplate.cmake.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6qmldirTemplate.cmake.in new file mode 100644 index 0000000000000000000000000000000000000000..b9ecbdebad1efda9af83e63c9130ee59402c3973 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6qmldirTemplate.cmake.in @@ -0,0 +1 @@ +@__qt_qmldir_content@ diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6qt.conf.in b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6qt.conf.in new file mode 100644 index 0000000000000000000000000000000000000000..494430ebc33df19b959b7d29c7c74d31037fbeb9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6Qml/Qt6qt.conf.in @@ -0,0 +1,5 @@ +[Paths] +QmlImports = @qt_all_qml_output_dirs@ + +[Config] +MergeQtConf = true diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..387a3133f036d4692edba137e8ab71dc974a4ecb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderAdditionalTargetInfo.cmake @@ -0,0 +1,72 @@ +# Additional target information for Qt6QmlAssetDownloader +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlAssetDownloader) +get_target_property(_qt_imported_location Qt6::QmlAssetDownloader IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QmlAssetDownloader IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QmlAssetDownloader" for configuration "Release" +set_property(TARGET Qt6::QmlAssetDownloader APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlAssetDownloader PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QmlAssetDownloader" for configuration "MinSizeRel" +set_property(TARGET Qt6::QmlAssetDownloader APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlAssetDownloader PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QmlAssetDownloader PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlAssetDownloaderPrivate) +__qt_internal_promote_target_to_global_checked(Qt6::QmlAssetDownloader_resources_1) +get_target_property(_qt_imported_objects Qt6::QmlAssetDownloader_resources_1 IMPORTED_OBJECTS_RELWITHDEBINFO) +get_target_property(_qt_imported_clr Qt6::QmlAssetDownloader_resources_1 IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO) +get_target_property(_qt_imported_objects_default Qt6::QmlAssetDownloader_resources_1 IMPORTED_OBJECTS_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_clr_default Qt6::QmlAssetDownloader_resources_1 IMPORTED_COMMON_LANGUAGE_RUNTIME_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QmlAssetDownloader_resources_1" for configuration "Release" +set_property(TARGET Qt6::QmlAssetDownloader_resources_1 APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_objects) + set_property(TARGET Qt6::QmlAssetDownloader_resources_1 PROPERTY IMPORTED_OBJECTS_RELEASE "${_qt_imported_objects}") +endif() +if(_qt_imported_clr) + set_property(TARGET Qt6::QmlAssetDownloader_resources_1 PROPERTY IMPORTED_COMMON_LANGUAGE_RUNTIME_RELEASE "${_qt_imported_clr}") +endif() + +# Import target "Qt6::QmlAssetDownloader_resources_1" for configuration "MinSizeRel" +set_property(TARGET Qt6::QmlAssetDownloader_resources_1 APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_objects) + set_property(TARGET Qt6::QmlAssetDownloader_resources_1 PROPERTY IMPORTED_OBJECTS_MINSIZEREL "${_qt_imported_objects}") +endif() +if(_qt_imported_clr) + set_property(TARGET Qt6::QmlAssetDownloader_resources_1 PROPERTY IMPORTED_COMMON_LANGUAGE_RUNTIME_MINSIZEREL "${_qt_imported_clr}") +endif() + +# Default configuration +if(_qt_imported_objects_default) + set_property(TARGET Qt6::QmlAssetDownloader_resources_1 PROPERTY IMPORTED_OBJECTS "${_qt_imported_objects_default}") +endif() +if(_qt_imported_clr_default) + set_property(TARGET Qt6::QmlAssetDownloader_resources_1 PROPERTY IMPORTED_COMMON_LANGUAGE_RUNTIME "${_qt_imported_clr_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..152658c2c4fc8fce6a365846de500f54a7a02bfb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderDependencies.cmake") + _qt_internal_suggest_dependency_debugging(QmlAssetDownloader + __qt_QmlAssetDownloader_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6QmlAssetDownloader_FOUND") + set("Qt6QmlAssetDownloader_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6QmlAssetDownloader_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6QmlAssetDownloader) instead. + set(Qt6QmlAssetDownloader_LIBRARIES "Qt6::QmlAssetDownloader") + + get_target_property(_Qt6QmlAssetDownloader_OWN_INCLUDE_DIRS + Qt6::QmlAssetDownloader INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlAssetDownloader_OWN_INCLUDE_DIRS) + set(_Qt6QmlAssetDownloader_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QmlAssetDownloaderPrivate) + get_target_property(_Qt6QmlAssetDownloader_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QmlAssetDownloaderPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlAssetDownloader_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6QmlAssetDownloader_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6QmlAssetDownloader_DEFINITIONS + Qt6::QmlAssetDownloader INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlAssetDownloader_DEFINITIONS) + set(Qt6QmlAssetDownloader_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6QmlAssetDownloader_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6QmlAssetDownloader_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6QmlAssetDownloader_COMPILE_DEFINITIONS + Qt6::QmlAssetDownloader INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlAssetDownloader_COMPILE_DEFINITIONS) + set(Qt6QmlAssetDownloader_COMPILE_DEFINITIONS "") + endif() + + set(Qt6QmlAssetDownloader_INCLUDE_DIRS + ${_Qt6QmlAssetDownloader_OWN_INCLUDE_DIRS}) + + set(Qt6QmlAssetDownloader_PRIVATE_INCLUDE_DIRS + ${_Qt6QmlAssetDownloader_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6QmlAssetDownloader_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6QmlAssetDownloader${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6QmlAssetDownloader${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6QmlAssetDownloader_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6QmlAssetDownloader${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6QmlAssetDownloader${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6QmlAssetDownloader_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlAssetDownloader_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlAssetDownloader_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6QmlAssetDownloader_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::QmlAssetDownloader) + qt_make_features_available(Qt6::QmlAssetDownloader) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "QmlAssetDownloader") + + get_target_property(_qt_module_target_type "Qt6::QmlAssetDownloader" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::QmlAssetDownloader MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6QmlAssetDownloader_FOUND FALSE) + if(NOT DEFINED Qt6QmlAssetDownloader_NOT_FOUND_MESSAGE) + set(Qt6QmlAssetDownloader_NOT_FOUND_MESSAGE + "Target \"Qt6::QmlAssetDownloader\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6QmlAssetDownloader_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..338e92c3b02788fa90e285c5a4a4633fd14c992d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..71bfff3bae92c2afb0afea1a3d166ab3d7866933 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6QmlAssetDownloader_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_QmlAssetDownloader_third_party_deps "") + +_qt_internal_find_third_party_dependencies("QmlAssetDownloader" __qt_QmlAssetDownloader_third_party_deps) + +# Find Qt tool package. +set(__qt_QmlAssetDownloader_tool_deps "") +_qt_internal_find_tool_dependencies("QmlAssetDownloader" __qt_QmlAssetDownloader_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_QmlAssetDownloader_target_deps "Qt6Qml\;6.8.1;Qt6ExamplesAssetDownloaderPrivate\;6.8.1") +set(__qt_QmlAssetDownloader_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("QmlAssetDownloader" __qt_QmlAssetDownloader_target_deps + __qt_QmlAssetDownloader_find_dependency_paths) + +set(_Qt6QmlAssetDownloader_MODULE_DEPENDENCIES "Qml;ExamplesAssetDownloaderPrivate") +set(Qt6QmlAssetDownloader_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dfbc93e17cb4b0918bc87e66ecfbcb23181c57e6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets-debug.cmake @@ -0,0 +1,29 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlAssetDownloader" for configuration "Debug" +set_property(TARGET Qt6::QmlAssetDownloader APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QmlAssetDownloader PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6QmlAssetDownloaderd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlAssetDownloader ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlAssetDownloader "${_IMPORT_PREFIX}/lib/Qt6QmlAssetDownloaderd.lib" ) + +# Import target "Qt6::QmlAssetDownloader_resources_1" for configuration "Debug" +set_property(TARGET Qt6::QmlAssetDownloader_resources_1 APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QmlAssetDownloader_resources_1 PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_OBJECTS_DEBUG "${_IMPORT_PREFIX}/qml/Assets/Downloader/objects-Debug/QmlAssetDownloader_resources_1/.qt/rcc/qrc_qmake_Assets_Downloader_init.cpp.obj" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlAssetDownloader_resources_1 ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlAssetDownloader_resources_1 "${_IMPORT_PREFIX}/qml/Assets/Downloader/objects-Debug/QmlAssetDownloader_resources_1/.qt/rcc/qrc_qmake_Assets_Downloader_init.cpp.obj" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..35931521b8d410a56d3c662d45ba5031b4283588 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets-relwithdebinfo.cmake @@ -0,0 +1,29 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlAssetDownloader" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QmlAssetDownloader APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QmlAssetDownloader PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6QmlAssetDownloader.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlAssetDownloader ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlAssetDownloader "${_IMPORT_PREFIX}/lib/Qt6QmlAssetDownloader.lib" ) + +# Import target "Qt6::QmlAssetDownloader_resources_1" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QmlAssetDownloader_resources_1 APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QmlAssetDownloader_resources_1 PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_OBJECTS_RELWITHDEBINFO "${_IMPORT_PREFIX}/qml/Assets/Downloader/objects-RelWithDebInfo/QmlAssetDownloader_resources_1/.qt/rcc/qrc_qmake_Assets_Downloader_init.cpp.obj" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlAssetDownloader_resources_1 ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlAssetDownloader_resources_1 "${_IMPORT_PREFIX}/qml/Assets/Downloader/objects-RelWithDebInfo/QmlAssetDownloader_resources_1/.qt/rcc/qrc_qmake_Assets_Downloader_init.cpp.obj" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5e46ac9e15fe18a318eb784beb81f8a9d57a726f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderTargets.cmake @@ -0,0 +1,170 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QmlAssetDownloader Qt6::QmlAssetDownloaderPrivate Qt6::QmlAssetDownloader_resources_1) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QmlAssetDownloader +add_library(Qt6::QmlAssetDownloader STATIC IMPORTED) + +set_target_properties(Qt6::QmlAssetDownloader PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_QMLASSETDOWNLOADER_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQmlAssetDownloader;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "\$;\$;\$;\$;\$<\$,STATIC_LIBRARY>>,\$>>,\$>>,\$>:\$>;Qt6::QmlAssetDownloader_resources_1" + INTERFACE_LINK_OPTIONS "\$<\$,STATIC_LIBRARY>>,\$>,\$>>,\$>:\$>" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6qmlassetdownloader_metatypes.json>;\$<\$,STATIC_LIBRARY>>,\$>,\$>>>,\$>>,\$>:\$>" + _qt_config_module_name "qmlassetdownloader" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_include_name "QtQmlAssetDownloader" + _qt_module_interface_name "QmlAssetDownloader" + _qt_package_name "Qt6QmlAssetDownloader" + _qt_package_version "6.8.1" + _qt_private_module_target_name "QmlAssetDownloaderPrivate" + _qt_qml_module_installed_plugin_target "Qt6::QmlAssetDownloaderplugin" + _qt_qml_module_plugin_target "QmlAssetDownloaderplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-QmlAssetDownloader" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::QmlAssetDownloaderPrivate +add_library(Qt6::QmlAssetDownloaderPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::QmlAssetDownloaderPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlAssetDownloader/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlAssetDownloader/6.8.1/QtQmlAssetDownloader>" + INTERFACE_LINK_LIBRARIES "Qt6::QmlAssetDownloader" + _qt_config_module_name "qmlassetdownloader_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6QmlAssetDownloader" + _qt_package_version "6.8.1" + _qt_public_module_target_name "QmlAssetDownloader" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-QmlAssetDownloader" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::QmlAssetDownloader_resources_1 +add_library(Qt6::QmlAssetDownloader_resources_1 OBJECT IMPORTED) + +set_target_properties(Qt6::QmlAssetDownloader_resources_1 PROPERTIES + INTERFACE_LINK_LIBRARIES "Qt6::Core;\$;\$" + _is_qt_propagated_object_library "TRUE" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlAssetDownloaderTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Qml" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..236d6ec1df4500579c826c04cec5d325ddaf6e20 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlAssetDownloader;QmlAssetDownloaderPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8ca4a7be4c2c6152367badddb55072f73010b4f1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlAssetDownloader/Qt6QmlAssetDownloaderVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlAssetDownloader;QmlAssetDownloaderPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..279244acedf3fa002bed1a2991215f6d320c9315 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6QmlCompiler +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlCompiler) +get_target_property(_qt_imported_location Qt6::QmlCompiler IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::QmlCompiler IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::QmlCompiler IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QmlCompiler IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::QmlCompiler IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::QmlCompiler IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QmlCompiler" for configuration "Release" +set_property(TARGET Qt6::QmlCompiler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::QmlCompiler" for configuration "MinSizeRel" +set_property(TARGET Qt6::QmlCompiler APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::QmlCompiler PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlCompilerPrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3290d1fe7531832f30ac18becde26e00f030ee23 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerDependencies.cmake") + _qt_internal_suggest_dependency_debugging(QmlCompiler + __qt_QmlCompiler_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6QmlCompiler_FOUND") + set("Qt6QmlCompiler_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6QmlCompiler_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6QmlCompiler) instead. + set(Qt6QmlCompiler_LIBRARIES "Qt6::QmlCompiler") + + get_target_property(_Qt6QmlCompiler_OWN_INCLUDE_DIRS + Qt6::QmlCompiler INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlCompiler_OWN_INCLUDE_DIRS) + set(_Qt6QmlCompiler_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QmlCompilerPrivate) + get_target_property(_Qt6QmlCompiler_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QmlCompilerPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlCompiler_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6QmlCompiler_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6QmlCompiler_DEFINITIONS + Qt6::QmlCompiler INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlCompiler_DEFINITIONS) + set(Qt6QmlCompiler_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6QmlCompiler_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6QmlCompiler_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6QmlCompiler_COMPILE_DEFINITIONS + Qt6::QmlCompiler INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlCompiler_COMPILE_DEFINITIONS) + set(Qt6QmlCompiler_COMPILE_DEFINITIONS "") + endif() + + set(Qt6QmlCompiler_INCLUDE_DIRS + ${_Qt6QmlCompiler_OWN_INCLUDE_DIRS}) + + set(Qt6QmlCompiler_PRIVATE_INCLUDE_DIRS + ${_Qt6QmlCompiler_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6QmlCompiler_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6QmlCompiler${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6QmlCompiler${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6QmlCompiler_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6QmlCompiler${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6QmlCompiler${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6QmlCompiler_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlCompiler_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlCompiler_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6QmlCompiler_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::QmlCompiler) + qt_make_features_available(Qt6::QmlCompiler) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerPlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerPlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "QmlCompiler") + + get_target_property(_qt_module_target_type "Qt6::QmlCompiler" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::QmlCompiler MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6QmlCompiler_FOUND FALSE) + if(NOT DEFINED Qt6QmlCompiler_NOT_FOUND_MESSAGE) + set(Qt6QmlCompiler_NOT_FOUND_MESSAGE + "Target \"Qt6::QmlCompiler\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6QmlCompiler_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9bb8cac5a4b749921a65926eb5dedf35361311f9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..27be6fdfa4518fd7074d8c1411061762e64aa6a3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6QmlCompiler_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_QmlCompiler_third_party_deps "") + +_qt_internal_find_third_party_dependencies("QmlCompiler" __qt_QmlCompiler_third_party_deps) + +# Find Qt tool package. +set(__qt_QmlCompiler_tool_deps "") +_qt_internal_find_tool_dependencies("QmlCompiler" __qt_QmlCompiler_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_QmlCompiler_target_deps "Qt6Core\;6.8.1;Qt6Qml\;6.8.1;Qt6QmlToolingSettingsPrivate\;6.8.1") +set(__qt_QmlCompiler_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("QmlCompiler" __qt_QmlCompiler_target_deps + __qt_QmlCompiler_find_dependency_paths) + +set(_Qt6QmlCompiler_MODULE_DEPENDENCIES "Core;Qml;QmlToolingSettingsPrivate") +set(Qt6QmlCompiler_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerPlugins.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerPlugins.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3c29b62d02bbf24d0a174676446687e8757376dc --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerPlugins.cmake @@ -0,0 +1,14 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + + +# Distributions should probably change this default. +if(NOT DEFINED QT_SKIP_AUTO_PLUGIN_INCLUSION) + set(QT_SKIP_AUTO_PLUGIN_INCLUSION OFF) +endif() + +if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION) + __qt_internal_include_plugin_packages(QmlCompiler) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..09561042cb7d07b2d67be97ab4bb7e49320a80f9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlCompiler" for configuration "Debug" +set_property(TARGET Qt6::QmlCompiler APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QmlCompiler PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6QmlCompilerd.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6QmlCompilerd.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlCompiler ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlCompiler "${_IMPORT_PREFIX}/lib/Qt6QmlCompilerd.lib" "${_IMPORT_PREFIX}/bin/Qt6QmlCompilerd.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..205d902db7e2a91d8ce0d894d5d39f92f2ee7436 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlCompiler" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QmlCompiler APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QmlCompiler PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6QmlCompiler.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6QmlCompiler.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlCompiler ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlCompiler "${_IMPORT_PREFIX}/lib/Qt6QmlCompiler.lib" "${_IMPORT_PREFIX}/bin/Qt6QmlCompiler.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dcf39a221d74b052bc35882cde37b50982c5afeb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerTargets.cmake @@ -0,0 +1,161 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QmlCompiler Qt6::QmlCompilerPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QmlCompiler +add_library(Qt6::QmlCompiler SHARED IMPORTED) + +set_target_properties(Qt6::QmlCompiler PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_QMLCOMPILER_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQmlCompiler;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::Qml" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6qmlcompiler_metatypes.json>" + MODULE_PLUGIN_TYPES "qmllint" + _qt_config_module_name "qmlcompiler" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtQmlCompiler" + _qt_module_interface_name "QmlCompiler" + _qt_package_name "Qt6QmlCompiler" + _qt_package_version "6.8.1" + _qt_private_module_target_name "QmlCompilerPrivate" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-QmlCompiler" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::QmlCompilerPrivate +add_library(Qt6::QmlCompilerPrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::QmlCompilerPrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlCompiler/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlCompiler/6.8.1/QtQmlCompiler>" + INTERFACE_LINK_LIBRARIES "Qt6::QmlPrivate;Qt6::QmlToolingSettingsPrivate;Qt6::QmlCompiler" + _qt_config_module_name "qmlcompiler_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6QmlCompiler" + _qt_package_version "6.8.1" + _qt_public_module_target_name "QmlCompiler" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-QmlCompiler" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCompilerTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Qml" "Qt6::QmlPrivate" "Qt6::QmlToolingSettingsPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..943e6b47a5e98ced10352d01a32ca0f83474a576 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlCompiler;QmlCompilerPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ddf1adb01661a062e8e497fbfeab51b05d2696b8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlCompilerVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlCompiler;QmlCompilerPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f8ee91f651489eb9f7e41278129e54fb3fe479ea --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QmlLintQuickPlugin +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlLintQuickPlugin) +get_target_property(_qt_imported_location Qt6::QmlLintQuickPlugin IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QmlLintQuickPlugin IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QmlLintQuickPlugin" for configuration "Release" +set_property(TARGET Qt6::QmlLintQuickPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlLintQuickPlugin PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QmlLintQuickPlugin" for configuration "MinSizeRel" +set_property(TARGET Qt6::QmlLintQuickPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlLintQuickPlugin PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QmlLintQuickPlugin PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..db0b98cf112d6b5d0aa33d1a41f6c90012a796b2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfig.cmake @@ -0,0 +1,58 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +include_guard(DIRECTORY) + +if(DEFINED QT_REPO_DEPENDENCIES + AND NOT QT_INTERNAL_BUILD_STANDALONE_PARTS + AND NOT QT_BUILD_STANDALONE_TESTS) + # We're building a Qt repository. + # Skip this plugin if it has not been provided by one of this repo's dependencies. + string(TOLOWER "QtDeclarative" lower_case_project_name) + if(NOT lower_case_project_name IN_LIST QT_REPO_DEPENDENCIES) + return() + endif() +endif() + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtPluginConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +if (NOT QT_NO_CREATE_TARGETS) + # Find required dependencies, if any. + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlLintQuickPluginDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlLintQuickPluginDependencies.cmake") + endif() + + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlLintQuickPluginTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlLintQuickPluginAdditionalTargetInfo.cmake") +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..91ffc308c465862d9c507974e1ca44e1cd1f06ce --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlLintQuickPluginConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..388be089944fb54eefb89580655bd3ade38fc30c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlLintQuickPlugin" for configuration "Debug" +set_property(TARGET Qt6::QmlLintQuickPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QmlLintQuickPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_DEBUG "" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/plugins/qmllint/quicklintplugind.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlLintQuickPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlLintQuickPlugin "${_IMPORT_PREFIX}/plugins/qmllint/quicklintplugind.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c7531b90eeb59945d5f10807dec0b83287b04181 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlLintQuickPlugin" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QmlLintQuickPlugin APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QmlLintQuickPlugin PROPERTIES + IMPORTED_COMMON_LANGUAGE_RUNTIME_RELWITHDEBINFO "" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/plugins/qmllint/quicklintplugin.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlLintQuickPlugin ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlLintQuickPlugin "${_IMPORT_PREFIX}/plugins/qmllint/quicklintplugin.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..71fd7249fb04610c61d33df4565b18e9a24ec972 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCompiler/Qt6QmlLintQuickPluginTargets.cmake @@ -0,0 +1,118 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QmlLintQuickPlugin) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QmlLintQuickPlugin +add_library(Qt6::QmlLintQuickPlugin MODULE IMPORTED) + +set_target_properties(Qt6::QmlLintQuickPlugin PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_QT_MAJOR_VERSION "6" + QT_DEFAULT_PLUGIN "1" + QT_MODULE "QmlCompiler" + QT_PLUGIN_CLASS_NAME "QmlLintQuickPlugin" + QT_PLUGIN_TYPE "qmllint" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-plugin-QmlLintQuickPlugin" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlLintQuickPluginTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2a14ad3d6e68fced0dfd46d3d4fe76cc3fd7b360 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreAdditionalTargetInfo.cmake @@ -0,0 +1,61 @@ +# Additional target information for Qt6QmlCore +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlCore) +get_target_property(_qt_imported_location Qt6::QmlCore IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_implib Qt6::QmlCore IMPORTED_IMPLIB_RELWITHDEBINFO) +get_target_property(_qt_imported_link_dependencies Qt6::QmlCore IMPORTED_LINK_DEPENDENT_LIBRARIES_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QmlCore IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_implib_default Qt6::QmlCore IMPORTED_IMPLIB_${QT_DEFAULT_IMPORT_CONFIGURATION}) +get_target_property(_qt_imported_link_dependencies_default Qt6::QmlCore IMPORTED_LINK_DEPENDENT_LIBRARIES_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QmlCore" for configuration "Release" +set_property(TARGET Qt6::QmlCore APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_IMPLIB_RELEASE "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "${_qt_imported_link_dependencies}") +endif() + +# Import target "Qt6::QmlCore" for configuration "MinSizeRel" +set_property(TARGET Qt6::QmlCore APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() +if(_qt_imported_implib) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_IMPLIB_MINSIZEREL "${_qt_imported_implib}") +endif() +if(_qt_imported_link_dependencies) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_MINSIZEREL "${_qt_imported_link_dependencies}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() +if(_qt_imported_implib_default) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_IMPLIB "${_qt_imported_implib_default}") +endif() +if(_qt_imported_link_dependencies_default) + set_property(TARGET Qt6::QmlCore PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES "${_qt_imported_link_dependencies_default}") +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlCorePrivate) + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..39a0531e6cce1bd435d54060bc5b959ae0aa68f2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreDependencies.cmake") + _qt_internal_suggest_dependency_debugging(QmlCore + __qt_QmlCore_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6QmlCore_FOUND") + set("Qt6QmlCore_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6QmlCore_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6QmlCore) instead. + set(Qt6QmlCore_LIBRARIES "Qt6::QmlCore") + + get_target_property(_Qt6QmlCore_OWN_INCLUDE_DIRS + Qt6::QmlCore INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlCore_OWN_INCLUDE_DIRS) + set(_Qt6QmlCore_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QmlCorePrivate) + get_target_property(_Qt6QmlCore_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QmlCorePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlCore_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6QmlCore_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6QmlCore_DEFINITIONS + Qt6::QmlCore INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlCore_DEFINITIONS) + set(Qt6QmlCore_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6QmlCore_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6QmlCore_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6QmlCore_COMPILE_DEFINITIONS + Qt6::QmlCore INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlCore_COMPILE_DEFINITIONS) + set(Qt6QmlCore_COMPILE_DEFINITIONS "") + endif() + + set(Qt6QmlCore_INCLUDE_DIRS + ${_Qt6QmlCore_OWN_INCLUDE_DIRS}) + + set(Qt6QmlCore_PRIVATE_INCLUDE_DIRS + ${_Qt6QmlCore_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6QmlCore_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6QmlCore${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6QmlCore${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6QmlCore_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6QmlCore${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6QmlCore${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6QmlCore_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlCore_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlCore_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6QmlCore_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::QmlCore) + qt_make_features_available(Qt6::QmlCore) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCorePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCorePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "QmlCore") + + get_target_property(_qt_module_target_type "Qt6::QmlCore" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::QmlCore MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6QmlCore_FOUND FALSE) + if(NOT DEFINED Qt6QmlCore_NOT_FOUND_MESSAGE) + set(Qt6QmlCore_NOT_FOUND_MESSAGE + "Target \"Qt6::QmlCore\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6QmlCore_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..efeb0de056eb99e77684f00e2c6414e4d5713e4f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1a9d4e88da9cde29ae3059174b881cf69b373d63 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6QmlCore_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_QmlCore_third_party_deps "") + +_qt_internal_find_third_party_dependencies("QmlCore" __qt_QmlCore_third_party_deps) + +# Find Qt tool package. +set(__qt_QmlCore_tool_deps "") +_qt_internal_find_tool_dependencies("QmlCore" __qt_QmlCore_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_QmlCore_target_deps "Qt6Core\;6.8.1;Qt6Qml\;6.8.1") +set(__qt_QmlCore_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("QmlCore" __qt_QmlCore_target_deps + __qt_QmlCore_find_dependency_paths) + +set(_Qt6QmlCore_MODULE_DEPENDENCIES "Core;Qml") +set(Qt6QmlCore_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7355d95b91345113a2a2590917be110b106b6eb7 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlCore" for configuration "Debug" +set_property(TARGET Qt6::QmlCore APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QmlCore PROPERTIES + IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/Qt6QmlCored.lib" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/Qt6QmlCored.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlCore ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlCore "${_IMPORT_PREFIX}/lib/Qt6QmlCored.lib" "${_IMPORT_PREFIX}/bin/Qt6QmlCored.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b4563992a6fc05289b75b24644a8e18eb3485c1e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlCore" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QmlCore APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QmlCore PROPERTIES + IMPORTED_IMPLIB_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6QmlCore.lib" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/bin/Qt6QmlCore.dll" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlCore ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlCore "${_IMPORT_PREFIX}/lib/Qt6QmlCore.lib" "${_IMPORT_PREFIX}/bin/Qt6QmlCore.dll" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ec1654d8c372db648f8adb507d0feff13a810ffe --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreTargets.cmake @@ -0,0 +1,162 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QmlCore Qt6::QmlCorePrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QmlCore +add_library(Qt6::QmlCore SHARED IMPORTED) + +set_target_properties(Qt6::QmlCore PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_QMLCORE_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQmlCore;${_IMPORT_PREFIX}/include" + INTERFACE_LINK_LIBRARIES "Qt6::Core;Qt6::Qml" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6qmlcore_metatypes.json>" + _qt_config_module_name "qmlcore" + _qt_is_internal_library "TRUE" + _qt_is_internal_target "TRUE" + _qt_is_public_module "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtQmlCore" + _qt_module_interface_name "QmlCore" + _qt_package_name "Qt6QmlCore" + _qt_package_version "6.8.1" + _qt_private_module_target_name "QmlCorePrivate" + _qt_qml_module_installed_plugin_target "Qt6::qtqmlcoreplugin" + _qt_qml_module_plugin_target "qtqmlcoreplugin" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-QmlCore" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Create imported target Qt6::QmlCorePrivate +add_library(Qt6::QmlCorePrivate INTERFACE IMPORTED) + +set_target_properties(Qt6::QmlCorePrivate PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlCore/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlCore/6.8.1/QtQmlCore>" + INTERFACE_LINK_LIBRARIES "Qt6::QmlCore" + _qt_config_module_name "qmlcore_private" + _qt_is_private_module "TRUE" + _qt_package_name "Qt6QmlCore" + _qt_package_version "6.8.1" + _qt_public_module_target_name "QmlCore" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-QmlCore" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlCoreTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::Qml" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..84fb11eab28e9b2c7f002fb87349601c29ec3c29 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlCore;QmlCorePrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d6bbea7f280b8e174da7f48ebd66004579793668 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlCore/Qt6QmlCoreVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlCore;QmlCorePrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..dae32fc24f93c1d17471d36af045044273b79a97 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QmlDebugPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlDebugPrivate) +get_target_property(_qt_imported_location Qt6::QmlDebugPrivate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QmlDebugPrivate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QmlDebugPrivate" for configuration "Release" +set_property(TARGET Qt6::QmlDebugPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlDebugPrivate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QmlDebugPrivate" for configuration "MinSizeRel" +set_property(TARGET Qt6::QmlDebugPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlDebugPrivate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QmlDebugPrivate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cb63167b4f75a0f9b349b5c954a466239f56ce3f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(QmlDebugPrivate + __qt_QmlDebugPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6QmlDebugPrivate_FOUND") + set("Qt6QmlDebugPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6QmlDebugPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6QmlDebugPrivate) instead. + set(Qt6QmlDebugPrivate_LIBRARIES "Qt6::QmlDebugPrivate") + + get_target_property(_Qt6QmlDebugPrivate_OWN_INCLUDE_DIRS + Qt6::QmlDebugPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlDebugPrivate_OWN_INCLUDE_DIRS) + set(_Qt6QmlDebugPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QmlDebugPrivatePrivate) + get_target_property(_Qt6QmlDebugPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QmlDebugPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlDebugPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6QmlDebugPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6QmlDebugPrivate_DEFINITIONS + Qt6::QmlDebugPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlDebugPrivate_DEFINITIONS) + set(Qt6QmlDebugPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6QmlDebugPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6QmlDebugPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6QmlDebugPrivate_COMPILE_DEFINITIONS + Qt6::QmlDebugPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlDebugPrivate_COMPILE_DEFINITIONS) + set(Qt6QmlDebugPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6QmlDebugPrivate_INCLUDE_DIRS + ${_Qt6QmlDebugPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6QmlDebugPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6QmlDebugPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6QmlDebugPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6QmlDebugPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6QmlDebugPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6QmlDebugPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6QmlDebugPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6QmlDebugPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6QmlDebugPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlDebugPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlDebugPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6QmlDebugPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::QmlDebugPrivate) + qt_make_features_available(Qt6::QmlDebugPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "QmlDebugPrivate") + + get_target_property(_qt_module_target_type "Qt6::QmlDebugPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::QmlDebugPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6QmlDebugPrivate_FOUND FALSE) + if(NOT DEFINED Qt6QmlDebugPrivate_NOT_FOUND_MESSAGE) + set(Qt6QmlDebugPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::QmlDebugPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6QmlDebugPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..ab3e7108ea92daf55c233b2680aa2b346316a2df --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fee5ef4c73cb2ef75152da2cb582a0b993173f88 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6QmlDebugPrivate_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_QmlDebugPrivate_third_party_deps "") + +_qt_internal_find_third_party_dependencies("QmlDebugPrivate" __qt_QmlDebugPrivate_third_party_deps) + +# Find Qt tool package. +set(__qt_QmlDebugPrivate_tool_deps "") +_qt_internal_find_tool_dependencies("QmlDebugPrivate" __qt_QmlDebugPrivate_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_QmlDebugPrivate_target_deps "Qt6Core\;6.8.1;Qt6Network\;6.8.1;Qt6PacketProtocolPrivate\;6.8.1;Qt6Qml\;6.8.1") +set(__qt_QmlDebugPrivate_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("QmlDebugPrivate" __qt_QmlDebugPrivate_target_deps + __qt_QmlDebugPrivate_find_dependency_paths) + +set(_Qt6QmlDebugPrivate_MODULE_DEPENDENCIES "Core;Network;PacketProtocolPrivate;Qml") +set(Qt6QmlDebugPrivate_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2950bca6990b72f38d5717dbb530ee03df8fcedb --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlDebugPrivate" for configuration "Debug" +set_property(TARGET Qt6::QmlDebugPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QmlDebugPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6QmlDebugd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlDebugPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlDebugPrivate "${_IMPORT_PREFIX}/lib/Qt6QmlDebugd.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f69193dc4e93529cd970483a8476a7cd63a6f6c9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlDebugPrivate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QmlDebugPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QmlDebugPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6QmlDebug.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlDebugPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlDebugPrivate "${_IMPORT_PREFIX}/lib/Qt6QmlDebug.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f9a462ab3a3f49ab744f6989407ca667a46eb542 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateTargets.cmake @@ -0,0 +1,141 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QmlDebugPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QmlDebugPrivate +add_library(Qt6::QmlDebugPrivate STATIC IMPORTED) + +set_target_properties(Qt6::QmlDebugPrivate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_QMLDEBUG_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQmlDebug;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlDebug/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlDebug/6.8.1/QtQmlDebug>" + INTERFACE_LINK_LIBRARIES "Qt6::CorePrivate;Qt6::Network;Qt6::PacketProtocolPrivate;Qt6::QmlPrivate;\$" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6qmldebugprivate_metatypes.json>" + _qt_config_module_name "qmldebug_private" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_include_name "QtQmlDebug" + _qt_module_interface_name "QmlDebug" + _qt_package_name "Qt6QmlDebugPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-QmlDebugPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDebugPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::PacketProtocolPrivate" "Qt6::QmlPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c9bfb9efd65ff533bc8748c8849847808b05419c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlDebugPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..78d8b812fa82fb8493afc965e735c3bf01ad7876 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDebugPrivate/Qt6QmlDebugPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlDebugPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateAdditionalTargetInfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateAdditionalTargetInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d7d04fd63cc1484acf8069c8e0e28e87a275dec1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateAdditionalTargetInfo.cmake @@ -0,0 +1,38 @@ +# Additional target information for Qt6QmlDomPrivate +if(NOT DEFINED QT_DEFAULT_IMPORT_CONFIGURATION) + set(QT_DEFAULT_IMPORT_CONFIGURATION RELWITHDEBINFO) +endif() +__qt_internal_promote_target_to_global_checked(Qt6::QmlDomPrivate) +get_target_property(_qt_imported_location Qt6::QmlDomPrivate IMPORTED_LOCATION_RELWITHDEBINFO) +get_target_property(_qt_imported_location_default Qt6::QmlDomPrivate IMPORTED_LOCATION_${QT_DEFAULT_IMPORT_CONFIGURATION}) + +# Import target "Qt6::QmlDomPrivate" for configuration "Release" +set_property(TARGET Qt6::QmlDomPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlDomPrivate PROPERTY IMPORTED_LOCATION_RELEASE "${_qt_imported_location}") +endif() + +# Import target "Qt6::QmlDomPrivate" for configuration "MinSizeRel" +set_property(TARGET Qt6::QmlDomPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS MINSIZEREL) + +if(_qt_imported_location) + set_property(TARGET Qt6::QmlDomPrivate PROPERTY IMPORTED_LOCATION_MINSIZEREL "${_qt_imported_location}") +endif() + +# Default configuration +if(_qt_imported_location_default) + set_property(TARGET Qt6::QmlDomPrivate PROPERTY IMPORTED_LOCATION "${_qt_imported_location_default}") +endif() + +unset(_qt_imported_location) +unset(_qt_imported_location_default) +unset(_qt_imported_soname) +unset(_qt_imported_soname_default) +unset(_qt_imported_link_dependencies) +unset(_qt_imported_link_dependencies_default) +unset(_qt_imported_objects) +unset(_qt_imported_objects_default) +unset(_qt_imported_clr) +unset(_qt_imported_clr_default) +unset(_qt_imported_configs) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7f6a8cf0c2b84829d1ff6745f0f44c2332c5ce37 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfig.cmake @@ -0,0 +1,186 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + + +####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### +####### Any changes to this file will be overwritten by the next CMake run #### +####### The input file was QtModuleConfig.cmake.in ######## + +get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) + +macro(set_and_check _var _file) + set(${_var} "${_file}") + if(NOT EXISTS "${_file}") + message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") + endif() +endmacro() + +macro(check_required_components _NAME) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(NOT ${_NAME}_${comp}_FOUND) + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + endif() + endif() + endforeach() +endmacro() + +#################################################################################### + +cmake_minimum_required(VERSION 3.16...3.21) + +include(CMakeFindDependencyMacro) + +get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_import_prefix "${_import_prefix}" REALPATH) + +# Extra cmake code begin + +# Extra cmake code end + +# Find required dependencies, if any. +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateDependencies.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateDependencies.cmake") + _qt_internal_suggest_dependency_debugging(QmlDomPrivate + __qt_QmlDomPrivate_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE) +endif() + +# If *ConfigDependencies.cmake exists, the variable value will be defined there. +# Don't override it in that case. +if(NOT DEFINED "Qt6QmlDomPrivate_FOUND") + set("Qt6QmlDomPrivate_FOUND" TRUE) +endif() + +if (NOT QT_NO_CREATE_TARGETS AND Qt6QmlDomPrivate_FOUND) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateTargets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateAdditionalTargetInfo.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateExtraProperties.cmake" + OPTIONAL) + + # DEPRECATED + # Provide old style variables for includes, compile definitions, etc. + # These variables are deprecated and only provided on a best-effort basis to facilitate porting. + # Consider using target_link_libraries(app PRIVATE Qt6QmlDomPrivate) instead. + set(Qt6QmlDomPrivate_LIBRARIES "Qt6::QmlDomPrivate") + + get_target_property(_Qt6QmlDomPrivate_OWN_INCLUDE_DIRS + Qt6::QmlDomPrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlDomPrivate_OWN_INCLUDE_DIRS) + set(_Qt6QmlDomPrivate_OWN_INCLUDE_DIRS "") + endif() + + if(TARGET Qt6::QmlDomPrivatePrivate) + get_target_property(_Qt6QmlDomPrivate_OWN_PRIVATE_INCLUDE_DIRS + Qt6::QmlDomPrivatePrivate INTERFACE_INCLUDE_DIRECTORIES) + if(NOT _Qt6QmlDomPrivate_OWN_PRIVATE_INCLUDE_DIRS) + set(_Qt6QmlDomPrivate_OWN_PRIVATE_INCLUDE_DIRS "") + endif() + endif() + + get_target_property(Qt6QmlDomPrivate_DEFINITIONS + Qt6::QmlDomPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlDomPrivate_DEFINITIONS) + set(Qt6QmlDomPrivate_DEFINITIONS "") + else() + set(updated_defs "") + foreach(def IN LISTS Qt6QmlDomPrivate_DEFINITIONS) + if(def MATCHES "^[A-Za-z_]") + list(APPEND updated_defs "-D${def}") + else() + list(APPEND updated_defs "${def}") + endif() + endforeach() + set(Qt6QmlDomPrivate_DEFINITIONS "${updated_defs}") + unset(updated_defs) + endif() + + get_target_property(Qt6QmlDomPrivate_COMPILE_DEFINITIONS + Qt6::QmlDomPrivate INTERFACE_COMPILE_DEFINITIONS) + if(NOT Qt6QmlDomPrivate_COMPILE_DEFINITIONS) + set(Qt6QmlDomPrivate_COMPILE_DEFINITIONS "") + endif() + + set(Qt6QmlDomPrivate_INCLUDE_DIRS + ${_Qt6QmlDomPrivate_OWN_INCLUDE_DIRS}) + + set(Qt6QmlDomPrivate_PRIVATE_INCLUDE_DIRS + ${_Qt6QmlDomPrivate_OWN_PRIVATE_INCLUDE_DIRS}) + + foreach(_module_dep ${_Qt6QmlDomPrivate_MODULE_DEPENDENCIES}) + if(_module_dep MATCHES ".+Private$") + set(_private_suffix "Private") + else() + set(_private_suffix "") + endif() + list(APPEND Qt6QmlDomPrivate${_private_suffix}_INCLUDE_DIRS + ${Qt6${_module_dep}_INCLUDE_DIRS}) + list(APPEND Qt6QmlDomPrivate${_private_suffix}_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + if(_private_suffix) + list(APPEND Qt6QmlDomPrivate_PRIVATE_INCLUDE_DIRS + ${Qt6${_module_dep}_PRIVATE_INCLUDE_DIRS}) + endif() + list(APPEND Qt6QmlDomPrivate${_private_suffix}_DEFINITIONS + ${Qt6${_module_dep}_DEFINITIONS}) + list(APPEND Qt6QmlDomPrivate${_private_suffix}_COMPILE_DEFINITIONS + ${Qt6${_module_dep}_COMPILE_DEFINITIONS}) + endforeach() + unset(_private_suffix) + + list(REMOVE_DUPLICATES Qt6QmlDomPrivate_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlDomPrivate_PRIVATE_INCLUDE_DIRS) + list(REMOVE_DUPLICATES Qt6QmlDomPrivate_DEFINITIONS) + list(REMOVE_DUPLICATES Qt6QmlDomPrivate_COMPILE_DEFINITIONS) +endif() + +if (TARGET Qt6::QmlDomPrivate) + qt_make_features_available(Qt6::QmlDomPrivate) + + foreach(extra_cmake_include ) + include("${CMAKE_CURRENT_LIST_DIR}/${extra_cmake_include}") + endforeach() + + if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivatePlugins.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivatePlugins.cmake") + endif() + + list(APPEND QT_ALL_MODULES_FOUND_VIA_FIND_PACKAGE "QmlDomPrivate") + + get_target_property(_qt_module_target_type "Qt6::QmlDomPrivate" TYPE) + if(NOT _qt_module_target_type STREQUAL "INTERFACE_LIBRARY") + get_target_property(_qt_module_plugin_types + Qt6::QmlDomPrivate MODULE_PLUGIN_TYPES) + if(_qt_module_plugin_types) + list(APPEND QT_ALL_PLUGIN_TYPES_FOUND_VIA_FIND_PACKAGE "${_qt_module_plugin_types}") + endif() + endif() + + + # Load Module's BuildInternals should any exist + if (Qt6BuildInternals_DIR AND + EXISTS "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateBuildInternals.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateBuildInternals.cmake") + endif() + + if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS) + if(CMAKE_VERSION VERSION_LESS 3.18 OR QT_USE_OLD_VERSION_LESS_TARGETS) + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateVersionlessTargets.cmake") + else() + include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateVersionlessAliasTargets.cmake") + endif() + endif() +else() + + set(Qt6QmlDomPrivate_FOUND FALSE) + if(NOT DEFINED Qt6QmlDomPrivate_NOT_FOUND_MESSAGE) + set(Qt6QmlDomPrivate_NOT_FOUND_MESSAGE + "Target \"Qt6::QmlDomPrivate\" was not found.") + + if(QT_NO_CREATE_TARGETS) + string(APPEND Qt6QmlDomPrivate_NOT_FOUND_MESSAGE + "Possibly due to QT_NO_CREATE_TARGETS being set to TRUE and thus " + "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateTargets.cmake was not " + "included to define the target.") + endif() + endif() +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..723f2296f3f9658b5f3e741a2c54eca92777b9e1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateDependencies.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateDependencies.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fdeef4bc57d791c449b8d4d24c3e191e942c288b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateDependencies.cmake @@ -0,0 +1,47 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Make sure Qt6 is found before anything else. +set(Qt6QmlDomPrivate_FOUND FALSE) + +if("${_qt_cmake_dir}" STREQUAL "") + set(_qt_cmake_dir "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}") +endif() +set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH") +if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES) + set(__qt_use_no_default_path_for_qt_packages "") +endif() + +# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls +# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file. +set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE) + +if(NOT Qt6_FOUND) + find_dependency(Qt6 6.8.1 + PATHS + ${QT_BUILD_CMAKE_PREFIX_PATH} + "${CMAKE_CURRENT_LIST_DIR}/.." + "${_qt_cmake_dir}" + ${_qt_additional_packages_prefix_paths} + ${__qt_use_no_default_path_for_qt_packages} + ) +endif() + + +# note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;" +set(__qt_QmlDomPrivate_third_party_deps "") + +_qt_internal_find_third_party_dependencies("QmlDomPrivate" __qt_QmlDomPrivate_third_party_deps) + +# Find Qt tool package. +set(__qt_QmlDomPrivate_tool_deps "") +_qt_internal_find_tool_dependencies("QmlDomPrivate" __qt_QmlDomPrivate_tool_deps) + +# note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0" +set(__qt_QmlDomPrivate_target_deps "Qt6Qml\;6.8.1;Qt6QmlCompiler\;6.8.1") +set(__qt_QmlDomPrivate_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}") +_qt_internal_find_qt_dependencies("QmlDomPrivate" __qt_QmlDomPrivate_target_deps + __qt_QmlDomPrivate_find_dependency_paths) + +set(_Qt6QmlDomPrivate_MODULE_DEPENDENCIES "Qml;QmlCompiler") +set(Qt6QmlDomPrivate_FOUND TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets-debug.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets-debug.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0781bb47516ee367a71bf4f6b5d2cff1c87eefc0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets-debug.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Debug". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlDomPrivate" for configuration "Debug" +set_property(TARGET Qt6::QmlDomPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) +set_target_properties(Qt6::QmlDomPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/Qt6QmlDomd.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlDomPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlDomPrivate "${_IMPORT_PREFIX}/lib/Qt6QmlDomd.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets-relwithdebinfo.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets-relwithdebinfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a57f90d433941c527bcc5b70d900e5b6868d5bf0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets-relwithdebinfo.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "RelWithDebInfo". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "Qt6::QmlDomPrivate" for configuration "RelWithDebInfo" +set_property(TARGET Qt6::QmlDomPrivate APPEND PROPERTY IMPORTED_CONFIGURATIONS RELWITHDEBINFO) +set_target_properties(Qt6::QmlDomPrivate PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELWITHDEBINFO "CXX" + IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/Qt6QmlDom.lib" + ) + +list(APPEND _cmake_import_check_targets Qt6::QmlDomPrivate ) +list(APPEND _cmake_import_check_files_for_Qt6::QmlDomPrivate "${_IMPORT_PREFIX}/lib/Qt6QmlDom.lib" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..25e064192ada46f1ce948d3a3f85bc7052f5de5a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateTargets.cmake @@ -0,0 +1,142 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "3.1.0") + message(FATAL_ERROR "CMake >= 3.1.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 3.1.0...3.28) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS Qt6::QmlDomPrivate) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target Qt6::QmlDomPrivate +add_library(Qt6::QmlDomPrivate STATIC IMPORTED) + +set_target_properties(Qt6::QmlDomPrivate PROPERTIES + COMPATIBLE_INTERFACE_STRING "QT_MAJOR_VERSION" + INTERFACE_COMPILE_DEFINITIONS "QT_QMLDOM_LIB" + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QtQmlDom;${_IMPORT_PREFIX}/include;\$<\$>:>;\$<\$>:>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlDom/6.8.1>;\$<\$>:${_IMPORT_PREFIX}/include/QtQmlDom/6.8.1/QtQmlDom>" + INTERFACE_LINK_LIBRARIES "Qt6::QmlPrivate;Qt6::QmlCompilerPrivate;\$" + INTERFACE_QT_MAJOR_VERSION "6" + INTERFACE_SOURCES "\$<\$>:${_IMPORT_PREFIX}/./metatypes/qt6qmldomprivate_metatypes.json>" + _qt_config_module_name "qmldom_private" + _qt_is_internal_library "TRUE" + _qt_is_internal_module "TRUE" + _qt_is_internal_target "TRUE" + _qt_module_has_headers "ON" + _qt_module_has_private_headers "TRUE" + _qt_module_has_public_headers "TRUE" + _qt_module_include_name "QtQmlDom" + _qt_module_interface_name "QmlDom" + _qt_package_name "Qt6QmlDomPrivate" + _qt_package_version "6.8.1" + _qt_sbom_spdx_id "SPDXRef-Package-qtdeclarative-qt-module-QmlDomPrivate" + _qt_sbom_spdx_relative_installed_repo_document_path "sbom/qtdeclarative-6.8.1.spdx" + _qt_sbom_spdx_repo_document_namespace "https://qt.io/spdxdocs/qtdeclarative-6.8.1" + _qt_sbom_spdx_repo_project_name_lowercase "qtdeclarative" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Qt6QmlDomPrivateTargets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + if(CMAKE_VERSION VERSION_LESS "3.28" + OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target} + OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}") + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + endif() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# Make sure the targets which have been exported in some other +# export set exist. +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) +foreach(_target "Qt6::QmlPrivate" "Qt6::QmlCompilerPrivate" ) + if(NOT TARGET "${_target}" ) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets "${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets} ${_target}") + endif() +endforeach() + +if(DEFINED ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + if(CMAKE_FIND_PACKAGE_NAME) + set( ${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + set( ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + else() + message(FATAL_ERROR "The following imported targets are referenced, but are missing: ${${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets}") + endif() +endif() +unset(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE_targets) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateVersionlessAliasTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateVersionlessAliasTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d140753ebb31389e4ba44bcd378ec94e80f74459 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateVersionlessAliasTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlDomPrivate") + +_qt_internal_create_versionless_alias_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateVersionlessTargets.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateVersionlessTargets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f691fc1e37961054df5389d231ac681fc7217638 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlDomPrivate/Qt6QmlDomPrivateVersionlessTargets.cmake @@ -0,0 +1,7 @@ +# Protect against multiple inclusion, which would fail when already imported targets are +# added once more. +_qt_internal_check_multiple_inclusion(_targets_not_defined "QmlDomPrivate") + +_qt_internal_create_versionless_targets("${_targets_not_defined}" Qt6) + +unset(_targets_not_defined) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfig.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfig.cmake new file mode 100644 index 0000000000000000000000000000000000000000..4d9f5a967b0b1e38f18e21500bf5bb314f95d51c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfig.cmake @@ -0,0 +1,5 @@ +# The functionality that was provided in the Qt5 package was moved to the Qml package. +# Defers to that package and it macros. +include(CMakeFindDependencyMacro) +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlImportScannerDependencies.cmake") +set("Qt6QmlImportScanner_FOUND" TRUE) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfigVersion.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfigVersion.cmake new file mode 100644 index 0000000000000000000000000000000000000000..04fea28f532937a11ca09568f5051a2c412f3c06 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfigVersion.cmake @@ -0,0 +1,68 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause + +# Include the basic version config file to get results of regular version checking. +include("${CMAKE_CURRENT_LIST_DIR}/Qt6QmlImportScannerConfigVersionImpl.cmake") + +set(__qt_disable_package_version_check FALSE) + +# Allow to opt out of the version check. +if(QT_NO_PACKAGE_VERSION_CHECK) + set(__qt_disable_package_version_check TRUE) +endif() + +# Extra CMake code begin + +# Extra CMake code end + +if((NOT PACKAGE_VERSION_COMPATIBLE) OR PACKAGE_VERSION_UNSUITABLE) + set(__qt_package_version_incompatible TRUE) +else() + set(__qt_package_version_incompatible FALSE) +endif() + +if(__qt_disable_package_version_check) + # Don't show the warning needlessly if we know that we're doing an exact search, and the + # version found is not the exactly same. + if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT + AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE) + endif() + + # Warn if version check is disabled regardless if it's a Qt repo build or user project build. + # Allow to opt out of warning. + if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING + AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + message(WARNING + "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as " + "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee " + "the build will succeed. You can silence this warning by passing " + "-DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") + endif() + + # Mark version as compatible. This is how we disable the version check. + set(PACKAGE_VERSION_COMPATIBLE TRUE) + unset(PACKAGE_VERSION_UNSUITABLE) + +# If QT_REPO_MODULE_VERSION is set, that means we are building a Qt repo. Show message that one can +# disable the check if they need to. +elseif(QT_REPO_MODULE_VERSION AND __qt_package_version_incompatible) + if(PACKAGE_FIND_VERSION_RANGE) + set(__qt_package_version_message_prefix "Version range ${PACKAGE_FIND_VERSION_RANGE}") + else() + set(__qt_package_version_message_prefix "Version ${PACKAGE_FIND_VERSION}") + endif() + + message(WARNING + "${__qt_package_version_message_prefix} of package ${PACKAGE_FIND_NAME} was requested but " + "an incompatible version was found: ${PACKAGE_VERSION}. You can pass " + "-DQT_NO_PACKAGE_VERSION_CHECK=TRUE to disable the version check and force the " + "incompatible version to be used. There is no guarantee the build will succeed. " + "Use at your own risk. " + "You can silence this warning by passing -DQT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING=TRUE") +endif() + +unset(__qt_disable_package_version_check) +unset(__qt_disable_package_version_check_due_to_developer_build) +unset(__qt_package_version_message_prefix) +unset(__qt_package_version_incompatible) diff --git a/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfigVersionImpl.cmake b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfigVersionImpl.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d77c0f8977e551fd2d11618f7758d7886da13df4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/lib/cmake/Qt6QmlImportScanner/Qt6QmlImportScannerConfigVersionImpl.cmake @@ -0,0 +1,43 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "6.8.1") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/qt/6.8.1/msvc2022_64/lib/objects-Debug/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj b/qt/6.8.1/msvc2022_64/lib/objects-Debug/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj new file mode 100644 index 0000000000000000000000000000000000000000..ff2d5e7c504fe74aa7c7a090ebe9995892d28fdf Binary files /dev/null and b/qt/6.8.1/msvc2022_64/lib/objects-Debug/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj differ diff --git a/qt/6.8.1/msvc2022_64/lib/objects-Debug/QmlTypeRegistrarPrivate_resources_1/.qt/rcc/qrc_jsRootMetaTypes_init.cpp.obj b/qt/6.8.1/msvc2022_64/lib/objects-Debug/QmlTypeRegistrarPrivate_resources_1/.qt/rcc/qrc_jsRootMetaTypes_init.cpp.obj new file mode 100644 index 0000000000000000000000000000000000000000..6e4109e261b46623e515cf652a9f686bc86123d9 Binary files /dev/null and b/qt/6.8.1/msvc2022_64/lib/objects-Debug/QmlTypeRegistrarPrivate_resources_1/.qt/rcc/qrc_jsRootMetaTypes_init.cpp.obj differ diff --git a/qt/6.8.1/msvc2022_64/lib/objects-RelWithDebInfo/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj b/qt/6.8.1/msvc2022_64/lib/objects-RelWithDebInfo/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj new file mode 100644 index 0000000000000000000000000000000000000000..44880acd2ad420683102c8863460e653ff3dc11a Binary files /dev/null and b/qt/6.8.1/msvc2022_64/lib/objects-RelWithDebInfo/ExampleIconsPrivate_resources_1/.qt/rcc/qrc_example_icons_init.cpp.obj differ diff --git a/qt/6.8.1/msvc2022_64/lib/objects-RelWithDebInfo/QmlTypeRegistrarPrivate_resources_1/.qt/rcc/qrc_jsRootMetaTypes_init.cpp.obj b/qt/6.8.1/msvc2022_64/lib/objects-RelWithDebInfo/QmlTypeRegistrarPrivate_resources_1/.qt/rcc/qrc_jsRootMetaTypes_init.cpp.obj new file mode 100644 index 0000000000000000000000000000000000000000..63973d7608b5f1ebf51bec0ce74dea99f37345ec Binary files /dev/null and b/qt/6.8.1/msvc2022_64/lib/objects-RelWithDebInfo/QmlTypeRegistrarPrivate_resources_1/.qt/rcc/qrc_jsRootMetaTypes_init.cpp.obj differ diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/aix/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/aix/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..56761501256956301f197338efed7d9d8d3b8299 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/aix/qplatformdefs.h @@ -0,0 +1,79 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_AIX_QPLATFORMDEFS_H +#define Q_AIX_QPLATFORMDEFS_H + +// Get Qt defines/settings + +#include "qglobal.h" + +// Set any POSIX/XOPEN defines at the top of this file to turn on specific APIs + +#include + + +// We are hot - unistd.h should have turned on the specific APIs we requested + + +// uncomment if you have problems with because your gcc +// hasn't been built on exactly the same OS version your are using now. +// typedef int crid_t; +// typedef unsigned int class_id_t; +#include +#include +#include +#include +#include +#include +#include +#include // AIX X11 headers define FD_ZERO using bzero() + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Only AIX 4.3 and better support 64-bit + +#define QT_USE_XOPEN_LFS_EXTENSIONS +#include "../posix/qplatformdefs.h" + +#undef QT_SOCKLEN_T + +#ifdef _AIX43 +// AIX 4.3 and better +#define QT_SOCKLEN_T socklen_t +#elif _AIX42 +// AIX 4.2 +#define QT_SOCKLEN_T size_t +#else +// AIX 4.1 +#define QT_SOCKLEN_T size_t +// override +#define QT_SOCKOPTLEN_T int +#endif + +#ifdef QT_LARGEFILE_SUPPORT +#undef QT_DIR +#undef QT_OPENDIR +#undef QT_CLOSEDIR + +#define QT_DIR DIR64 +#define QT_OPENDIR ::opendir64 +#define QT_CLOSEDIR ::closedir64 +#endif + +#if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE-0 >= 500) +// AIX 4.3 and better +#define QT_SNPRINTF ::snprintf +#define QT_VSNPRINTF ::vsnprintf +#endif + +#endif // include guard diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/android/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/android/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..1dae5f33876798dd1f655d983b80db077725f322 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/android/qplatformdefs.h @@ -0,0 +1,117 @@ +// Copyright (C) 2012 Collabora Ltd, author +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QPLATFORMDEFS_H +#define QPLATFORMDEFS_H + +// Get Qt defines/settings + +#include "qglobal.h" + +// Set any POSIX/XOPEN defines at the top of this file to turn on specific APIs + +// 1) need to reset default environment if _BSD_SOURCE is defined +// 2) need to specify POSIX thread interfaces explicitly in glibc 2.0 +// 3) it seems older glibc need this to include the X/Open stuff + +#include + +// We are hot - unistd.h should have turned on the specific APIs we requested + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +#define QT_STATBUF struct stat +#define QT_STATBUF4TSTAT struct stat +#define QT_STAT ::stat +#define QT_FSTAT ::fstat +#define QT_LSTAT ::lstat +#define QT_OPEN ::open +#define QT_TRUNCATE ::truncate +#define QT_FTRUNCATE ::ftruncate +#define QT_LSEEK ::lseek + +#define QT_FOPEN ::fopen +#define QT_FSEEK ::fseek +#define QT_FTELL ::ftell +#define QT_FGETPOS ::fgetpos +#define QT_FSETPOS ::fsetpos +#define QT_MMAP ::mmap +#define QT_FPOS_T fpos_t +#define QT_OFF_T long + +#define QT_STAT_REG S_IFREG +#define QT_STAT_DIR S_IFDIR +#define QT_STAT_MASK S_IFMT +#define QT_STAT_LNK S_IFLNK +#define QT_SOCKET_CONNECT ::connect +#define QT_SOCKET_BIND ::bind +#define QT_FILENO fileno +#define QT_CLOSE ::close +#define QT_READ ::read +#define QT_WRITE ::write +#define QT_ACCESS ::access +#define QT_GETCWD ::getcwd +#define QT_CHDIR ::chdir +#define QT_MKDIR ::mkdir +#define QT_RMDIR ::rmdir +#define QT_OPEN_LARGEFILE O_LARGEFILE +#define QT_OPEN_RDONLY O_RDONLY +#define QT_OPEN_WRONLY O_WRONLY +#define QT_OPEN_RDWR O_RDWR +#define QT_OPEN_CREAT O_CREAT +#define QT_OPEN_TRUNC O_TRUNC +#define QT_OPEN_APPEND O_APPEND +#define QT_OPEN_EXCL O_EXCL + +// Directory iteration +#define QT_DIR DIR + + +#define QT_OPENDIR ::opendir +#define QT_CLOSEDIR ::closedir + +#if defined(QT_LARGEFILE_SUPPORT) \ + && defined(QT_USE_XOPEN_LFS_EXTENSIONS) \ + && !defined(QT_NO_READDIR64) +#define QT_DIRENT struct dirent64 +#define QT_READDIR ::readdir64 +#else +#define QT_DIRENT struct dirent +#define QT_READDIR ::readdir +#endif + +#define QT_SOCKET_CONNECT ::connect +#define QT_SOCKET_BIND ::bind + + +#define QT_SIGNAL_RETTYPE void +#define QT_SIGNAL_ARGS int +#define QT_SIGNAL_IGNORE SIG_IGN + +#define QT_SOCKLEN_T socklen_t + +#if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500) +#define QT_SNPRINTF ::snprintf +#define QT_VSNPRINTF ::vsnprintf +#endif + + +#endif // QPLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/bsd/bsd.conf b/qt/6.8.1/msvc2022_64/mkspecs/common/bsd/bsd.conf new file mode 100644 index 0000000000000000000000000000000000000000..c0ec6e64ddd688c3c8b1ff69636acbcfc859c8d1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/bsd/bsd.conf @@ -0,0 +1,30 @@ +# +# common qmake configuration for *BSD +# + +MAKEFILE_GENERATOR = UNIX +QMAKE_PLATFORM += bsd + +include(../unix.conf) + +QMAKE_CFLAGS_THREAD = -pthread + +QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD + +QMAKE_LFLAGS_THREAD = -pthread +QMAKE_LFLAGS_GCSECTIONS = -Wl,--gc-sections + +QMAKE_LIBS = +QMAKE_LIBS_DYNLOAD = +QMAKE_LIBS_EXECINFO = -lexecinfo +QMAKE_LIBS_X11 = -lXext -lX11 -lm +QMAKE_LIBS_OPENGL = -lGL +QMAKE_LIBS_THREAD = + +QMAKE_AR = ar cqs +QMAKE_OBJCOPY = objcopy +QMAKE_NM = nm -P +QMAKE_RANLIB = + +QMAKE_STRIP = strip +QMAKE_STRIPFLAGS_LIB += --strip-unneeded diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/bsd/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/bsd/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..4d47233c1a334f3cde719edbd20fe08c481b30f5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/bsd/qplatformdefs.h @@ -0,0 +1,46 @@ +// Copyright (C) 2017 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_BSD_PLATFORMDEFS_H +#define Q_BSD_PLATFORMDEFS_H + +// Get Qt defines/settings + +#include "qglobal.h" + +// Set any POSIX/XOPEN defines at the top of this file to turn on specific APIs + +#include + + +// We are hot - unistd.h should have turned on the specific APIs we requested + + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../posix/qplatformdefs.h" + +#undef QT_OPEN_LARGEFILE +#define QT_OPEN_LARGEFILE 0 + +#define QT_SNPRINTF ::snprintf +#define QT_VSNPRINTF ::vsnprintf + +#endif // QPLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/c89/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/c89/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..f34759aa3fd149357804b775027625a953161e54 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/c89/qplatformdefs.h @@ -0,0 +1,18 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_C89_QPLATFORMDEFS_H +#define Q_C89_QPLATFORMDEFS_H + +// #include + +#define QT_FPOS_T fpos_t +#define QT_OFF_T long + +#define QT_FOPEN ::fopen +#define QT_FSEEK ::fseek +#define QT_FTELL ::ftell +#define QT_FGETPOS ::fgetpos +#define QT_FSETPOS ::fsetpos + +#endif // include guard diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/integrity/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/integrity/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..79005da749550a01fbea934e349b109a11baf155 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/integrity/qplatformdefs.h @@ -0,0 +1,67 @@ +// Copyright (C) 2015 Green Hills Software. All rights reserved. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_INTEGRITY_PLATFORMDEFS_H +#define Q_INTEGRITY_PLATFORMDEFS_H + +// Get Qt defines/settings + +#include "qglobal.h" + +#include +#include +#include + +#define __STDC_CONSTANT_MACROS + +#include +#include +#include +#include +#include + +#include +#include +#include +// INTEGRITY doesn't have the System V header. This is not a standard +// POSIX header, it's only documented in the Single UNIX Specification. +// The preferred POSIX compliant way to share memory is to use the functions +// in that comply with the POSIX Real Time Interface (1003.1b). +#include +#include +#include +#include +#include + +// for htonl +#include + +#define QT_SNPRINTF ::snprintf +#define QT_VSNPRINTF ::vsnprintf + +// INTEGRITY doesn't have getpagesize() +inline int getpagesize() +{ + return sysconf(_SC_PAGESIZE); +} + +// geteuid() is only available with multi-process posix, but we do not want +// to rely on it +inline uid_t geteuid(void) +{ + return 0; +} + +// getuid() is only available with multi-process posix, but we do not want +// to rely on it +inline uid_t getuid(void) +{ + return 0; +} + +#include "../posix/qplatformdefs.h" +#undef QT_OPEN_LARGEFILE +#define QT_OPEN_LARGEFILE 0 +#define PATH_MAX 1024 + +#endif // Q_INTEGRITY_PLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/mac/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/mac/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..2f6ae13267bb64a913e6df359ec4f23f8b3291d4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/mac/qplatformdefs.h @@ -0,0 +1,53 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QPLATFORMDEFS_H +#define QPLATFORMDEFS_H + +// Get Qt defines/settings + +#include "qglobal.h" + +// Set any POSIX/XOPEN defines at the top of this file to turn on specific APIs + +#include + + +// We are hot - unistd.h should have turned on the specific APIs we requested + + +#include +#include +#include +#include +#include +#include +#define QT_NO_LIBRARY_UNLOAD + +#include +#include +#include +#include +#include +#include +#include +#include +#define __APPLE_USE_RFC_3542 +#include + +#include "../posix/qplatformdefs.h" + +#undef QT_OPEN_LARGEFILE +#undef QT_SOCKLEN_T +#undef QT_SIGNAL_IGNORE + +#define QT_OPEN_LARGEFILE 0 + +#define QT_SOCKLEN_T socklen_t + +#define QT_SIGNAL_IGNORE (void (*)(int))1 + +#define QT_SNPRINTF ::snprintf +#define QT_VSNPRINTF ::vsnprintf + +#endif // QPLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/posix/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/posix/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..f0cb35179ab983a72859786d52a275b814d9ae40 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/posix/qplatformdefs.h @@ -0,0 +1,125 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_POSIX_QPLATFORMDEFS_H +#define Q_POSIX_QPLATFORMDEFS_H + +#include + +#include +#ifndef QT_NO_SOCKET_H +# include +#endif +#include + +#if defined(QT_USE_XOPEN_LFS_EXTENSIONS) && defined(QT_LARGEFILE_SUPPORT) + +#define QT_STATBUF struct stat64 +#define QT_FPOS_T fpos64_t +#define QT_OFF_T off64_t + +#define QT_STAT ::stat64 +#define QT_LSTAT ::lstat64 +#define QT_TRUNCATE ::truncate64 + +// File I/O +#define QT_OPEN ::open64 +#define QT_LSEEK ::lseek64 +#define QT_FSTAT ::fstat64 +#define QT_FTRUNCATE ::ftruncate64 + +// Standard C89 +#define QT_FOPEN ::fopen64 +#define QT_FSEEK ::fseeko64 +#define QT_FTELL ::ftello64 +#define QT_FGETPOS ::fgetpos64 +#define QT_FSETPOS ::fsetpos64 + +#define QT_MMAP ::mmap64 + +#else // !defined(QT_USE_XOPEN_LFS_EXTENSIONS) || !defined(QT_LARGEFILE_SUPPORT) + +#include "../c89/qplatformdefs.h" + +#define QT_STATBUF struct stat + +#define QT_STAT ::stat +#define QT_LSTAT ::lstat +#define QT_TRUNCATE ::truncate + +// File I/O +#define QT_OPEN ::open +#define QT_LSEEK ::lseek +#define QT_FSTAT ::fstat +#define QT_FTRUNCATE ::ftruncate + +// Posix extensions to C89 +#if !defined(QT_USE_XOPEN_LFS_EXTENSIONS) && !defined(QT_NO_USE_FSEEKO) +#undef QT_OFF_T +#undef QT_FSEEK +#undef QT_FTELL + +#define QT_OFF_T off_t + +#define QT_FSEEK ::fseeko +#define QT_FTELL ::ftello +#endif + +#define QT_MMAP ::mmap + +#endif // !defined (QT_USE_XOPEN_LFS_EXTENSIONS) || !defined(QT_LARGEFILE_SUPPORT) + +#define QT_STAT_MASK S_IFMT +#define QT_STAT_REG S_IFREG +#define QT_STAT_DIR S_IFDIR +#define QT_STAT_LNK S_IFLNK + +#define QT_ACCESS ::access +#define QT_GETCWD ::getcwd +#define QT_CHDIR ::chdir +#define QT_MKDIR ::mkdir +#define QT_RMDIR ::rmdir + +// File I/O +#define QT_CLOSE ::close +#define QT_READ ::read +#define QT_WRITE ::write + +#define QT_OPEN_LARGEFILE O_LARGEFILE +#define QT_OPEN_RDONLY O_RDONLY +#define QT_OPEN_WRONLY O_WRONLY +#define QT_OPEN_RDWR O_RDWR +#define QT_OPEN_CREAT O_CREAT +#define QT_OPEN_TRUNC O_TRUNC +#define QT_OPEN_APPEND O_APPEND +#define QT_OPEN_EXCL O_EXCL + +// Posix extensions to C89 +#define QT_FILENO fileno + +// Directory iteration +#define QT_DIR DIR + +#define QT_OPENDIR ::opendir +#define QT_CLOSEDIR ::closedir + +#if defined(QT_LARGEFILE_SUPPORT) \ + && defined(QT_USE_XOPEN_LFS_EXTENSIONS) \ + && !defined(QT_NO_READDIR64) +#define QT_DIRENT struct dirent64 +#define QT_READDIR ::readdir64 +#else +#define QT_DIRENT struct dirent +#define QT_READDIR ::readdir +#endif + +#define QT_SOCKLEN_T socklen_t + +#define QT_SOCKET_CONNECT ::connect +#define QT_SOCKET_BIND ::bind + +#define QT_SIGNAL_RETTYPE void +#define QT_SIGNAL_ARGS int +#define QT_SIGNAL_IGNORE SIG_IGN + +#endif // include guard diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/qnx/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/qnx/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..2ba5bde8b9a115e549546bba45c615a29aa03509 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/qnx/qplatformdefs.h @@ -0,0 +1,61 @@ +// Copyright (C) 2014 BlackBerry Limited. All rights reserved. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_QNX_PLATFORMDEFS_H +#define Q_QNX_PLATFORMDEFS_H + +// Get Qt defines/settings + +#include "qglobal.h" + +// Set any POSIX/XOPEN defines at the top of this file to turn on specific APIs + +#include + +#define __STDC_CONSTANT_MACROS + +// We are hot - unistd.h should have turned on the specific APIs we requested + + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +// QNX doesn't have the System V header. This is not a standard +// POSIX header, it's only documented in the Single UNIX Specification. +// The preferred POSIX compliant way to share memory is to use the functions +// in that comply with the POSIX Real Time Interface (1003.1b). +#include +#include +#include +#include +#include + +// for htonl +#include + +#define QT_USE_XOPEN_LFS_EXTENSIONS +#if !defined(__EXT_QNX__READDIR64_R) +#define QT_NO_READDIR64 +#endif +#include "../posix/qplatformdefs.h" + +#define QT_SNPRINTF ::snprintf +#define QT_VSNPRINTF ::vsnprintf + +// QNX6 doesn't have getpagesize() +inline int getpagesize() +{ + return ::sysconf(_SC_PAGESIZE); +} + +#include + +#endif // Q_QNX_PLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/rtems/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/rtems/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..5d29b974789ea8a8a70a07e855199dee116cc801 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/rtems/qplatformdefs.h @@ -0,0 +1,36 @@ +// Copyright (C) 2018 The Qt Company. All rights reserved. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_RTEMS_PLATFORMDEFS_H +#define Q_RTEMS_PLATFORMDEFS_H + +// Get Qt defines/settings + +#include "qglobal.h" + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +#define __LINUX_ERRNO_EXTENSIONS__ +#include + +#include "../posix/qplatformdefs.h" + +#ifdef __STRICT_ANSI__ +#undef __STRICT_ANSI__ +#endif + +#undef QT_OPEN_LARGEFILE +#define QT_OPEN_LARGEFILE 0 + +#endif // Q_RTEMS_PLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/GLES2/gl2.h b/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/GLES2/gl2.h new file mode 100644 index 0000000000000000000000000000000000000000..197f43aa74c38e6a8256c8e7d3d4fe47432054ed --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/GLES2/gl2.h @@ -0,0 +1,5 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include +#include diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/clang.conf b/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/clang.conf new file mode 100644 index 0000000000000000000000000000000000000000..1a5f4cd123015aebf781527a57a40a9f142ea1f2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/clang.conf @@ -0,0 +1,3 @@ +# +# compiler settings for iOS/tvOS/watchOS clang compilers +# diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..852a7e5d1c3106ed1a2823df78e8ebb7c1160a83 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/uikit/qmake.conf @@ -0,0 +1,23 @@ +# +# Common build settings for all iOS/tvOS/watchOS configurations +# + +QMAKE_XCODE_CODE_SIGN_IDENTITY = "iPhone Developer" + +# iOS build tools +QMAKE_CC = clang +QMAKE_CXX = clang++ +QMAKE_FIX_RPATH = install_name_tool -id +QMAKE_AR = ar cq +QMAKE_RANLIB = ranlib -s +QMAKE_LINK = $$QMAKE_CXX +QMAKE_LINK_SHLIB = $$QMAKE_CXX + +# OpenGL ES2 +QMAKE_INCDIR_OPENGL_ES2 = +QMAKE_LIBDIR_OPENGL_ES2 = +QMAKE_LIBS_OPENGL_ES2 = -framework OpenGLES + +# No desktop OpenGL +QMAKE_INCDIR_OPENGL = +QMAKE_LIBS_OPENGL = diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/vxworks/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/vxworks/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..749c1377cd95724ec6a58973aecfa68ac9c5cbdd --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/vxworks/qplatformdefs.h @@ -0,0 +1,52 @@ +// Copyright (C) 2023 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_VXWORKS_PLATFORMDEFS_H +#define Q_VXWORKS_PLATFORMDEFS_H + +#include "qglobal.h" + +#include +#include + +#include +#include +#include + +// from VxWorks 7 +#ifndef S_ISSOCK +# ifdef S_IFSOCK +# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK) +# else +# define S_ISSOCK(m) 0 +# endif +#endif + +#include "../common/posix/qplatformdefs.h" + +#undef QT_OPEN_LARGEFILE + +#define O_LARGEFILE 0 +#define QT_OPEN_LARGEFILE O_LARGEFILE + +#define QT_MMAP ::mmap + +#define QT_SNPRINTF ::snprintf +#define QT_VSNPRINTF ::vsnprintf + +#define S_ISVTX 01000 + +/* + * vxworks introduces some defines that replace READ with 0 and WRITE with 1 + * this causes issues with moc and Q_PROPERTY + */ +#undef READ +#undef WRITE + +/* vxworks exposes these definitions only when _POSIX_C_SOURCE >=200809L but we don't want to set this, as it hides other API */ +#ifndef UTIME_NOW +# define UTIME_NOW ((1l << 30) - 1l) +# define UTIME_OMIT ((1l << 30) - 2l) +#endif + +#endif /* Q_VXWORKS_PLATFORMDEFS_H */ diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/wasm/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/common/wasm/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..fd4f9e1f41f887d85d45ca7cf17f698305fb1743 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/wasm/qplatformdefs.h @@ -0,0 +1,143 @@ +// Copyright (C) 2018 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef Q_WASM_PLATFORMDEFS_H +#define Q_WASM_PLATFORMDEFS_H + +// Get Qt defines/settings + +#include "qglobal.h" + +// Set any POSIX/XOPEN defines at the top of this file to turn on specific APIs + +// 1) need to reset default environment if _BSD_SOURCE is defined +// 2) need to specify POSIX thread interfaces explicitly in glibc 2.0 +// 3) it seems older glibc need this to include the X/Open stuff + +#include + +// We are hot - unistd.h should have turned on the specific APIs we requested + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#ifndef QT_NO_IPV6IFNAME +#include +#endif + +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +#ifdef QT_LARGEFILE_SUPPORT +#define QT_STATBUF struct stat64 +#define QT_STATBUF4TSTAT struct stat64 +#define QT_STAT ::stat64 +#define QT_FSTAT ::fstat64 +#define QT_LSTAT ::lstat64 +#define QT_OPEN ::open64 +#define QT_TRUNCATE ::truncate64 +#define QT_FTRUNCATE ::ftruncate64 +#define QT_LSEEK ::lseek64 +#else +#define QT_STATBUF struct stat +#define QT_STATBUF4TSTAT struct stat +#define QT_STAT ::stat +#define QT_FSTAT ::fstat +#define QT_LSTAT ::lstat +#define QT_OPEN ::open +#define QT_TRUNCATE ::truncate +#define QT_FTRUNCATE ::ftruncate +#define QT_LSEEK ::lseek +#endif + +#ifdef QT_LARGEFILE_SUPPORT +#define QT_FOPEN ::fopen64 +#define QT_FSEEK ::fseeko64 +#define QT_FTELL ::ftello64 +#define QT_FGETPOS ::fgetpos64 +#define QT_FSETPOS ::fsetpos64 +#define QT_MMAP ::mmap64 +#define QT_FPOS_T fpos64_t +#define QT_OFF_T off64_t +#else +#define QT_FOPEN ::fopen +#define QT_FSEEK ::fseek +#define QT_FTELL ::ftell +#define QT_FGETPOS ::fgetpos +#define QT_FSETPOS ::fsetpos +#define QT_MMAP ::mmap +#define QT_FPOS_T fpos_t +#define QT_OFF_T long +#endif + +#define QT_STAT_REG S_IFREG +#define QT_STAT_DIR S_IFDIR +#define QT_STAT_MASK S_IFMT +#define QT_STAT_LNK S_IFLNK +#define QT_SOCKET_CONNECT ::connect +#define QT_SOCKET_BIND ::bind +#define QT_FILENO fileno +#define QT_CLOSE ::close +#define QT_READ ::read +#define QT_WRITE ::write +#define QT_ACCESS ::access +#define QT_GETCWD ::getcwd +#define QT_CHDIR ::chdir +#define QT_MKDIR ::mkdir +#define QT_RMDIR ::rmdir +#define QT_OPEN_LARGEFILE O_LARGEFILE +#define QT_OPEN_RDONLY O_RDONLY +#define QT_OPEN_WRONLY O_WRONLY +#define QT_OPEN_RDWR O_RDWR +#define QT_OPEN_CREAT O_CREAT +#define QT_OPEN_TRUNC O_TRUNC +#define QT_OPEN_APPEND O_APPEND +#define QT_OPEN_EXCL O_EXCL + +// Directory iteration +#define QT_DIR DIR + +#define QT_OPENDIR ::opendir +#define QT_CLOSEDIR ::closedir + +#if defined(QT_LARGEFILE_SUPPORT) \ + && defined(QT_USE_XOPEN_LFS_EXTENSIONS) \ + && !defined(QT_NO_READDIR64) +#define QT_DIRENT struct dirent64 +#define QT_READDIR ::readdir64 +#else +#define QT_DIRENT struct dirent +#define QT_READDIR ::readdir +#endif + +#define QT_SOCKET_CONNECT ::connect +#define QT_SOCKET_BIND ::bind + + +#define QT_SIGNAL_RETTYPE void +#define QT_SIGNAL_ARGS int +#define QT_SIGNAL_IGNORE SIG_IGN + +#define QT_SOCKLEN_T socklen_t + +#if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500) +#define QT_SNPRINTF ::snprintf +#define QT_VSNPRINTF ::vsnprintf +#endif + +#endif // Q_WASM_PLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/common/wasm/wasm.conf b/qt/6.8.1/msvc2022_64/mkspecs/common/wasm/wasm.conf new file mode 100644 index 0000000000000000000000000000000000000000..fc4c946be740197ea86ad926115fc2cee1e893a2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/common/wasm/wasm.conf @@ -0,0 +1,85 @@ +# qmake configuration for building with emscripten +MAKEFILE_GENERATOR = UNIX +QMAKE_PLATFORM = wasm unix + +include(../gcc-base.conf) +include(../clang.conf) + +load(device_config) +load(emcc_ver) + +# Support enabling asyncify by configuring with "-device-option QT_EMSCRIPTEN_ASYNCIFY=1" +!isEmpty(QT_EMSCRIPTEN_ASYNCIFY): { + !equals(QT_EMSCRIPTEN_ASYNCIFY, 1):!equals(QT_EMSCRIPTEN_ASYNCIFY, 0): \ + message(Error: The value for QT_EMSCRIPTEN_ASYNCIFY must be 0 or 1) + equals(QT_EMSCRIPTEN_ASYNCIFY, 1): { + QMAKE_CFLAGS += -DQT_HAVE_EMSCRIPTEN_ASYNCIFY + QMAKE_CXXFLAGS += -DQT_HAVE_EMSCRIPTEN_ASYNCIFY + QMAKE_LFLAGS += -s ASYNCIFY + + # Emscripten recommends building with optimizations when using asyncify + # in order to reduce wasm file size, and may also generate broken wasm + # (with "wasm validation error: too many locals" type errors) if optimizations + # are omitted. Enable optimizations also for debug builds. + QMAKE_LFLAGS_DEBUG += -Os + } +} + +# Declare async functions +QMAKE_LFLAGS += -s ASYNCIFY_IMPORTS=qt_asyncify_suspend_js,qt_asyncify_resume_js + +EMCC_COMMON_LFLAGS += \ + -s WASM=1 \ + -s MAX_WEBGL_VERSION=2 \ + -s ERROR_ON_UNDEFINED_SYMBOLS=1 \ + --bind \ + -s FETCH=1 \ + -s MODULARIZE=1 \ + -s WASM_BIGINT=1 \ + -s STACK_SIZE=5MB + +# The -s arguments can also be used with release builds, +# but are here in debug for clarity. +EMCC_COMMON_LFLAGS_DEBUG = \ + $$EMCC_COMMON_LFLAGS \ + # -s LIBRARY_DEBUG=1 \ #print out library calls, verbose + # -s SYSCALL_DEBUG=1 \ #print out sys calls, verbose + # -s FS_LOG=1 \ #print out filesystem ops, verbose + # -s SOCKET_DEBUG \ #print out socket,network data transfer + # -s GL_DEBUG=1 \ + --profiling-funcs + +QMAKE_LFLAGS_DEBUG += -g2 +QMAKE_LFLAGS_RELEASE += -O2 + +QMAKE_COMPILER += emscripten + +QMAKE_CC = emcc +QMAKE_CXX = em++ + +QMAKE_LINK = $$QMAKE_CXX +QMAKE_LINK_SHLIB = $$QMAKE_CXX +QMAKE_LINK_C = $$QMAKE_CC +QMAKE_LINK_C_SHLIB = $$QMAKE_CC + +QMAKE_LIBS_THREAD = $$QMAKE_CFLAGS_THREAD + +QMAKE_LFLAGS += $$EMCC_COMMON_LFLAGS +QMAKE_LFLAGS_DEBUG += $$EMCC_COMMON_LFLAGS_DEBUG + +QMAKE_PREFIX_SHLIB = lib +QMAKE_EXTENSION_SHLIB = so # llvm bitcode, linked to js in post_link +QMAKE_PREFIX_STATICLIB = lib +QMAKE_EXTENSION_STATICLIB = a # llvm bitcode + +QMAKE_AR = emar cqs +equals(QMAKE_HOST.os, Windows) { + QMAKE_RESPONSEFILE_THRESHOLD = 1 + QMAKE_AR_CMD = \ + "$(file >$(OBJECTS_DIR)/$(TARGET).rsp, $(subst \\,/,$(OBJECTS)))$$escape_expand(\\n\\t)" \ + "$(AR) $(DESTDIR)$(TARGET) @$(OBJECTS_DIR)/$(TARGET).rsp" +} + +QMAKE_DISTCLEAN += *.html *.js *.wasm + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/common/freebsd_device_post.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/freebsd_device_post.conf new file mode 100644 index 0000000000000000000000000000000000000000..311afb5c019a7fb7eb7a53f00d16af56ad272d95 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/freebsd_device_post.conf @@ -0,0 +1,7 @@ +defineTest(qtConfSanitizeMkspec) { + deviceSanityCheckCompiler() +} + +QMAKE_CFLAGS += $$COMPILER_FLAGS +QMAKE_CXXFLAGS += $$COMPILER_FLAGS +QMAKE_LFLAGS += $$LINKER_FLAGS diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/common/freebsd_device_pre.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/freebsd_device_pre.conf new file mode 100644 index 0000000000000000000000000000000000000000..35516bc79a291e71f97ca9657470239255d5605a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/freebsd_device_pre.conf @@ -0,0 +1,27 @@ +QT_QPA_DEFAULT_PLATFORM = bsdfb + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../freebsd-clang/qmake.conf) + +load(device_config) + +# modifications to g++-unix.conf +QMAKE_CC = $${CROSS_COMPILE}cc +QMAKE_CXX = $${CROSS_COMPILE}c++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +# modifications to linux.conf +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +# Do not set QMAKE_INCDIR to system include here +# it messes up system include order. --sysroot is +# sufficient. See link for details: +# https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=213217 +QMAKE_LIBDIR_POST = $$[QT_SYSROOT]/usr/lib diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_arm_device_post.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_arm_device_post.conf new file mode 100644 index 0000000000000000000000000000000000000000..9d0ec8d1c7cbddfe49755e849aa9ce356c3c9ae8 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_arm_device_post.conf @@ -0,0 +1,9 @@ +contains(DISTRO_OPTS, hard-float) { + COMPILER_FLAGS += -mfloat-abi=hard + LINKER_FLAGS += -mfloat-abi=hard +} else: !contains(DISTRO_OPTS, aarch64) { + COMPILER_FLAGS += -mfloat-abi=softfp + LINKER_FLAGS += -mfloat-abi=softfp +} + +include(linux_device_post.conf) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_device_post.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_device_post.conf new file mode 100644 index 0000000000000000000000000000000000000000..53d585830b32bf754d2a7afad2f3938d885c95de --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_device_post.conf @@ -0,0 +1,17 @@ +defineTest(qtConfSanitizeMkspec) { + deviceSanityCheckCompiler() +} + +contains(DISTRO_OPTS, deb-multi-arch) { + QMAKE_RPATHLINKDIR_POST += \ + $$[QT_SYSROOT]/usr/lib/$${GCC_MACHINE_DUMP} \ + $$[QT_SYSROOT]/lib/$${GCC_MACHINE_DUMP} +} + +contains(DISTRO_OPTS, boot2qt) { + QMAKE_PLATFORM += boot2qt +} + +QMAKE_CFLAGS += $$COMPILER_FLAGS +QMAKE_CXXFLAGS += $$COMPILER_FLAGS +QMAKE_LFLAGS += $$LINKER_FLAGS diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_device_pre.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_device_pre.conf new file mode 100644 index 0000000000000000000000000000000000000000..0c03d972f1733b3dcf9d5b51d3a954110b072c7b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/common/linux_device_pre.conf @@ -0,0 +1,32 @@ +QT_QPA_DEFAULT_PLATFORM = eglfs + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +!load(device_config) { + error(Could not successfully load device configuration) +} + +# modifications to g++-unix.conf +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +# modifications to linux.conf +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +# modifications to gcc-base.conf +QMAKE_AR_LTCG = $${CROSS_COMPILE}gcc-ar cqs +QMAKE_NM_LTCG = $${CROSS_COMPILE}gcc-nm -P + +contains(DISTRO_OPTS, deb-multi-arch): \ + QMAKE_PKG_CONFIG = $${CROSS_COMPILE}pkg-config diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-generic-clang/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-generic-clang/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..3cf00e3a45d44115d696e2c1748ffff2d5b3f48c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-generic-clang/qmake.conf @@ -0,0 +1,9 @@ +# +# Generic qmake configuration for cross-compiling with clang +# +# A minimal configure line could look something like this: +# ./configure -device freebsd-generic-clang -device-option CROSS_COMPILE=/usr/armv6-freebsd/usr/bin/ + +include(../common/freebsd_device_pre.conf) +include(../common/freebsd_device_post.conf) +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-generic-clang/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-generic-clang/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..6c17135615ac8c96201cd484bfdd5a64d99686df --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-generic-clang/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../common/bsd/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-rasp-pi-clang/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-rasp-pi-clang/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..19883a665eccb554599bdac9f2229eec5f107f7e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-rasp-pi-clang/qmake.conf @@ -0,0 +1,25 @@ +# qmake configuration for the Raspberry Pi and Raspberry Pi 2 + +include(../common/freebsd_device_pre.conf) + +QT_QPA_DEFAULT_PLATFORM = eglfs +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_brcm + +QMAKE_LIBDIR_OPENGL_ES2 = $$[QT_SYSROOT]/usr/local/lib +QMAKE_LIBDIR_EGL = $$QMAKE_LIBDIR_OPENGL_ES2 +QMAKE_LIBDIR_OPENVG = $$QMAKE_LIBDIR_OPENGL_ES2 + +QMAKE_INCDIR_EGL = $$[QT_SYSROOT]/usr/local/include \ + $$[QT_SYSROOT]/usr/local/include/interface/vcos/pthreads \ + $$[QT_SYSROOT]/usr/local/include/interface/vmcs_host/linux +QMAKE_INCDIR_OPENGL_ES2 = $${QMAKE_INCDIR_EGL} +QMAKE_INCDIR_OPENVG = $${QMAKE_INCDIR_EGL} + +QMAKE_LIBS_EGL = -lEGL -lGLESv2 +QMAKE_LIBS_OPENGL_ES2 = $${QMAKE_LIBS_EGL} +QMAKE_LIBS_OPENVG = -lEGL -lOpenVG -lGLESv2 + +include(../common/freebsd_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-rasp-pi-clang/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-rasp-pi-clang/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..eb7202cc5c456fdd0dcccdd1929948ef59713099 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/freebsd-rasp-pi-clang/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../freebsd-generic-clang/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-SA8155P/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-SA8155P/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..8afb697e72d7cac019dfd372c2a4281e1fb15847 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-SA8155P/qmake.conf @@ -0,0 +1,47 @@ +# +# qmake configuration for INTEGRITY Qualcomm SA8155P ADP +# + +load(device_config) + +include(../../common/ghs-integrity-armv8.conf) + +QMAKE_CFLAGS = --signed_fields --no_commons --diag_suppress=1,82,228,236,381,611,961,997,1795,1931,1974,3148,1721,1424,193,940,620,111,128,185,826,186,68,830,177,554,550,175,1441,546 --defer_parse_function_templates --exceptions +QMAKE_CXXFLAGS = $$QMAKE_CFLAGS --no_implicit_include --link_once_templates -non_shared --new_outside_of_constructor --c++17 +QMAKE_LFLAGS += --thread_local_storage --exceptions + +QT_QPA_DEFAULT_PLATFORM = eglfs +EGLFS_DEVICE_INTEGRATION = eglfs_openwfd + +qc_multimedia_inc_directory = $$(QC_MULTIMEDIA_INC_DIR) +isEmpty(qc_multimedia_inc_directory): \ + error("This makespec requires the environment variable QC_MULTIMEDIA_INC_DIR to be set.") + +QMAKE_INCDIR += $$(QC_MULTIMEDIA_INC_DIR) + +QMAKE_LIBS_EGL += -lESXEGL_Adreno -lESXGLESv2_Adreno -ladreno_utils -lGSLUser -lOSUser -lpanel -livfs -lposix -lpmem -ltzbsp -lpaged_alloc -lglnext-llvm -lopenwfd -lplanedef -llogger -lnet -lsocket -lrfs_client -lshm_client -lmmosalrfs -lmmosalfile -lOSAbstraction + +QMAKE_LIBS_OPENGL_ES2 += $${QMAKE_LIBS_EGL} + +QMAKE_CFLAGS += -DINTEGRITY +QMAKE_CXXFLAGS += -DINTEGRITY + +QMAKE_CFLAGS += -bigswitch +QMAKE_CXXFLAGS += -bigswitch +QMAKE_LFLAGS += -bigswitch + +dirs = $$(GL_INC_DIR) +isEmpty(dirs): \ + error("This makespec requires the environment variable GL_INC_DIR to be set.") + +QMAKE_INCDIR_EGL = $$split(dirs, $$QMAKE_DIRLIST_SEP) +QMAKE_INCDIR_OPENGL_ES2 = $$QMAKE_INCDIR_EGL + +dirs = $$(GL_LIB_DIR) +isEmpty(dirs): \ + error("This makespec requires the environment variable GL_LIB_DIR to be set.") + +QMAKE_LIBDIR_EGL = $$split(dirs, $$QMAKE_DIRLIST_SEP) +QMAKE_LIBDIR_OPENGL_ES2 = $$QMAKE_LIBDIR_EGL + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-SA8155P/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-SA8155P/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..f01eccf0e3cf5b793bd2acb276f0c1066fc65627 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-SA8155P/qplatformdefs.h @@ -0,0 +1,9 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QPLATFORMDEFS_H +#define QPLATFORMDEFS_H + +#include "../../common/integrity/qplatformdefs.h" + +#endif // QPLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-drive-cx/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-drive-cx/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..c32c010e0de5645e94424b3164b6fc4155cfd571 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-drive-cx/qmake.conf @@ -0,0 +1,39 @@ +# +# qmake configuration for 64-bit Tegra X1 boards, like the DRIVE CX, using Vibrante Integrity +# +# A typical configure line might look like: +# configure \ +# -device integrity-armv8-drive-cx \ +# -device-option VIBRANTE_INTEGRITY_PDK_TOPDIR=/opt/nvidia/vibrante-t186ref-integrity +# -static \ +# -opengl es2 + +load(device_config) + +include(../../common/ghs-integrity-armv8.conf) + +DEFINES += WIN_INTERFACE_CUSTOM + +QT_QPA_DEFAULT_PLATFORM = eglfs + +QMAKE_LIBS_EGL += -lEGL -lGLESv2 -lnvidia-glsi -lnvidia-eglcore -lnvidia-rmapi-tegra -lposix -livfs -ldrm-nvdc -lnvll -lnvdc -lnvrm -lnvrm_gpu -lnvrm_graphics -lnvos -lsocket -lnet -lnvtegrahv +QMAKE_LIBS_OPENGL_ES2 += $${QMAKE_LIBS_EGL} + +EGLFS_DEVICE_INTEGRATION = eglfs_kms_egldevice + +# Vibrante Integrity PDK headers & libraries +QMAKE_INCDIR += $${VIBRANTE_INTEGRITY_PDK_TOPDIR}/include +QMAKE_LIBDIR += $${VIBRANTE_INTEGRITY_PDK_TOPDIR}/libs + +# OpenGL libraries have a dependency on libEGL +QMAKE_INCDIR_EGL = $${VIBRANTE_INTEGRITY_PDK_TOPDIR}/include +QMAKE_LIBDIR_EGL = $${VIBRANTE_INTEGRITY_PDK_TOPDIR}/libs +QMAKE_INCDIR_OPENGL_ES2 = $${VIBRANTE_INTEGRITY_PDK_TOPDIR}/include +QMAKE_LIBDIR_OPENGL_ES2 = $${VIBRANTE_INTEGRITY_PDK_TOPDIR}/libs + +defineTest(qtConfSanitizeMkspec) { + isEmpty(VIBRANTE_INTEGRITY_PDK_TOPDIR): \ + error("You must pass -device-option VIBRANTE_INTEGRITY_PDK_TOPDIR=/path/to/pdk") +} + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-drive-cx/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-drive-cx/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..c4ffb053843505168214652e988615ceed4ef221 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-drive-cx/qplatformdefs.h @@ -0,0 +1,9 @@ +// Copyright (C) 2017 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QPLATFORMDEFS_H +#define QPLATFORMDEFS_H + +#include "../../common/integrity/qplatformdefs.h" + +#endif // QPLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-msm8996au/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-msm8996au/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..a074a6c76723c4318c5c8adfe8adb974cb3018f7 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-msm8996au/qmake.conf @@ -0,0 +1,59 @@ +# +# qmake configuration for INTEGRITY Qualcomm s820 Snapdragon MSM8996AU +# + +load(device_config) + +include(../../common/ghs-integrity-armv8.conf) + +QT_QPA_DEFAULT_PLATFORM = eglfs +EGLFS_DEVICE_INTEGRATION = eglfs_openwfd + +bsp_name = $$(INTEGRITY_BSP) +isEmpty(bsp_name): \ + error("This qmakespec requires $INTEGRITY_BSP to be set") + +os_directory = $$(INTEGRITY_DIR) +isEmpty(os_directory): \ + error("This qmakespec requires $INTEGRITY_DIR to be set") + +qclibs_directory = $$(QCLIBS_DIR) +isEmpty(qclibs_directory): \ + error("This qmakespec requires $QCLIBS_DIR to be set") + +qc_multimedia_inc_directory = $$(QC_MULTIMEDIA_INC_DIR) +isEmpty(qc_multimedia_inc_directory): \ + error("This qmakespec requires $QC_MULTIMEDIA_INC_DIR to be set") + +gl_inc_directory = $$(GL_INC_DIR) +isEmpty(gl_inc_directory): \ + error("This qmakespec requires $GL_INC_DIR to be set") + +gl_lib_directory = $$(GL_LIB_DIR) +isEmpty(gl_lib_directory): \ + error("This qmakespec requires $GL_LIB_DIR to be set") + +QMAKE_INCDIR += $$(QC_MULTIMEDIA_INC_DIR) + +QMAKE_LIBS_EGL += -lESXEGL_Adreno -lESXGLESv2_Adreno -ladreno_utils -lGSLUser -lOSUser -lpanel -livfs -lposix -lpmem -ltzbsp -lpaged_alloc -lglnext-llvm -lopenwfd -lplanedef -lmmosallibrary +QMAKE_LIBS_OPENGL_ES2 += $${QMAKE_LIBS_EGL} + +QMAKE_CFLAGS += -DINTEGRITY +QMAKE_CXXFLAGS += -DINTEGRITY + +QMAKE_CFLAGS += -bigswitch +QMAKE_CXXFLAGS += -bigswitch +QMAKE_LFLAGS += -bigswitch + +# OpenGL libraries have a dependency on libEGL +QMAKE_INCDIR_EGL = $$(GL_INC_DIR) +QMAKE_LIBDIR_EGL = $$(GL_LIB_DIR) +QMAKE_LIBDIR_EGL += $$(QCLIBS_DIR)/base +QMAKE_LIBDIR_EGL += $$(QCLIBS_DIR)/multimedia/display + +QMAKE_INCDIR_OPENGL_ES2 = $$(GL_INC_DIR) +QMAKE_LIBDIR_OPENGL_ES2 = $$(GL_LIB_DIR) +QMAKE_LIBDIR_OPENGL_ES2 += $$(QCLIBS_DIR)/base +QMAKE_LIBDIR_OPENGL_ES2 += $$(QCLIBS_DIR)/multimedia/display + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-msm8996au/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-msm8996au/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..c4ffb053843505168214652e988615ceed4ef221 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/integrity-armv8-msm8996au/qplatformdefs.h @@ -0,0 +1,9 @@ +// Copyright (C) 2017 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#ifndef QPLATFORMDEFS_H +#define QPLATFORMDEFS_H + +#include "../../common/integrity/qplatformdefs.h" + +#endif // QPLATFORMDEFS_H diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-archos-gen8-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-archos-gen8-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..4ba5def20f0fa1ffc756b64710c290e7167e7800 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-archos-gen8-g++/qmake.conf @@ -0,0 +1,58 @@ +# +# qmake configuration for the Archos gen8 tablets (70 and 101) +# with the SDE (Software Developer Edition) firmware +# http://www.archos.com/support/support_tech/updates_dev.html +# +# OpenEmbedded platform build system for Qt5 available at: +# http://github.com/KDAB/OpenEmbedded-Archos + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +load(device_config) + +defineTest(qtConfSanitizeMkspec) { + deviceSanityCheckCompiler() +} + +QT_QPA_DEFAULT_PLATFORM = eglfs + +# modifications to g++.conf +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +# modifications to linux.conf +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +COMPILER_FLAGS = -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=softfp + +#modifications to gcc-base.conf +QMAKE_CFLAGS += $${COMPILER_FLAGS} +QMAKE_CXXFLAGS += $${COMPILER_FLAGS} +QMAKE_CXXFLAGS_RELEASE += -O3 + +QMAKE_LIBS += -lrt -lpthread -ldl + +# Extra stuff (OpenGL, DirectFB, ...) +QMAKE_INCDIR_EGL = $$[QT_SYSROOT]/usr/include +QMAKE_LIBDIR_EGL = $$[QT_SYSROOT]/usr/lib +QMAKE_INCDIR_OPENGL_ES2 = $${QMAKE_INCDIR_EGL} +QMAKE_LIBDIR_OPENGL_ES2 = $${QMAKE_LIBDIR_EGL} +QMAKE_INCDIR_OPENVG = $${QMAKE_INCDIR_EGL} +QMAKE_LIBDIR_OPENVG = $${QMAKE_LIBDIR_EGL} + +QMAKE_LIBS_EGL = -lEGL -lIMGegl -lsrv_um +QMAKE_LIBS_OPENGL_ES2 = -lGLESv2 $${QMAKE_LIBS_EGL} +QMAKE_LIBS_OPENVG = -lOpenVG $${QMAKE_LIBS_EGL} + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-archos-gen8-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-archos-gen8-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-archos-gen8-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qeglfshooks_8726m.cpp b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qeglfshooks_8726m.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6d155f4cca624d4a3619d5fed615103860a4bdb6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qeglfshooks_8726m.cpp @@ -0,0 +1,60 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "private/qeglfshooks_p.h" +#include +#include +#include +#include +#include +#include +#include + +QT_BEGIN_NAMESPACE + +class QEglFS8726MHooks : public QEglFSHooks +{ +public: + virtual QSize screenSize() const; + virtual EGLNativeWindowType createNativeWindow(QPlatformWindow *window, const QSize &size, const QSurfaceFormat &format); + virtual void destroyNativeWindow(EGLNativeWindowType window); +}; + +QSize QEglFS8726MHooks::screenSize() const +{ + int fd = open("/dev/fb0", O_RDONLY); + if (fd == -1) { + qFatal("Failed to open fb to detect screen resolution!"); + } + + struct fb_var_screeninfo vinfo; + if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo) == -1) { + qFatal("Could not get variable screen info"); + } + + close(fd); + + return QSize(vinfo.xres, vinfo.yres); +} + +EGLNativeWindowType QEglFS8726MHooks::createNativeWindow(QPlatformWindow *window, const QSize &size, const QSurfaceFormat &format) +{ + Q_UNUSED(window); + Q_UNUSED(format); + + fbdev_window *window = new fbdev_window; + window->width = size.width(); + window->height = size.height(); + + return window; +} + +void QEglFS8726MHooks::destroyNativeWindow(EGLNativeWindowType window) +{ + delete window; +} + +QEglFS8726MHooks eglFS8726MHooks; +QEglFSHooks *platformHooks = &eglFS8726MHooks; + +QT_END_NAMESPACE diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..1b15d2f0721da5e7605db7e09b1a407239e569f1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qmake.conf @@ -0,0 +1,36 @@ +# +# qmake configuration for linux-g++ +# + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +load(device_config) + +defineTest(qtConfSanitizeMkspec) { + deviceSanityCheckCompiler() +} + +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +QMAKE_CFLAGS += -mfloat-abi=softfp -mfpu=neon -mcpu=cortex-a9 +QMAKE_CXXFLAGS += $$QMAKE_CFLAGS + +EGLFS_PLATFORM_HOOKS_SOURCES = $$PWD/qeglfshooks_8726m.cpp + +QT_QPA_DEFAULT_PLATFORM = eglfs + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..44907260081bce53885faf261f677611cab97a49 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-amlogic-8726M-g++/qplatformdefs.h @@ -0,0 +1,5 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" + diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-generic-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-generic-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..fc753bd81e72eec0fbbf62a0403529b733fff543 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-generic-g++/qmake.conf @@ -0,0 +1,9 @@ +# +# Generic qmake configuration for building with g++ on arm devices. +# +# A minimal configure line could look something like this: +# ./configure -device arm-generic-g++ -device-option CROSS_COMPILE=arm-linux-gnueabi- + +include(../common/linux_device_pre.conf) +include(../common/linux_arm_device_post.conf) +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-generic-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-generic-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-generic-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-hisilicon-hix5hd2-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-hisilicon-hix5hd2-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..dec13209b5128bdeccfc0aa34a7fa116d156283c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-hisilicon-hix5hd2-g++/qmake.conf @@ -0,0 +1,46 @@ +# +# qmake configuration for linux-arm-hisilicon-hix5hd2-g++ using the arm-linux-gnueabihf-g++ crosscompiler +# +# A typical configure line looks like this: +# /configure -opensource -confirm-license -release -make libs -make examples -optimized-qmake +# -platform linux-g++-64 -device linux-arm-hisilicon-hix5hd2-g++ -device-option CROSS_COMPILE=arm-linux-gnueabihf- +# -opengl es2 -no-qml-debug -no-directfb -no-kms -no-xcb -no-alsa -qt-zlib -qt-libjpeg -qt-libpng +# -no-icu -no-nis -sysroot -extprefix -hostprefix +# -prefix +# +# such as +# ./configure -opensource -confirm-license -release -make libs -make examples -optimized-qmake +# -platform linux-g++-64 -device linux-arm-hisilicon-hix5hd2-g++ -device-option CROSS_COMPILE=arm-linux-gnueabihf- +# -opengl es2 -no-qml-debug -no-directfb -no-kms -no-xcb -no-alsa -qt-zlib -qt-libjpeg -qt-libpng +# -no-icu -no-nis -sysroot /home/abc/project/sysbase +# -extprefix /home/abc/project/sysbase/qt_install +# -hostprefix /home/abc/project/qtdir/qtbase_hostinstall +# -prefix /home/abc/project/sysbase/qt_install + +include(../common/linux_device_pre.conf) + +QMAKE_INCDIR_POST += /usr/arm-linux-gnueabihf/include +QMAKE_LIBDIR_POST += /usr/arm-linux-gnueabihf/lib + +QMAKE_LIBS += -lrt + +QMAKE_INCDIR_EGL += $$[QT_SYSROOT]/egl/include +QMAKE_LIBDIR_EGL += $$[QT_SYSROOT]/egl/lib +QMAKE_INCDIR_OPENGL_ES2 += $$QMAKE_INCDIR_EGL +QMAKE_LIBDIR_OPENGL_ES2 += $$QMAKE_LIBDIR_EGL + +QMAKE_LIBS_EGL += -lMali +QMAKE_LIBS_OPENGL_ES2 += $$QMAKE_LIBS_EGL +QMAKE_LIBS_OPENVG += $$QMAKE_LIBS_EGL + +DISTRO_OPTS += hard-float + +QMAKE_CFLAGS +=-march=armv7-a -mcpu=cortex-a9 -mfpu=vfpv3-d16 +QMAKE_CXXFLAGS += $$QMAKE_CFLAGS + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_mali + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-hisilicon-hix5hd2-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-hisilicon-hix5hd2-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-hisilicon-hix5hd2-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-trident-pnx8473-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-trident-pnx8473-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..bab800ae3e824dfe61234e8dd2179415c1a2f26b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-trident-pnx8473-g++/qmake.conf @@ -0,0 +1,68 @@ +# +# qmake configuration for building with arm-linux-uclibcgnueabi-g++ +# +# http://wiki.qt.io/Shiner +# + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +load(device_config) + +defineTest(qtConfSanitizeMkspec) { + isEmpty(TRIDENT_SHINER_SDK_BUILDTREE): \ + error("TRIDENT_SHINER_SDK_BUILDTREE needs to be set via -device-option TRIDENT_SHINER_SDK_BUILDTREE=") + isEmpty(TRIDENT_SHINER_SDK_BUILDSPEC): \ + error("TRIDENT_SHINER_SDK_BUILDSPEC needs to be set via -device-option TRIDENT_SHINER_SDK_BUILDSPEC=") + isEmpty(TRIDENT_SHINER_SDK_INCDIR_EGL_OPENGL_ES2): \ + error("TRIDENT_SHINER_SDK_INCDIR_EGL_OPENGL_ES2 needs to be set via -device-option TRIDENT_SHINER_SDK_INCDIR_EGL_OPENGL_ES2=") + isEmpty(TRIDENT_SHINER_SDK_LIBDIR_EGL_OPENGL_ES2): \ + error("TRIDENT_SHINER_SDK_LIBDIR_EGL_OPENGL_ES2 needs to be set via -device-option TRIDENT_SHINER_SDK_LIBDIR_EGL_OPENGL_ES2=") + deviceSanityCheckCompiler() +} + +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${CROSS_COMPILE}g++ +QMAKE_LINK_SHLIB = $${CROSS_COMPILE}g++ + +# +# Usage configure options "-sysroot " with "--prefix=" results into installation of Qt at "". +# Trident Shiner SDK expects all libs to be in "Application file system" which is not +# +# Because of this fact not using "-sysroot " and hence following code is required +# +QMAKE_CFLAGS += --sysroot=$${TRIDENT_SHINER_SDK_BUILDTREE}/open_source_archive/linux/toolchains/gcc-4.5.2_uclibc/ +QMAKE_CXXFLAGS += --sysroot=$${TRIDENT_SHINER_SDK_BUILDTREE}/open_source_archive/linux/toolchains/gcc-4.5.2_uclibc/ +QMAKE_LFLAGS += --sysroot=$${TRIDENT_SHINER_SDK_BUILDTREE}/open_source_archive/linux/toolchains/gcc-4.5.2_uclibc/ + +QMAKE_CFLAGS = -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard +QMAKE_CXXFLAGS = $$QMAKE_CFLAGS + +# modifications to linux.conf +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +QMAKE_INCDIR_POST += $${TRIDENT_SHINER_SDK_BUILDTREE}/target/output/objs/$${TRIDENT_SHINER_SDK_BUILDSPEC}/comps/generic_apps/usr/include +QMAKE_LIBDIR_POST += $${TRIDENT_SHINER_SDK_BUILDTREE}/target/output/objs/$${TRIDENT_SHINER_SDK_BUILDSPEC}/comps/generic_apps/usr/lib +QMAKE_LIBDIR_POST += $${TRIDENT_SHINER_SDK_BUILDTREE}/target/output/objs/$${TRIDENT_SHINER_SDK_BUILDSPEC}/comps/generated/lib/armgnu_linux_el_cortex-a9 + +QMAKE_INCDIR_EGL = $${TRIDENT_SHINER_SDK_INCDIR_EGL_OPENGL_ES2} +QMAKE_LIBDIR_EGL = $${TRIDENT_SHINER_SDK_LIBDIR_EGL_OPENGL_ES2} + +QMAKE_INCDIR_OPENGL_ES2 = $${TRIDENT_SHINER_SDK_INCDIR_EGL_OPENGL_ES2} +QMAKE_LIBDIR_OPENGL_ES2 = $${TRIDENT_SHINER_SDK_LIBDIR_EGL_OPENGL_ES2} + +QMAKE_LIBS_EGL = -lEGL -lIMGegl -lsrv_um -lusc +QMAKE_LIBS_OPENGL_ES2 = $$QMAKE_LIBS_EGL -lGLESv2 -lGLES_CM + +QT_QPA_DEFAULT_PLATFORM = eglfs + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-trident-pnx8473-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-trident-pnx8473-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..44907260081bce53885faf261f677611cab97a49 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-arm-trident-pnx8473-g++/qplatformdefs.h @@ -0,0 +1,5 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" + diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-beagleboard-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-beagleboard-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..bea0a3af2f7bf8ff196aa375547bc3c89c5f7219 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-beagleboard-g++/qmake.conf @@ -0,0 +1,58 @@ +# +# qmake configuration for the BeagleBoard and BeagleBoard xM boards +# http://beagleboard.org/ + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +load(device_config) + +QT_QPA_DEFAULT_PLATFORM = eglfs + +# modifications to g++.conf +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +# modifications to linux.conf +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +COMPILER_FLAGS = -march=armv7-a -mtune=cortex-a8 -mfpu=neon -mthumb + +#modifications to gcc-base.conf +QMAKE_CFLAGS += $${COMPILER_FLAGS} +QMAKE_CXXFLAGS += $${COMPILER_FLAGS} +QMAKE_CXXFLAGS_RELEASE += -O3 + +QMAKE_LIBS += -lrt -lpthread -ldl + +# Extra stuff (OpenGL, DirectFB, ...) +QMAKE_INCDIR_EGL = +QMAKE_LIBDIR_EGL = +QMAKE_INCDIR_OPENGL_ES2 = $${QMAKE_INCDIR_EGL} +QMAKE_LIBDIR_OPENGL_ES2 = $${QMAKE_LIBDIR_EGL} +QMAKE_INCDIR_OPENVG = $${QMAKE_INCDIR_EGL} +QMAKE_LIBDIR_OPENVG = $${QMAKE_LIBDIR_EGL} + +QMAKE_LIBS_EGL = -lEGL -lIMGegl -lsrv_um +QMAKE_LIBS_OPENGL_ES2 = -lGLESv2 $${QMAKE_LIBS_EGL} +QMAKE_LIBS_OPENVG = -lOpenVG $${QMAKE_LIBS_EGL} + +DISTRO_OPTS += hard-float + +# No need for any special EGL device integration. +# Prioritize the default, compiled-in integration over any plugins. +EGLFS_DEVICE_INTEGRATION = none + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-beagleboard-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-beagleboard-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-beagleboard-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-colibri-vf-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-colibri-vf-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..414478058ad34151ac609b2e018cd2f541f463c1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-colibri-vf-g++/qmake.conf @@ -0,0 +1,17 @@ +# +# qmake configuration for the NXP Colibri VFxx boards +# + +include(../common/linux_device_pre.conf) + +VFXX_CFLAGS = -march=armv7-a -mtune=cortex-a5 -mfpu=neon +QMAKE_CFLAGS += $$VFXX_CFLAGS +QMAKE_CXXFLAGS += $$VFXX_CFLAGS + +QT_QPA_DEFAULT_PLATFORM = linuxfb + +DISTRO_OPTS += hard-float + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-colibri-vf-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-colibri-vf-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-colibri-vf-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-drive-cx-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-drive-cx-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..d629ba3ceffe9cfd6f69fc0d8ccac3da44760277 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-drive-cx-g++/qmake.conf @@ -0,0 +1,52 @@ +# +# qmake configuration for 64-bit Tegra X1 boards, like the DRIVE CX, using Vibrante Linux +# +# A typical configure line might look like: +# configure \ +# -device drive-cx \ +# -device-option VIBRANTE_SDK_TOPDIR=/opt/nvidia/vibrante-t186ref-linux +# -device-option CROSS_COMPILE=/opt/nvidia/toolchains/tegra-4.9-nv/usr/bin/aarch64-gnu-linux/aarch64-gnu-linux- \ +# -sysroot /opt/nvidia/vibrante-t186ref-linux/targetfs \ +# -no-gcc-sysroot \ +# -opengl es2 + +# Note: This enables eglfs and wayland only. To enable xcb (with EGL +# support) as well, add -qt-xcb and fix the SDK's X11 headers. See +# QTBUG-55140. + +include(../common/linux_device_pre.conf) + +QMAKE_INCDIR_POST += \ + $${VIBRANTE_SDK_TOPDIR}/include \ + $$[QT_SYSROOT]/usr/include + +QMAKE_LIBDIR_POST += \ + $${VIBRANTE_SDK_TOPDIR}/lib-target \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/lib/aarch64-linux-gnu \ + $$[QT_SYSROOT]/usr/lib/aarch64-linux-gnu + +QMAKE_RPATHLINKDIR_POST += \ + $${VIBRANTE_SDK_TOPDIR}/lib-target \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/usr/lib/aarch64-linux-gnu \ + $$[QT_SYSROOT]/lib/aarch64-linux-gnu + +DISTRO_OPTS += aarch64 + +# Do not define WIN_INTERFACE_CUSTOM here. It is suitable for drm and +# wayland, but not X11. Leave it to qt_egl_p.h instead. +COMPILER_FLAGS += -mtune=cortex-a57.cortex-a53 -march=armv8-a + +EGLFS_DEVICE_INTEGRATION = eglfs_kms_egldevice + +include(../common/linux_arm_device_post.conf) + +# override the default from linux_arm_device_post.conf +defineTest(qtConfSanitizeMkspec) { + isEmpty(VIBRANTE_SDK_TOPDIR): \ + error("You must pass -device-option VIBRANTE_SDK_TOPDIR=/path/to/sdk") + deviceSanityCheckCompiler() +} + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-drive-cx-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-drive-cx-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-drive-cx-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-emu-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-emu-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..e28284c5d7baf5e54bc771c93fec29bda148018d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-emu-g++/qmake.conf @@ -0,0 +1,29 @@ +# +# qmake configuration for the Qt Simulator for Embedded Linux +# (cross-compile for the x86-based Yocto image + use a custom EGL/GLES implementation) +# +# Example configure command: +# +# ./configure \ +# -prefix /usr/local/qt5 \ +# -hostprefix /usr/local/qt5-host \ +# -extprefix $PWD/../qt5 \ +# -device emu \ +# -device-option CROSS_COMPILE=$QT/Boot2Qt/emulator/toolchain/sysroots/x86_64-pokysdk-linux/usr/bin/i586-poky-linux/i586-poky-linux- \ +# -sysroot $QT/Boot2Qt/emulator/toolchain/sysroots/i586-poky-linux \ +# -nomake examples -nomake tests -v \ +# -release -force-debug-info \ +# -opengl es2 + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL = -lQtGlesStreamClient +QMAKE_LIBS_OPENGL_ES2 = $$QMAKE_LIBS_EGL +QMAKE_LIBS_OPENGL_ES2_DEBUG = $$QMAKE_LIBS_EGL + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_emu + +include(../common/linux_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-emu-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-emu-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-emu-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-generic-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-generic-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..d719fad9c3c3106527b349b05fdac3c1e9a9eb20 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-generic-g++/qmake.conf @@ -0,0 +1,9 @@ +# +# Generic qmake configuration for building with g++ on generic devices. +# +# A minimal configure line could look something like this: +# ./configure -device linux-generic-g++ -device-option CROSS_COMPILE=mipsel-linux-gnu- + +include(../common/linux_device_pre.conf) +include(../common/linux_device_post.conf) +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-generic-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-generic-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-generic-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx53qsb-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx53qsb-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..e6b1e98d14e658d9c6e917aa902b32d373324b56 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx53qsb-g++/qmake.conf @@ -0,0 +1,29 @@ +# +# qmake configuration for the Freescale iMX53 board +# +# This mkspec is based and tested on the Yocto Project's Poky Distribution +# with libEGL.so from Freescale without the X11 dependency. +# +# This mkspec is tested with a framebuffer (eglfs) configuration +# +# A typical configure line looks like: +# +# export PATH=/opt/imx53qsb/x86_64-linux/usr/bin/armv7a-vfp-neon-poky-linux-gnueabi:$PATH +# +# ./configure -prefix /usr/local/qt5-imx53 -hostprefix /opt/imx53qsb/x86_64-linux/usr/local/qt5-imx53 -release -device linux-imx53qsb-g++ +# -opensource -confirm-license -device-option CROSS_COMPILE=arm-poky-linux-gnueabi- -sysroot /opt/imx53qsb/sysroot +# -eglfs -no-pch -opengl es2 -no-xcb -silent + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL +QMAKE_LIBS_OPENVG += -lOpenVG -lEGL + +IMX5_CFLAGS = -march=armv7-a -mfpu=neon -DLINUX=1 -DEGL_API_FB=1 -Wno-psabi +QMAKE_CFLAGS += $$IMX5_CFLAGS +QMAKE_CXXFLAGS += $$IMX5_CFLAGS + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx53qsb-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx53qsb-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx53qsb-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx6-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx6-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..3b5c39cd285eaf0095f4d05d954795ad0fb8346f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx6-g++/qmake.conf @@ -0,0 +1,39 @@ +# +# qmake configuration for the Freescale iMX6 boards (single, dual and quad) +# +# The configuration below is set up for running with EGL on the framebuffer via +# the eglfs platform plugin and its eglfs_viv backend. + +# Wayland is also fully functional out of the box. However, when writing Wayland +# *compositors* with Qt, the eglfs backend will have to be switched to +# eglfs_viv_wl by setting the QT_QPA_EGLFS_INTEGRATION environment variable. +# +# Below is an example configure line that assumes the SDK is in +# $HOME/imx6/toolchain. On device Qt is expected to be placed under +# /usr/local/qt5 whereas on the host 'make install' will copy the host tools and +# the target libraries to $HOME/imx6/qt5. +# +# ./configure -prefix /usr/local/qt5 -extprefix $HOME/imx6/qt5 -device linux-imx6-g++ \ +# -device-option CROSS_COMPILE=$HOME/imx6/toolchain/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi- \ +# -sysroot $HOME/imx6/toolchain/sysroots/cortexa9hf-vfp-neon-poky-linux-gnueabi \ +# -nomake examples -nomake tests -v +# + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL -lGAL +QMAKE_LIBS_OPENVG += -lOpenVG -lEGL -lGAL + +IMX6_CFLAGS = -march=armv7-a -mfpu=neon -DLINUX=1 -DEGL_API_FB=1 +QMAKE_CFLAGS += $$IMX6_CFLAGS +QMAKE_CXXFLAGS += $$IMX6_CFLAGS + +DISTRO_OPTS += hard-float + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_viv + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx6-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx6-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx6-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx7-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx7-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..15da538b083e25589734b3fd56412e5612ed9f6b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx7-g++/qmake.conf @@ -0,0 +1,17 @@ +# +# qmake configuration for the NXP iMX7 boards (single, dual and quad) +# + +include(../common/linux_device_pre.conf) + +IMX7_CFLAGS = -march=armv7-a -mfpu=neon -DLINUX=1 +QMAKE_CFLAGS += $$IMX7_CFLAGS +QMAKE_CXXFLAGS += $$IMX7_CFLAGS + +DISTRO_OPTS += hard-float + +QT_QPA_DEFAULT_PLATFORM = linuxfb + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx7-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx7-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx7-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx8-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx8-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..a34a5d0410a4064a8d5d97faa4731179269b527e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx8-g++/qmake.conf @@ -0,0 +1,41 @@ +# +# qmake configuration for the NXP i.MX8 based boards (64-bit) +# +# The configuration below is set up for running with the fbdev-style +# Vivante graphics stack. (so eglfs with the eglfs_viv backend, no +# direct drm use via eglfs_kms) + +# Wayland should also be functional. However, when writing Wayland +# *compositors* with Qt, the eglfs backend will have to be switched to +# eglfs_viv_wl by setting the QT_QPA_EGLFS_INTEGRATION environment +# variable. +# +# Below is an example configure line that assumes there is an AArch64 +# toolchain and sysroot available in $HOME/imx8. On device Qt is +# expected to be placed under /usr/local/qt514 whereas on the host +# 'make install' will copy the host tools and the target libraries to +# $HOME/imx8/qt5. +# +# ./configure -release -opengl es2 -device linux-imx8-g++ \ +# -device-option CROSS_COMPILE=~/imx8/toolchain/x86_64-pokysdk-linux/usr/bin/aarch64-poky-linux/aarch64-poky-linux- \ +# -sysroot ~/imx8/sysroot \ +# -opensource -confirm-license -make libs -prefix /usr/local/qt514 -extprefix ~/imx8/qt5 -v + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL -lGAL +QMAKE_LIBS_OPENVG += -lOpenVG -lEGL -lGAL + +IMX8_CFLAGS = -march=armv8-a -mtune=cortex-a72.cortex-a53 -DLINUX=1 -DEGL_API_FB=1 +QMAKE_CFLAGS += $$IMX8_CFLAGS +QMAKE_CXXFLAGS += $$IMX8_CFLAGS + +DISTRO_OPTS += aarch64 + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_viv + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx8-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx8-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-imx8-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..5c8f35b04d691b337c1fe99874b431940f73c708 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-g++/qmake.conf @@ -0,0 +1,34 @@ +# +# qmake configuration for the Jetson TK1 boards running Linux For Tegra +# +# Note that this environment has been tested with X11 only. +# +# A typical configure line might look like: +# configure \ +# -device linux-jetson-tk1-g++ \ +# -device-option CROSS_COMPILE=/opt/nvidia/toolchains/tegra-4.8.1-nv/usr/bin/arm-cortex_a15-linux-gnueabi/arm-cortex_a15-linux-gnueabi- \ +# -sysroot /opt/nvidia/l4t/targetfs + +include(../common/linux_device_pre.conf) + +QMAKE_INCDIR_POST += \ + $$[QT_SYSROOT]/usr/include \ + $$[QT_SYSROOT]/usr/include/arm-linux-gnueabihf + +QMAKE_LIBDIR_POST += \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/lib/arm-linux-gnueabihf \ + $$[QT_SYSROOT]/usr/lib/arm-linux-gnueabihf + +QMAKE_RPATHLINKDIR_POST += \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/usr/lib/arm-linux-gnueabihf \ + $$[QT_SYSROOT]/lib/arm-linux-gnueabihf + +DISTRO_OPTS += hard-float +COMPILER_FLAGS += -mtune=cortex-a15 -march=armv7-a -mfpu=neon-vfpv4 + +EGLFS_DEVICE_INTEGRATION = eglfs_kms_egldevice + +include(../common/linux_arm_device_post.conf) +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-pro-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-pro-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..800cac6aba8b67eb0151ece55c988687cf6529d5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-pro-g++/qmake.conf @@ -0,0 +1,47 @@ +# +# qmake configuration for the Jetson TK1 Pro boards running Vibrante Linux +# +# This environment supports eglfs (via DRM, EGLDevice, and EGLStream), +# Wayland (requires an EGLStream-capable compositor), and X11 (untested). +# +# A typical configure line might look like: +# configure \ +# -device jetson-tk1-pro \ +# -device-option VIBRANTE_SDK_TOPDIR=/opt/nvidia/vibrante-vcm30t124-linux +# -device-option CROSS_COMPILE=/opt/nvidia/toolchains/tegra-4.8.1-nv/usr/bin/arm-cortex_a15-linux-gnueabi/arm-cortex_a15-linux-gnueabi- \ +# -sysroot /opt/nvidia/vibrante-vcm30t124-linux/targetfs \ +# -no-gcc-sysroot + +include(../common/linux_device_pre.conf) + +QMAKE_INCDIR_POST += \ + $${VIBRANTE_SDK_TOPDIR}/include \ + $$[QT_SYSROOT]/usr/include + +QMAKE_LIBDIR_POST += \ + $${VIBRANTE_SDK_TOPDIR}/lib-target \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/lib/arm-linux-gnueabihf \ + $$[QT_SYSROOT]/usr/lib/arm-linux-gnueabihf + +QMAKE_RPATHLINKDIR_POST += \ + $${VIBRANTE_SDK_TOPDIR}/lib-target \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/usr/lib/arm-linux-gnueabihf \ + $$[QT_SYSROOT]/lib/arm-linux-gnueabihf + +DISTRO_OPTS += hard-float +COMPILER_FLAGS += -mtune=cortex-a15 -march=armv7-a -mfpu=neon-vfpv4 -DWIN_INTERFACE_CUSTOM + +EGLFS_DEVICE_INTEGRATION = eglfs_kms_egldevice + +include(../common/linux_arm_device_post.conf) + +# override the default from linux_arm_device_post.conf +defineTest(qtConfSanitizeMkspec) { + isEmpty(VIBRANTE_SDK_TOPDIR): \ + error("You must pass -device-option VIBRANTE_SDK_TOPDIR=/path/to/sdk") + deviceSanityCheckCompiler() +} + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-pro-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-pro-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tk1-pro-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tx1-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tx1-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..76c0e746fd9ffaa0971657fa4ac82c0146357b21 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tx1-g++/qmake.conf @@ -0,0 +1,51 @@ +# +# qmake configuration for Jetson TX1 boards running 64-bit Linux For Tegra +# (tested with R24.2, sample root filesystem) +# +# Note that this environment has been tested with X11 only. +# +# A typical configure line might look like the following: +# +# configure \ +# -device linux-jetson-tx1-g++ \ +# -device-option CROSS_COMPILE=/opt/gcc-linaro-5.3.1-2016.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu- \ +# -sysroot /opt/Linux_for_Tegra/rootfs +# +# Note that this builds for GLX + OpenGL. To use EGL + OpenGL ES instead, pass +# -opengl es2 and ensure the rootfs has the headers (rootfs/usr/include/EGL, +# GLES2, GLES3), which may not be the case out of the box. +# +# Check the configure output carefully, some features may be disabled due to the +# rootfs not having the necessary dev files. +# +# If getting cryptic linker errors from static libs like libm.a, check that the +# symlinks libm.so, libz.so, etc. under rootfs/usr/lib/aarch64-linux-gnu are not +# broken. If they are, due to using absolute paths, change them so that they are +# relative to rootfs. + +include(../common/linux_device_pre.conf) + +QMAKE_INCDIR_POST += \ + $$[QT_SYSROOT]/usr/include \ + $$[QT_SYSROOT]/usr/include/aarch64-linux-gnu + +QMAKE_LIBDIR_POST += \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/lib/aarch64-linux-gnu \ + $$[QT_SYSROOT]/usr/lib/aarch64-linux-gnu + +QMAKE_RPATHLINKDIR_POST += \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/usr/lib/aarch64-linux-gnu \ + $$[QT_SYSROOT]/usr/lib/aarch64-linux-gnu/tegra \ + $$[QT_SYSROOT]/lib/aarch64-linux-gnu + +DISTRO_OPTS += aarch64 +COMPILER_FLAGS += -mtune=cortex-a57.cortex-a53 -march=armv8-a + +# When configured with -opengl es2, eglfs will be functional with its +# dummy fullscreen X11 backend, in addition to xcb. +EGLFS_DEVICE_INTEGRATION = eglfs_x11 + +include(../common/linux_arm_device_post.conf) +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tx1-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tx1-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-jetson-tx1-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qdirectfbeglhooks_bcm97425.cpp b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qdirectfbeglhooks_bcm97425.cpp new file mode 100644 index 0000000000000000000000000000000000000000..dd988d569cd5047618837bc75b47f3e15a32098d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qdirectfbeglhooks_bcm97425.cpp @@ -0,0 +1,36 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "qdirectfbeglhooks.h" +#include "qdirectfbconvenience.h" + +#include "default_directfb.h" + +QT_BEGIN_NAMESPACE + +// Exported to the directfb plugin +QDirectFBEGLHooks platform_hook; +static void *dbpl_handle; + +void QDirectFBEGLHooks::platformInit() +{ + DBPL_RegisterDirectFBDisplayPlatform(&dbpl_handle, QDirectFbConvenience::dfbInterface()); +} + +void QDirectFBEGLHooks::platformDestroy() +{ + DBPL_UnregisterDirectFBDisplayPlatform(dbpl_handle); + dbpl_handle = 0; +} + +bool QDirectFBEGLHooks::hasCapability(QPlatformIntegration::Capability cap) const +{ + switch (cap) { + case QPlatformIntegration::ThreadedOpenGL: + return true; + default: + return false; + } +} + +QT_END_NAMESPACE diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..b5494be7ba90c1a79178fb57fe2fd5da1a5de36d --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qmake.conf @@ -0,0 +1,68 @@ +# +# qmake configuration for linux-mipsel-broadcom-97425-g++ +# + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +load(device_config) + +defineTest(qtConfSanitizeMkspec) { + isEmpty(B_REFSW_DEBUG): \ + error("B_REFSW_DEBUG needs to be set via -device-option B_REFSW_DEBUG=(y|n)") + isEmpty(BRCM_ROCKFORD_PATH): \ + error("BRCM_ROCKFORD_PATH needs to be set via -device-option BRCM_ROCKFORD_PATH=") + isEmpty(BRCM_APPLIBS_PATH): \ + error("BRCM_APPLIBS_PATH needs to be set via -device-option BRCM_APPLIBS_PATH=") + deviceSanityCheckCompiler() +} + +# Modify the defaults we loaded above +CROSS_COMPILE = mipsel-linux- +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +#TODO: Clean Qt to work with uclibc not calling itself GLIBC. +#QMAKE_CFLAGS += -D__FORCE_NOGLIBC +#QMAKE_CXXFLAGS += -D__FORCE_NOGLIBC + + +BRCM_PLATFORM = 97425 + +# Figure the kind of directfb build used. +BRCM_BUILD_TYPE = debug +contains(B_REFSW_DEBUG, [Nn]) { + BRCM_BUILD_TYPE = release +} + +QMAKE_INCDIR_OPENGL_ES2 = $${BRCM_ROCKFORD_PATH}/middleware/v3d/interface/khronos/include +QMAKE_LIBDIR_OPENGL_ES2 = $${BRCM_ROCKFORD_PATH}/middleware/v3d/lib_$${BRCM_PLATFORM}_$${BRCM_BUILD_TYPE} +QMAKE_LIBS_OPENGL_ES2 = -lv3ddriver -lrt +QMAKE_LIBS_EGL = + +QMAKE_INCDIR_POST += $${BRCM_APPLIBS_PATH}/opensource/zlib/zlib-1.2.3 +QMAKE_LIBDIR_POST += $${BRCM_APPLIBS_PATH}/opensource/zlib/zlib-1.2.3 +QMAKE_RPATHLINKDIR_POST += $$QMAKE_LIBDIR_OPENGL_ES2 $${BRCM_APPLIBS_PATH}/opensource/zlib/zlib-1.2.3 + +# DirectFB platform hooks for this hardware +QT_CONFIG += directfb_egl egl +DIRECTFB_PLATFORM_HOOKS_SOURCES = $$PWD/qdirectfbeglhooks_bcm97425.cpp +DIRECTFB_PLATFORM_HOOKS_INCLUDEPATH = $${BRCM_ROCKFORD_PATH}/middleware/platform/directfb +DIRECTFB_PLATFORM_HOOKS_LIBS = -ldbpl +DIRECTFB_PLATFORM_HOOKS_LIBDIR = $${BRCM_ROCKFORD_PATH}/middleware/platform/directfb/lib_$${BRCM_PLATFORM}_$${BRCM_BUILD_TYPE} + +QT_QPA_DEFAULT_PLATFORM = directfbegl + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-broadcom-97425-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-ci20-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-ci20-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..639313384b6fc1f0857d340483c170e8e426f8ba --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-ci20-g++/qmake.conf @@ -0,0 +1,21 @@ +# +# qmake configuration for building with mips-mti-linux-gnu-g++ +# build for CI20 targets X11 +# + +CROSS_COMPILE = mips-mti-linux-gnu- + +include(../common/linux_device_pre.conf) + +QMAKE_CFLAGS = -EL -march=mips32r2 +QMAKE_CXXFLAGS = $${QMAKE_CFLAGS} +QMAKE_LFLAGS = -EL + +QT_QPA_DEFAULT_PLATFORM = xcb + +QMAKE_LIBS_EGL = -lEGL -lIMGegl -lusc +QMAKE_LIBS_OPENGL_ES2 = -lGLESv2 $${QMAKE_LIBS_EGL} + +include(../common/linux_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-ci20-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-ci20-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-mipsel-ci20-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-nuc-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-nuc-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..104c797cb48c8d92e69daa72cee81870c7b96e36 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-nuc-g++/qmake.conf @@ -0,0 +1,20 @@ +# +# qmake configuration for the Intel NUC DE3815TYKE targeting EGL/GLES either via KMS (eglfs) or Wayland +# +# Verified with a core-image-weston image produced by Yocto. + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL + +NUC_CFLAGS = -m64 +QMAKE_CFLAGS += $$NUC_CFLAGS +QMAKE_CXXFLAGS += $$NUC_CFLAGS + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_kms + +include(../common/linux_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-nuc-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-nuc-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-nuc-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-odroid-xu3-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-odroid-xu3-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..f0b8ab3acd480d4c593b1450d2423a5cd6b02b39 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-odroid-xu3-g++/qmake.conf @@ -0,0 +1,17 @@ +# +# qmake configuration for linux-odroid-xu3-g++ using the arm-linux-gnueabihf-g++ crosscompiler +# + +include(../common/linux_device_pre.conf) + +DISTRO_OPTS += hard-float + +QMAKE_CFLAGS += -mcpu=cortex-a15 -mfpu=neon-vfpv4 -marm +QMAKE_CXXFLAGS += $$QMAKE_CFLAGS + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_mali + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-odroid-xu3-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-odroid-xu3-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-odroid-xu3-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..430c4f0e9896a661afaa161bd4d92cc4491ac815 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi-g++/qmake.conf @@ -0,0 +1,52 @@ +# qmake configuration for: +# - Raspberry PI +# - Raspberry PI Zero +# http://wiki.qt.io/RaspberryPi + +include(../common/linux_device_pre.conf) + +QMAKE_RPATHLINKDIR_POST += $$[QT_SYSROOT]/opt/vc/lib + +QMAKE_LIBDIR_OPENGL_ES2 = $$[QT_SYSROOT]/opt/vc/lib +QMAKE_LIBDIR_EGL = $$QMAKE_LIBDIR_OPENGL_ES2 +QMAKE_LIBDIR_OPENVG = $$QMAKE_LIBDIR_OPENGL_ES2 + +QMAKE_INCDIR_EGL = $$[QT_SYSROOT]/opt/vc/include \ + $$[QT_SYSROOT]/opt/vc/include/interface/vcos/pthreads \ + $$[QT_SYSROOT]/opt/vc/include/interface/vmcs_host/linux +QMAKE_INCDIR_OPENGL_ES2 = $${QMAKE_INCDIR_EGL} +QMAKE_INCDIR_OPENVG = $${QMAKE_INCDIR_EGL} + +QMAKE_LIBS_EGL = -lEGL -lGLESv2 +QMAKE_LIBS_OPENVG = -lEGL -lOpenVG -lGLESv2 + +QMAKE_INCDIR_BCM_HOST = $$[QT_SYSROOT]/opt/vc/include +QMAKE_LIBDIR_BCM_HOST = $$[QT_SYSROOT]/opt/vc/lib +QMAKE_LIBS_BCM_HOST = -lbcm_host + +contains(DISTRO, squeeze) { + #Debian Squeeze: Legacy everything + QMAKE_LIBS_OPENGL_ES2 = -lGLESv2 -lEGL +} else:contains(DISTRO, arch) { + #On principle: no wizardry required +} else { + #This is not strictly necessary + DISTRO_OPTS += deb-multi-arch + DISTRO_OPTS += hard-float +} + +QMAKE_CFLAGS += \ + -marm \ + -mfpu=vfp \ + -mtune=arm1176jzf-s \ + -march=armv6zk \ + -mabi=aapcs-linux + +QMAKE_CXXFLAGS = $$QMAKE_CFLAGS + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_brcm + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi2-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi2-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..5e80d27db5bf8f004647c6897953a362643343ff --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi2-g++/qmake.conf @@ -0,0 +1,35 @@ +# qmake configuration for the Raspberry Pi 2 + +include(../common/linux_device_pre.conf) + +QMAKE_RPATHLINKDIR_POST += $$[QT_SYSROOT]/opt/vc/lib + +QMAKE_LIBDIR_OPENGL_ES2 = $$[QT_SYSROOT]/opt/vc/lib +QMAKE_LIBDIR_EGL = $$QMAKE_LIBDIR_OPENGL_ES2 +QMAKE_LIBDIR_OPENVG = $$QMAKE_LIBDIR_OPENGL_ES2 + +QMAKE_INCDIR_EGL = $$[QT_SYSROOT]/opt/vc/include \ + $$[QT_SYSROOT]/opt/vc/include/interface/vcos/pthreads \ + $$[QT_SYSROOT]/opt/vc/include/interface/vmcs_host/linux +QMAKE_INCDIR_OPENGL_ES2 = $${QMAKE_INCDIR_EGL} +QMAKE_INCDIR_OPENVG = $${QMAKE_INCDIR_EGL} + +QMAKE_LIBS_EGL = -lEGL -lGLESv2 +QMAKE_LIBS_OPENVG = -lEGL -lOpenVG -lGLESv2 + +QMAKE_INCDIR_BCM_HOST = $$[QT_SYSROOT]/opt/vc/include +QMAKE_LIBDIR_BCM_HOST = $$[QT_SYSROOT]/opt/vc/lib +QMAKE_LIBS_BCM_HOST = -lbcm_host + +QMAKE_CFLAGS += -march=armv7-a -marm -mthumb-interwork -mfpu=neon-vfpv4 -mtune=cortex-a7 -mabi=aapcs-linux +QMAKE_CXXFLAGS = $$QMAKE_CFLAGS + +DISTRO_OPTS += hard-float +DISTRO_OPTS += deb-multi-arch + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_brcm + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi2-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi2-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi2-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..3fe443ab4ef5f42ecb615f1fb9a2620ea0e84b8f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-g++/qmake.conf @@ -0,0 +1,48 @@ +# qmake configuration for the Raspberry Pi 3 using the Broadcom graphics stack + +include(../common/linux_device_pre.conf) + +# For modern Yocto-based sysroots that have the proper include and lib +# setup in egl.pc we will pull the necessary arguments from +# there. However, to support Raspbian and older stuff that has /opt/vc +# and possibly no pkg-config, have some static values as well: + +# I consider it a bug that this is required, but our EGL config.test _requires_ it +QMAKE_RPATHLINKDIR_POST += $$[QT_SYSROOT]/opt/vc/lib + +VC_LIBRARY_PATH = /opt/vc/lib +VC_INCLUDE_PATH = =/opt/vc/include + +VC_LINK_LINE = -L=$${VC_LIBRARY_PATH} + +QMAKE_LIBDIR_OPENGL_ES2 = =$${VC_LIBRARY_PATH} +QMAKE_LIBDIR_EGL = $$QMAKE_LIBDIR_OPENGL_ES2 +QMAKE_LIBDIR_OPENVG = $$QMAKE_LIBDIR_OPENGL_ES2 + +QMAKE_INCDIR_EGL = \ + $${VC_INCLUDE_PATH} \ + $${VC_INCLUDE_PATH}/interface/vcos/pthreads \ + $${VC_INCLUDE_PATH}/interface/vmcs_host/linux + +QMAKE_INCDIR_OPENGL_ES2 = $${QMAKE_INCDIR_EGL} + +QMAKE_LIBS_OPENGL_ES2 = $${VC_LINK_LINE} -lGLESv2 + +# The official opt vc EGL references GLESv2 symbols: need to link it +QMAKE_LIBS_EGL = $${VC_LINK_LINE} -lEGL -lGLESv2 + +QMAKE_LIBDIR_BCM_HOST = =$$VC_LIBRARY_PATH +QMAKE_INCDIR_BCM_HOST = $$VC_INCLUDE_PATH +QMAKE_LIBS_BCM_HOST = -lbcm_host + +QMAKE_CFLAGS = -march=armv8-a -mtune=cortex-a53 -mfpu=crypto-neon-fp-armv8 +QMAKE_CXXFLAGS = $$QMAKE_CFLAGS + +DISTRO_OPTS += hard-float +DISTRO_OPTS += deb-multi-arch + +EGLFS_DEVICE_INTEGRATION= eglfs_brcm + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..11d3f87bfdaaec51f763dbbef5e70ecce138abdf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2017 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-vc4-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-vc4-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..3d5920e0fa4d41b09d29902d298623fe05786cbf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-vc4-g++/qmake.conf @@ -0,0 +1,44 @@ +# qmake configuration for the Raspberry Pi 3 (32-bit) using the +# *experimental* VC4 driver for Mesa and DRM. +# +# This should allow accelerated EGL and OpenGL with eglfs via +# KMS/DRM/GBM (instead of the Broadcom-specific backend), under X11 +# with xcb, and also enables (Qt)Wayland via the standard wayland-egl +# path. See https://dri.freedesktop.org/wiki/VC4 +# +# Note that this is not the same as the default, Broadcom proprietary +# driver. Some functionality and extensions may therefore be missing, +# in particular when it comes to accelerated multimedia (video, +# camera). +# +# At the time of writing Raspbian has to be switched explicitly to the +# experimental VC4 driver. To do this, run raspi-config and enable it +# in Advanced Options -> GL Driver. +# +# Example configure command below. We disable using the GNU gold +# linker as it apparently has issues with ARMv8. In the configure +# output check that "EGLFS GBM .......... yes" is present, otherwise +# eglfs will not be functional. +# +# ./configure -release -opengl es2 -device linux-rasp-pi3-vc4-g++ \ +# -device-option CROSS_COMPILE=~/raspbian/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/arm-linux-gnueabihf- \ +# -sysroot ~/raspbian/sysroot \ +# -prefix /usr/local/qt5pi -extprefix ~/raspbian/qt5pi -hostprefix ~/raspbian/qt5 \ +# -v -nomake examples -nomake tests -no-use-gold-linker + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL + +QMAKE_CFLAGS = -march=armv8-a -mtune=cortex-a53 -mfpu=crypto-neon-fp-armv8 +QMAKE_CXXFLAGS = $$QMAKE_CFLAGS + +DISTRO_OPTS += hard-float +DISTRO_OPTS += deb-multi-arch + +EGLFS_DEVICE_INTEGRATION = eglfs_kms + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-vc4-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-vc4-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..11d3f87bfdaaec51f763dbbef5e70ecce138abdf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi3-vc4-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2017 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-aarch64/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-aarch64/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..42a142405e56bcf3c7d8cec1f54b5d718dd31e81 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-aarch64/qmake.conf @@ -0,0 +1,25 @@ +# +# Generic qmake configuration for building with g++ on Raspberry Pi 4 (64-bit). +# +# Tested with Raspberry Pi OS 64-bit and aarch64 gcc compiler from Debian package repository +# +# A minimal configure line could look something like this: +# ./configure -release -opengl es2 -device linux-rasp-pi4-aarch64 -device-option CROSS_COMPILE=aarch64-linux-gnu- -sysroot ~/rpi-sysroot -prefix /usr/local/qt6 -extprefix $HOME/qt-raspi + +DISTRO_OPTS += deb-multi-arch + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL + +QMAKE_CFLAGS += -march=armv8-a +QMAKE_CXXFLAGS += $$QMAKE_CFLAGS + +EGLFS_DEVICE_INTEGRATION = eglfs_kms + +LINKER_FLAGS += -Wl,-O1 -Wl,--hash-style=gnu -Wl,--as-needed + +include(../common/linux_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-aarch64/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-aarch64/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..097ffd9087e8935569c0da9c9ded7db00f4561f0 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-aarch64/qplatformdefs.h @@ -0,0 +1,8 @@ +/**************************************************************************** +** +** Copyright (C) 2022 The Qt Company Ltd. +** SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only +** +****************************************************************************/ + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-v3d-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-v3d-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..58a803f7aa202185cca41b33b9fa2b3018eb985b --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-v3d-g++/qmake.conf @@ -0,0 +1,40 @@ +# qmake configuration for the Raspberry Pi 4 (32-bit) using the Mesa V3D +# graphics stack. (not the Broadcom stack) +# +# This supports accelerated OpenGL both for X11 and DRM/KMS. Perhaps +# Wayland too. +# +# Tested with a sysroot created from Raspbian Buster and a gcc 7.4 +# toolchain from Linaro. +# +# Example configure command line, assuming installation to +# /usr/local/qt5pi on device and ~/rpi/qt5 on the host: +# +# ./configure -release -opengl es2 -device linux-rasp-pi4-v3d-g++ -device-option CROSS_COMPILE=~/rpi/gcc-linaro-7.4.1-2019.02-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf- \ +# -sysroot ~/rpi/sysroot -opensource -confirm-license -make libs -prefix /usr/local/qt5pi -extprefix ~/rpi/qt5 -v +# +# Check the configure output carefully. EGLFS, EGLFS GBM, and EGL on X11 +# should all be 'yes'. Otherwise something is wrong. +# +# If getting linker errors like "undefined reference to `_dl_stack_flags'" check the +# symlinks in the sysroot, they were probably not adjusted +# correctly. F.ex. sysroot/usr/lib/arm-linux-gnueabihf/libpthread.so must point to +# sysroot/lib/arm-linux-gnueabihf/libpthread.so.0. If it is a broken link instead, bad +# things will happen. + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL + +QMAKE_CFLAGS = -march=armv8-a -mtune=cortex-a72 -mfpu=crypto-neon-fp-armv8 +QMAKE_CXXFLAGS = $$QMAKE_CFLAGS + +DISTRO_OPTS += hard-float +DISTRO_OPTS += deb-multi-arch + +EGLFS_DEVICE_INTEGRATION = eglfs_kms + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-v3d-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-v3d-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..11d3f87bfdaaec51f763dbbef5e70ecce138abdf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rasp-pi4-v3d-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2017 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-h2-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-h2-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..33265c215f5573430cfc2553dab6436a2d58be57 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-h2-g++/qmake.conf @@ -0,0 +1,31 @@ +# +# qmake configuration for the Renesas R-Car H2 (Lager) +# +# Both eglfs and wayland should be functional, via DRM/KMS. +# +# Below is an example configure line that assumes the SDK is in +# $HOME/rcar/toolchain. 'make install' will copy the host tools to qt5-host and +# the target contents to qt5. The latter is what should be deployed to +# /usr/local/qt5 on the target device. +# +# ./configure -prefix /usr/local/qt5 -extprefix $HOME/rcar/qt5 -hostprefix $HOME/rcar/qt5-host \ +# -device rcar-h2 \ +# -device-option CROSS_COMPILE=$HOME/rcar/toolchain/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi- \ +# -sysroot $HOME/rcar/toolchain/sysroots/cortexa15hf-neon-poky-linux-gnueabi \ +# -nomake examples -nomake tests -v + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL +QMAKE_LIBS_OPENVG += -lOpenVG -lEGL + +DISTRO_OPTS += hard-float +COMPILER_FLAGS += -mtune=cortex-a15 -march=armv7-a -mfpu=neon-vfpv4 + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_kms + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-h2-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-h2-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-h2-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-m3-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-m3-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..fdeeddfca00e13ee805e16ce3aeca44ead57d837 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-m3-g++/qmake.conf @@ -0,0 +1,17 @@ +# +# qmake configuration for the Renesas R-Car M3 +# + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL + +DISTRO_OPTS += aarch64 +COMPILER_FLAGS += -march=armv8-a -mtune=cortex-a57.cortex-a53 + +EGLFS_DEVICE_INTEGRATION = eglfs_kms + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-m3-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-m3-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..11d3f87bfdaaec51f763dbbef5e70ecce138abdf --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-rcar-m3-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2017 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7108-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7108-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..01e296cd1682748ca7316e81374693f6853c9f42 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7108-g++/qmake.conf @@ -0,0 +1,35 @@ +# +# qmake configuration for linux-g++ using the sh4-linux-g++ crosscompiler +# +# http://wiki.qt.io/ST7108 +# + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +load(device_config) + +defineTest(qtConfSanitizeMkspec) { + deviceSanityCheckCompiler() +} + +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +QMAKE_LIBS_EGL += -lMali + +QT_QPA_DEFAULT_PLATFORM = eglfs + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7108-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7108-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..44907260081bce53885faf261f677611cab97a49 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7108-g++/qplatformdefs.h @@ -0,0 +1,5 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" + diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7540-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7540-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..cf520856b199a934aeee8287afdfcfb6e980c8e9 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7540-g++/qmake.conf @@ -0,0 +1,47 @@ +# +# qmake configuration for linux-g++ using the sh4-linux-g++ crosscompiler +# +# http://wiki.qt.io/ST7540 +# + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +load(device_config) + +defineTest(qtConfSanitizeMkspec) { + deviceSanityCheckCompiler() +} + +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +QMAKE_INCDIR_EGL += $$[QT_SYSROOT]/root/modules/include/ +QMAKE_LIBDIR_EGL += $$[QT_SYSROOT]/root/modules/ + +# +# The EGL library used for ST7540 is based on DirectFB so it has to be linked with +# 1. libdirectfb.so 2. libfusion.so 3. libdirect.so +# +QMAKE_LIBS_EGL += -lMali -ldirectfb -lfusion -ldirect + +QMAKE_INCDIR_OPENGL_ES2 += $$QMAKE_INCDIR_EGL +QMAKE_LIBDIR_OPENGL_ES2 += $$QMAKE_LIBDIR_EGL +QMAKE_LIBS_OPENGL_ES2 += $$QMAKE_LIBS_EGL + +QT_QPA_DEFAULT_PLATFORM = eglfs + +load(qt_config) + diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7540-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7540-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..44907260081bce53885faf261f677611cab97a49 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-sh4-stmicro-ST7540-g++/qplatformdefs.h @@ -0,0 +1,5 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" + diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-snowball-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-snowball-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..f1dbe95878a66aa5c62b5957e58d0fe07a35afb6 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-snowball-g++/qmake.conf @@ -0,0 +1,34 @@ +# +# qmake configuration for ST Ericsson's Snowball +# http://wiki.qt.io/Snowball + +MAKEFILE_GENERATOR = UNIX +CONFIG += incremental +QMAKE_INCREMENTAL_STYLE = sublib + +include(../../common/linux.conf) +include(../../common/gcc-base-unix.conf) +include(../../common/g++-unix.conf) + +load(device_config) + +defineTest(qtConfSanitizeMkspec) { + deviceSanityCheckCompiler() +} + +QMAKE_CC = $${CROSS_COMPILE}gcc +QMAKE_CXX = $${CROSS_COMPILE}g++ +QMAKE_LINK = $${QMAKE_CXX} +QMAKE_LINK_SHLIB = $${QMAKE_CXX} + +# modifications to linux.conf +QMAKE_AR = $${CROSS_COMPILE}ar cqs +QMAKE_OBJCOPY = $${CROSS_COMPILE}objcopy +QMAKE_NM = $${CROSS_COMPILE}nm -P +QMAKE_STRIP = $${CROSS_COMPILE}strip + +QMAKE_RPATHLINKDIR_POST += \ + $$[QT_SYSROOT]/usr/lib/arm-linux-gnueabihf \ + $$[QT_SYSROOT]/lib/arm-linux-gnueabihf + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-snowball-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-snowball-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-snowball-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tegra2-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tegra2-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..c4581277abe343ac3b16abed0a94495bb151d580 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tegra2-g++/qmake.conf @@ -0,0 +1,30 @@ +# +# qmake configuration for the Tegra2 boards. +# +# This mkspec is based and tested on the TrimSlice using "Ubuntu Natty (11.04) - l4t.r15.01"-release. +# It might work with other boards and releases as well. +# A typical configure line looks like this: +# /configure -opensource -confirm-license -make libs -prefix /usr/local/Qt-5.0.0/Qt5-tegra2 +# -device tegra2 -device-option CROSS_COMPILE=/bin/arm-none-linux-gnueabi- \ +# -sysroot + +include(../common/linux_device_pre.conf) + +QMAKE_INCDIR_POST += $$[QT_SYSROOT]/usr/include + +QMAKE_LIBDIR_POST += $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/lib/arm-linux-gnueabi \ + $$[QT_SYSROOT]/usr/lib/arm-linux-gnueabi + +QMAKE_RPATHLINKDIR_POST += \ + $$[QT_SYSROOT]/usr/lib \ + $$[QT_SYSROOT]/usr/lib/arm-linux-gnueabi \ + $$[QT_SYSROOT]/lib/arm-linux-gnueabi + +TEGRA2_CFLAGS = -mtune=cortex-a9 -march=armv7-a -mhard-float -mfloat-abi=softfp -mfpu=vfpv3-d16 +QMAKE_CFLAGS += $$TEGRA2_CFLAGS +QMAKE_CXXFLAGS += $$TEGRA2_CFLAGS + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tegra2-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tegra2-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tegra2-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tinkerboard-g++/qmake.conf b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tinkerboard-g++/qmake.conf new file mode 100644 index 0000000000000000000000000000000000000000..abb5c27ad49a47498c4a8c6d1ddc0515cb10630a --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tinkerboard-g++/qmake.conf @@ -0,0 +1,20 @@ +# +# qmake configuration for the Asus Tinkerboard (Rockchip RK3288, Cortex-A17, Mali-T764) +# +# This configuration targets eglfs via DRM/KMS and Wayland. + +include(../common/linux_device_pre.conf) + +QMAKE_LIBS_EGL += -lEGL +QMAKE_LIBS_OPENGL_ES2 += -lGLESv2 -lEGL +QMAKE_LIBS_OPENVG += -lOpenVG -lEGL + +DISTRO_OPTS += hard-float +COMPILER_FLAGS += -mtune=cortex-a17 -march=armv7-a -mfpu=neon-vfpv4 + +# Preferred eglfs backend +EGLFS_DEVICE_INTEGRATION = eglfs_kms + +include(../common/linux_arm_device_post.conf) + +load(qt_config) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tinkerboard-g++/qplatformdefs.h b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tinkerboard-g++/qplatformdefs.h new file mode 100644 index 0000000000000000000000000000000000000000..e9c14c9d70597c66d2cb3cc5e4a7d5a8638c0c59 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/devices/linux-tinkerboard-g++/qplatformdefs.h @@ -0,0 +1,4 @@ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only + +#include "../../linux-g++/qplatformdefs.h" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/data/mac/objc_namespace.sh b/qt/6.8.1/msvc2022_64/mkspecs/features/data/mac/objc_namespace.sh new file mode 100644 index 0000000000000000000000000000000000000000..1fc5a3cfdab188e6a36be09f9a4ded783fce477e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/data/mac/objc_namespace.sh @@ -0,0 +1,227 @@ +#!/bin/bash +# Copyright (C) 2017 The Qt Company Ltd. +# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 + +script_argument_prefix="-Wobjc_namespace,--" + +required_arguments="target suffix original_ld" +optional_arguments="exclude_list exclude_regex silent" + +for argument in $required_arguments $optional_arguments; do + declare "$argument=" +done + +declare -i silent=0 +declare -a linker_arguments + +for i in "$@"; do + case $1 in + $script_argument_prefix*) + declare "${1#$script_argument_prefix}" + ;; + -o) + if [ -n "$2" ]; then + target="$2" + fi + linker_arguments+=("$1") + ;; + *) + linker_arguments+=("$1") + ;; + esac + shift +done + +get_entry() { + local map=$1 key=$2 + local i="${map}_map_${2}" + printf '%s' "${!i}" +} + +error() { + echo "$0: error: $*" >&2 + exit 1 +} + +for argument in $required_arguments; do + if [ -z "${!argument}" ]; then + error "missing argument --${argument}" + fi +done + +# Normalize suffix so we can use it as a bash variable +suffix=${suffix//[-. ]/_} + +link_binary() { + (PS4=; test $silent -ne 1 && set -x; $original_ld "${linker_arguments[@]}" "$@") 2>&1 || exit 1 +} + +sanitize_address() { + local address="$1" + address=${address#0x} # Remove hex prefix + address=${address: ${#address} < 8 ? 0 : -8} # Limit to 32-bit + echo "0x$address" +} + +arch_offset=0 +read_binary() { + local address=$1 + local length=$2 + + seek=$(($address + $arch_offset)) + dd if="$target" bs=1 iseek=$seek count=$length 2>|/dev/null +} + +read_32bit_value() { + local address=$1 + read_binary $address 4 | xxd -p | dd conv=swab 2>/dev/null | rev +} + +otool_args= +otool() { + command otool $otool_args "$@" +} + +declare -a extra_classnames_files + +inspect_binary() { + inspect_mode="$1" + + classnames_section="__objc_classname" + classnames=$(otool -v -s __TEXT $classnames_section "$target" | tail -n +3) + if [ -z "$classnames" ]; then + echo " ℹ️ No Objective-C classes found in binary" + return 1 + fi + + while read -a classname; do + address=$(sanitize_address ${classname[0]}) + name=${classname[1]} + + declare "address_to_classname_map_$address=$name" + declare "classname_to_address_map_$name=$address" + done <<< "$classnames" + + extra_classnames_file="$(mktemp -t ${classnames_section}_additions).S" + extra_classnames_files+=("$extra_classnames_file") + + if [ "$inspect_mode" == "inject_classnames" ]; then + echo " ℹ️ Class names have not been namespaced, adding suffix '$suffix'..." + printf ".section __TEXT,$classnames_section,cstring_literals,no_dead_strip\n" > $extra_classnames_file + elif [ "$inspect_mode" == "patch_classes" ]; then + echo " ℹ️ Found namespaced class names, updating class entries..." + fi + + classes=$(otool -o -v "$target" | grep "OBJC_CLASS_RO\|OBJC_METACLASS_RO") + if [ -z "$classes" ]; then + echo " 💥 Failed to read class entries from binary" + exit 1 + fi + + while read -a class; do + address="$(sanitize_address ${class[1]})" + class_flags="0x$(read_32bit_value $address)" + if [ -z "$class_flags" ]; then + echo " 💥 Failed to read class flags for class at $address" + continue + fi + + is_metaclass=$(($class_flags & 0x1)) + + name_offset=$(($address + 24)) + classname_address="0x$(read_32bit_value $name_offset)" + if [ -z "$classname_address" ]; then + echo " 💥 Failed to read class name address for class at $address" + continue + fi + + classname=$(get_entry address_to_classname $classname_address) + if [ -z "$classname" ]; then + echo " 💥 Failed to resolve class name for address '$classname_address'" + continue + fi + + if [[ $exclude_list =~ $classname || $classname =~ $exclude_regex ]]; then + if [ $is_metaclass -eq 1 ]; then + class_type="meta class" + else + class_type="class" + fi + echo " 🚽 Skipping excluded $class_type '$classname'" + continue + fi + + newclassname="${classname}_${suffix}" + + if [ "$inspect_mode" == "inject_classnames" ]; then + if [ $is_metaclass -eq 1 ]; then + continue + fi + + echo " 💉 Injecting $classnames_section entry '$newclassname' for '$classname'" + printf ".asciz \"$newclassname\"\n" >> $extra_classnames_file + + elif [ "$inspect_mode" == "patch_classes" ]; then + newclassname_address=$(get_entry classname_to_address ${newclassname}) + if [ -z "$newclassname_address" ]; then + echo " 💥 Failed to resolve class name address for class '$newclassname'" + continue + fi + + if [ $is_metaclass -eq 1 ]; then + class_type="meta" + else + class_type="class" + fi + + name_offset=$(($name_offset + $arch_offset)) + + echo " 🔨 Patching class_ro_t at $address ($class_type) from $classname_address ($classname) to $newclassname_address ($newclassname)" + echo ${newclassname_address: -8} | rev | dd conv=swab 2>/dev/null | xxd -p -r -seek $name_offset -l 4 - "$target" + fi + done <<< "$classes" +} + +echo "🔩 Linking binary using '$original_ld'..." +link_binary + +echo "🔎 Inspecting binary '$target'..." +if [ ! -f "$target" ]; then + echo " 💥 Target does not exist!" + exit 1 +fi + +read -a mach_header <<< "$(otool -h "$target" -v | tail -n 1)" +if [ "${mach_header[0]}" != "MH_MAGIC_64" ]; then + echo " 💥 Binary is not 64-bit, only 64-bit binaries are supported!" + exit 1 +fi + +architectures=$(otool -f -v "$target" | grep architecture) + +setup_arch() { + arch="$1" + if [ ! -z "$arch" ]; then + otool_args="-arch $arch" + offset=$(otool -f -v "$target" | grep -A 6 "architecture $arch" | grep offset) + offset="${offset##*( )}" + arch_offset="$(echo $offset | cut -d ' ' -f 2)" + echo "🤖 Processing architecture '$arch' at offset $arch_offset..." + fi +} + +while read -a arch; do + setup_arch "${arch[1]}" + inspect_binary inject_classnames + if [ $? -ne 0 ]; then + exit + fi +done <<< "$architectures" + +echo "🔩 Re-linking binary with extra __objc_classname section(s)..." +link_binary "${extra_classnames_files[@]}" + +while read -a arch; do + setup_arch "${arch[1]}" + inspect_binary patch_classes +done <<< "$architectures" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/data/testserver/Dockerfile b/qt/6.8.1/msvc2022_64/mkspecs/features/data/testserver/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..f42d3d5c5b97227897f9de0dbf09149032932f23 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/data/testserver/Dockerfile @@ -0,0 +1,29 @@ +# This Dockerfile is used to provision the shared scripts (e.g. startup.sh) and configurations. It +# relies on the arguments passed by docker-compose file to build additional images for each service. +# To lean more how it works, please check the topic "Use multi-stage builds". +# https://docs.docker.com/develop/develop-images/multistage-build/ + +ARG provisioningImage +FROM $provisioningImage as testserver_tier2 + +# Add and merge the testdata into service folder +ARG serviceDir +ARG shareDir=$serviceDir +COPY $serviceDir $shareDir service/ + +# create the shared script of testserver +RUN echo "#!/usr/bin/env bash\n" \ + "set -ex\n" \ + "for RUN_CMD; do \$RUN_CMD; done\n" \ + "service dbus restart\n" \ + "service avahi-daemon restart\n" \ + "sleep infinity\n" > startup.sh +RUN chmod +x startup.sh + +# rewrite the default configurations of avahi-daemon +# Disable IPv6 of avahi-daemon to resolve the unstable connections on Windows +ARG test_domain +RUN sed -i -e "s,#domain-name=local,domain-name=${test_domain:-test-net.qt.local}," \ + -e "s,#publish-aaaa-on-ipv4=yes,publish-aaaa-on-ipv4=no," \ + -e "s,use-ipv6=yes,use-ipv6=no," \ + /etc/avahi/avahi-daemon.conf diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/data/testserver/docker-compose-common.yml b/qt/6.8.1/msvc2022_64/mkspecs/features/data/testserver/docker-compose-common.yml new file mode 100644 index 0000000000000000000000000000000000000000..3db8bbcdafcfdd2e9b3c1cc495db8a72c309c3f1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/data/testserver/docker-compose-common.yml @@ -0,0 +1,38 @@ +version: '2.1' + +# This is a template docker-compose file shared with all modules. It is based +# on 'extending services' feature of compose file version 2.1. +# See https://docs.docker.com/compose/extends/#extending-services for details. +# +# Example: testserver/docker-compose.yml +# services: +# foo: +# extends: +# file: ${SHARED_DATA}/docker-compose-common.yml +# service: ${SHARED_SERVICE} +# container_name: qt-test-server-foo +# hostname: ${HOST_NAME:-foo} +# build: +# context: . +# args: +# provisioningImage: qt-test-server-foo:537fe302f61851d1663... +# serviceDir: ./foo +# command: service/foo.sh + +x-services: + &default-service + domainname: ${TEST_DOMAIN} + build: + context: . + dockerfile: ${SHARED_DATA}/Dockerfile + args: + test_domain: ${TEST_DOMAIN} + entrypoint: ./startup.sh + +services: + bridge-network: *default-service + host-network: + << : *default-service + network_mode: "host" + extra_hosts: + - "qt-test-server.${TEST_DOMAIN}:${MACHINE_IP}" diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/mac/unsupported/objc_namespace.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/mac/unsupported/objc_namespace.prf new file mode 100644 index 0000000000000000000000000000000000000000..04b639fb0d2f315f73d287bd0d0da6f9d6315833 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/mac/unsupported/objc_namespace.prf @@ -0,0 +1,50 @@ +# +# W A R N I N G +# ------------- +# +# This file is not part of the Qt API. It exists purely as an +# implementation detail. It may change from version to version +# without notice, or even be removed. +# +# We mean it. +# + +# The Objective-C runtime will complain when loading a binary that +# introduces as class name that already exists in the global namespace. +# This may happen when linking Qt statically into a plugin, and then +# loading more than two plugins into the same host, both using Qt. +# +# We work around this by doing a bit of post-processing on the final +# binary, adding new suffixed class name entries to the __objc_classname +# section of the __TEXT segment, and then patching the class_ro_t +# entries to point to the newly added class names. +# +# By linking the binary between these two steps we avoid having to +# manually remap all the offsets in the Mach-O binary due to the +# added class names, instead relying on the linker to do this +# for us by linking in an assembly file with the added names. + +objc_namespace_script = $$clean_path($$PWD/../../data/mac/objc_namespace.sh) + +isEmpty(QMAKE_OBJC_NAMESPACE_SUFFIX) { + QMAKE_OBJC_NAMESPACE_SUFFIX = $$TARGET + !isEmpty(QMAKE_TARGET_BUNDLE_PREFIX): \ + QMAKE_OBJC_NAMESPACE_SUFFIX = $${QMAKE_TARGET_BUNDLE_PREFIX}.$${QMAKE_OBJC_NAMESPACE_SUFFIX} +} + +QMAKE_LFLAGS += \ + -Wobjc_namespace,--target=$$shell_quote($$TARGET) \ + -Wobjc_namespace,--suffix=$$shell_quote($$QMAKE_OBJC_NAMESPACE_SUFFIX) \ + -Wobjc_namespace,--original_ld=$$shell_quote($$QMAKE_LINK) + +!isEmpty(QMAKE_OBJC_NAMESPACE_EXCLUDE): \ + QMAKE_LFLAGS += -Wobjc_namespace,--exclude_list=$$shell_quote($$QMAKE_OBJC_NAMESPACE_EXCLUDE) +!isEmpty(QMAKE_OBJC_NAMESPACE_EXCLUDE_REGEX) { + equals(MAKEFILE_GENERATOR, UNIX): \ + QMAKE_OBJC_NAMESPACE_EXCLUDE_REGEX ~= s/\\$/\$\$/ + QMAKE_LFLAGS += -Wobjc_namespace,--exclude_regex=$$shell_quote($$QMAKE_OBJC_NAMESPACE_EXCLUDE_REGEX) +} + +slient: QMAKE_LFLAGS += -Wobjc_namespace,--silent=1 + +QMAKE_LINK = $$objc_namespace_script diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/unsupported/testserver.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/unsupported/testserver.prf new file mode 100644 index 0000000000000000000000000000000000000000..9167ca0e39432a04d78c5d226e2c39cafb50f13c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/unsupported/testserver.prf @@ -0,0 +1,231 @@ +# Integrating docker-based test servers into Qt Test framework +# +# This file adds support for docker-based test servers built by testcase +# projects that need them. To enable this feature, any automated test can +# include testserver.pri in its project file. This instructs qmake to insert +# additional targets into the generated Makefile. The 'check' target then brings +# up test servers before running the testcase, and shuts them down afterwards. +# +# TESTSERVER_COMPOSE_FILE +# - Contains the path of docker-compose file +# This configuration file defines the services used for autotests. It tells the +# docker engine how to build up the docker images and containers. In qtbase, a +# shared docker-compose file is located in the tests folder. +# Example: TESTSERVER_COMPOSE_FILE = \ +# $$dirname(_QMAKE_CONF_)/tests/testserver/docker-compose.yml +# +# The user must run the provisioning scripts in advance before attempting to +# build the test servers. The docker_testserver.sh script is used to build up +# the docker images into the docker-cache. It handles the immutable parts of the +# server installation that rarely need adjustment, such as downloading packages. +# Example: qt5/coin/provisioning/.../testserver/docker_testserver.sh +# +# QT_TEST_SERVER_LIST +# - A list of test servers to bring up for this testcase +# These test servers should be defined in $$TESTSERVER_COMPOSE_FILE. Each +# testcase can define the test servers it depends on. +# Example: QT_TEST_SERVER_LIST = apache2 squid vsftpd ftp-proxy danted +# +# Pre-processor defines needed for the application: +# QT_TEST_SERVER +# - A preprocessor macro used for testcase to change testing parameters at +# compile time +# This macro is predefined for docker-based test servers and is passed as a +# compiler option (-DQT_TEST_SERVER). The testcase can then check whether +# docker-based servers are in use and change the testing parameters, such as +# host name or port number, at compile time. An example can be found in +# network-settings.h. +# +# Example: +# #if defined(QT_TEST_SERVER) +# Change the testing parameters at compile time +# #endif +# +# QT_TEST_SERVER_DOMAIN +# - A preprocessor macro that holds the server domain name +# Provided for the helper functions in network-settings.h. Use function +# serverDomainName() in your application instead. +# +# Additional make targets: +# 1. check_network - A renamed target from the check target of testcase feature. +# 2. testserver_clean - Clean up server containers/images and tidy away related +# files. + +# The docker test server should only be integrated in the leaf Makefile. +# If debug_and_release option is in use, skip the meta-Makefile except for +# Makefile.Debug and Makefile.Release. +debug_and_release:!build_pass: return() + +DOCKER_ENABLED = 1 + +equals(QMAKE_HOST.os, Darwin) { + DOCKER_ENABLED = 0 + message("Not using docker network test server on macOS, see QTQAINFRA-2717 and QTQAINFRA-2750") +} + +TESTSERVER_VERSION = "" + +equals(DOCKER_ENABLED, 1) { + TESTSERVER_VERSION = $$system(docker-compose --version) +} + +isEmpty(TESTSERVER_VERSION) { + # Make check with server "qt-test-server.qt-test-net" as a fallback +} else { + # Make check with docker test servers + equals(QMAKE_HOST.os, Linux) { + # For the platform supporting docker bridge network, each container is + # assigned a unique hostname and connected to the same network domain + # to communicate with the others. + DEFINES += QT_TEST_SERVER_NAME + DNSDOMAIN = test-net.qt.local + } else { + # For the others, the containers are deployed into a virtual machine + # using the host network. All the containers share the same hostname of + # the virtual machine, and they are connected to the same network domain. + # NOTE: In Windows, Apple Bonjour only works within a single local domain. + DNSDOMAIN = local + } + + equals(QMAKE_HOST.os, Darwin) { + # There is no docker bridge on macOS. It is impossible to ping a container. + # Docker docs recommends using port mapping to connect to a container; + # but it causes a port conflict if the user is running a service that + # binds the same port on the host. An alternative solution is to deploy + # the docker environment into VirtualBox using docker-machine. + isEmpty(TESTSERVER_COMPOSE_FILE): TESTSERVER_COMPOSE_FILE = \ + $$dirname(_QMAKE_CONF_)/tests/testserver/docker-compose-host-network.yml + + # The connection configuration for the target machine + MACHINE_CONFIG = $(shell docker-machine config qt-test-server) + + # The environment variables passed to the docker-compose file + TEST_ENV = 'MACHINE_IP=$(shell docker-machine ip qt-test-server)' + TEST_ENV += 'HOST_NAME=qt-test-server' + TEST_ENV += 'TEST_DOMAIN=$$DNSDOMAIN' + TEST_ENV += 'SHARED_DATA=$$PWD/../data/testserver' + TEST_ENV += 'SHARED_SERVICE=host-network' + TEST_CMD = env + } else:equals(QMAKE_HOST.os, Windows) { + # There is no docker bridge on Windows. It is impossible to ping a container. + # Use docker-machine to deploy the docker environment into VirtualBox. + isEmpty(TESTSERVER_COMPOSE_FILE): TESTSERVER_COMPOSE_FILE = \ + $$dirname(_QMAKE_CONF_)/tests/testserver/docker-compose-host-network.yml + + # The connection configuration for the target machine + MACHINE_CONFIG = (docker-machine config qt-test-server) + + # The environment variables passed to the docker-compose file + TEST_ENV = '\$\$env:MACHINE_IP = docker-machine ip qt-test-server;' + TEST_ENV += '\$\$env:HOST_NAME = $$shell_quote(\"qt-test-server\");' + TEST_ENV += '\$\$env:TEST_DOMAIN = $$shell_quote(\"$$DNSDOMAIN\");' + TEST_ENV += '\$\$env:SHARED_DATA = $$shell_quote(\"$$PWD/../data/testserver\");' + TEST_ENV += '\$\$env:SHARED_SERVICE = $$shell_quote(\"host-network\");' + + # Docker-compose CLI environment variables: + # Enable path conversion from Windows-style to Unix-style in volume definitions. + TEST_ENV += '\$\$env:COMPOSE_CONVERT_WINDOWS_PATHS = $$shell_quote(\"true\");' + + TEST_CMD = 'PowerShell -noprofile' + CONFIG += PowerShell + } else { + isEmpty(TESTSERVER_COMPOSE_FILE): TESTSERVER_COMPOSE_FILE = \ + $$dirname(_QMAKE_CONF_)/tests/testserver/docker-compose-bridge-network.yml + # The environment variables passed to the docker-compose file + TEST_ENV = 'TEST_DOMAIN=$$DNSDOMAIN' + TEST_ENV += 'SHARED_DATA=$$PWD/../data/testserver' + TEST_ENV += 'SHARED_SERVICE=bridge-network' + TEST_CMD = env + } + + # If $$TESTSERVER_COMPOSE_FILE defined by platform doesn't exist, the default + # docker-compose.yml is used as a fallback. + !exists($$TESTSERVER_COMPOSE_FILE): TESTSERVER_COMPOSE_FILE = \ + $$dirname(_QMAKE_CONF_)/tests/testserver/docker-compose.yml + !exists($$TESTSERVER_COMPOSE_FILE): error("Invalid TESTSERVER_COMPOSE_FILE specified") + + + # The domain name is relevant to https keycert (qnetworkreply/crts/qt-test-net-cacert.pem). + DEFINES += QT_TEST_SERVER QT_TEST_SERVER_DOMAIN=$$shell_quote(\"$${DNSDOMAIN}\") + + # Ensure that the docker-compose file is provided. It is a configuration + # file which is mandatory for all docker-compose commands. You can get more + # detail from the description of TESTSERVER_COMPOSE_FILE above. There is + # also an example showing how to configure it manually. + FILE_PRETEST_MSG = "Project variable 'TESTSERVER_COMPOSE_FILE' is not set" + PowerShell { + testserver_pretest.commands = echo $$TESTSERVER_VERSION && + testserver_pretest.commands += \ + $$TEST_CMD if ([String]::IsNullOrEmpty($$shell_quote(\"$$TESTSERVER_COMPOSE_FILE\"))) \ + {Write-Error $$shell_quote(\"$$FILE_PRETEST_MSG\")} && + } else { + testserver_pretest.commands = $(info "testserver:" $$TESTSERVER_VERSION) + testserver_pretest.commands += $(if $$TESTSERVER_COMPOSE_FILE,,$(error $$FILE_PRETEST_MSG)) + } + + # Make sure docker-machine is both created and running. The docker_machine + # script is used to deploy the docker environment into VirtualBox. + # Example: qt5/coin/provisioning/common/shared/testserver/docker_machine.sh + !isEmpty(MACHINE_CONFIG) { + MACHINE_LIST_CMD = docker-machine ls -q --filter "Name=^qt-test-server\$\$" + MACHINE_LIST_MSG = "Docker machine qt-test-server not found" + PowerShell { + testserver_pretest.commands += $$TEST_CMD if (!($$MACHINE_LIST_CMD)) \ + {Write-Error $$shell_quote(\"$$MACHINE_LIST_MSG\")} && + } else { + testserver_pretest.commands += \ + $(if $(shell $$MACHINE_LIST_CMD),,$(error $$MACHINE_LIST_MSG)) + } + + MACHINE_STATE_CMD = \ + docker-machine ls -q --filter "State=Running" --filter "Name=^qt-test-server\$\$" + MACHINE_START_CMD = docker-machine start qt-test-server + MACHINE_RECERT = docker-machine regenerate-certs -f qt-test-server + PowerShell { + testserver_pretest.commands += \ + $$TEST_CMD if (!($$MACHINE_STATE_CMD)) {$$MACHINE_START_CMD; $$MACHINE_RECERT} && + } else { + testserver_pretest.commands += \ + $(if $(shell $$MACHINE_STATE_CMD),,\ + $(shell $$MACHINE_START_CMD > /dev/null && $$MACHINE_RECERT > /dev/null)) + } + } + + # Before starting the test servers, it requires the user to run the setup + # script (coin/provisioning/.../testserver/docker_testserver.sh) in advance. + IMAGE_PRETEST_CMD = docker $$MACHINE_CONFIG images -aq "qt-test-server-*" + IMAGE_PRETEST_MSG = "Docker image qt-test-server-* not found" + PowerShell { + testserver_pretest.commands += $$TEST_CMD if (!($$IMAGE_PRETEST_CMD)) \ + {Write-Error $$shell_quote(\"$$IMAGE_PRETEST_MSG\")} + } else { + testserver_pretest.commands += \ + $(if $(shell $$IMAGE_PRETEST_CMD),,$(error $$IMAGE_PRETEST_MSG)) + } + + # Rename the check target of testcase feature + check.target = check_network + testserver_test.target = check + + # Pretesting test servers environment + testserver_test.depends = testserver_pretest + + # Bring up test servers and make sure the services are ready. + !isEmpty(TEST_CMD): testserver_test.commands = $$TEST_CMD $$TEST_ENV + testserver_test.commands += docker-compose $$MACHINE_CONFIG -f $$TESTSERVER_COMPOSE_FILE up \ + --build -d --force-recreate --timeout 1 $${QT_TEST_SERVER_LIST} && + + # Check test cases with docker-based test servers. + testserver_test.commands += $(MAKE) -f $(MAKEFILE) check_network && + + # Stop and remove test servers after testing. + !isEmpty(TEST_CMD): testserver_test.commands += $$TEST_CMD $$TEST_ENV + testserver_test.commands += docker-compose $$MACHINE_CONFIG -f $$TESTSERVER_COMPOSE_FILE down \ + --timeout 1 + + # Destroy test servers and tidy away related files. + testserver_clean.commands = docker-compose $$MACHINE_CONFIG -f $$TESTSERVER_COMPOSE_FILE down \ + --rmi all + + QMAKE_EXTRA_TARGETS += testserver_pretest testserver_test testserver_clean +} diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/default_pre.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/default_pre.prf new file mode 100644 index 0000000000000000000000000000000000000000..2ccb26920e10e8d69cbf00b49fd2825cf7b85be3 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/default_pre.prf @@ -0,0 +1,2 @@ +load(emcc_ver) +load(default_pre) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/emcc_ver.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/emcc_ver.prf new file mode 100644 index 0000000000000000000000000000000000000000..558b7b040f7b72a0c6bdcc02ef6a777bde03bb9f --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/emcc_ver.prf @@ -0,0 +1,25 @@ +defineReplace(qtEmccRecommendedVersion) { + return (3.1.56) +} + +defineReplace(qtSystemEmccVersion) { + EMCC = $$system("emcc -v 2>&1", lines) + EMCC_LINE = $$find(EMCC, "^.*\b(emcc)\b.*$") + E_VERSION = $$section(EMCC_LINE, " ", 9,9) + return ($${E_VERSION}) +} + +defineTest(qtConfTest_emccVersion) { + + REQ_VERSION = $$qtEmccRecommendedVersion() + EMCC_VERSION = $$qtSystemEmccVersion() + + !defined(QT_EMCC_VERSION, var):!equals(EMCC_VERSION, $${REQ_VERSION}) { + warning ("You should use the recommended Emscripten version $$REQ_VERSION with this Qt. You have $${EMCC_VERSION} ") + } + contains(TEMPLATE, .*app) { + !equals(QT_EMCC_VERSION, $$EMCC_VERSION) { + warning("This Qt was built with Emscripten version $${QT_EMCC_VERSION}. You have $${EMCC_VERSION}. The difference may cause issues.") + } + } +} diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/wasm.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/wasm.prf new file mode 100644 index 0000000000000000000000000000000000000000..9b3db508949602b310c014b9e29039ce4e811499 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/wasm/wasm.prf @@ -0,0 +1,179 @@ + +QT_FOR_CONFIG += core-private + +# DESTDIR will be empty if not set in the app .pro file; make sure it has a value +isEmpty(DESTDIR): DESTDIR = $$OUT_PWD + +exists($$QMAKE_QT_CONFIG) { +## this may be subject to change + + ## qmake puts a space if done otherwise + !isEmpty(QT_WASM_EXTRA_EXPORTED_METHODS): { + EXPORTED_METHODS = UTF16ToString,stringToUTF16,JSEvents,specialHTMLTargets,FS,callMain,$$QT_WASM_EXTRA_EXPORTED_METHODS + } else { + EXPORTED_METHODS = UTF16ToString,stringToUTF16,JSEvents,specialHTMLTargets,FS,callMain + } + EMCC_LFLAGS += -s EXPORTED_RUNTIME_METHODS=$$EXPORTED_METHODS + + !isEmpty(QT_WASM_EXPORT_NAME): { + EXPORT_NAME = $$QT_WASM_EXPORT_NAME + } else { + TARGET_SANITIZED = $$replace(TARGET, [^a-zA-Z0-9_], _) + EXPORT_NAME = $${TARGET_SANITIZED}_entry + } + + EMCC_LFLAGS += -s EXPORT_NAME=$$EXPORT_NAME + + qtConfig(thread) { + + EMCC_LFLAGS += -pthread + EMCC_CFLAGS += -pthread + + # Create worker threads at startup. This is supposed to be an optimization, + # however exceeding the pool size has been obesverved to hang the application. + POOL_SIZE = 4 + !isEmpty(QT_WASM_PTHREAD_POOL_SIZE) { + POOL_SIZE = $$QT_WASM_PTHREAD_POOL_SIZE + } + + message("Setting PTHREAD_POOL_SIZE to" $$POOL_SIZE) + EMCC_LFLAGS += -s PTHREAD_POOL_SIZE=$$POOL_SIZE + } + + # Set memory options + EMCC_LFLAGS += -sALLOW_MEMORY_GROWTH + isEmpty(QT_WASM_INITIAL_MEMORY) { + INITIAL_MEMORY = 50MB # emscripten default is 16MB, we need slightly more + } else { + INITIAL_MEMORY = $$QT_WASM_INITIAL_MEMORY + } + EMCC_LFLAGS += -s INITIAL_MEMORY=$$INITIAL_MEMORY + isEmpty(QT_WASM_MAXIMUM_MEMORY) { + MAXIMUM_MEMORY = 4GB # 32-bit max + } else { + MAXIMUM_MEMORY = $$QT_WASM_MAXIMUM_MEMORY + } + EMCC_LFLAGS += -s MAXIMUM_MEMORY=$$MAXIMUM_MEMORY + + qtConfig(sse2) { + QMAKE_CFLAGS += -O2 -msimd128 -msse -msse2 + QMAKE_CXXFLAGS += -O2 -msimd128 -msse -msse2 + QMAKE_LFLAGS += -msimd128 -msse -msse2 + QMAKE_LFLAGS_DEBUG += -msimd128 -msse -msse2 + } + + qtConfig(shared) { + contains(TEMPLATE, .*app) { + EMCC_MODULE_FLAGS = -s MAIN_MODULE=1 + } + contains(TEMPLATE, .*lib):!static: { + EMCC_MODULE_FLAGS = -s SIDE_MODULE=1 + } + EMCC_CFLAGS += $$EMCC_MODULE_FLAGS + EMCC_LFLAGS += $$EMCC_MODULE_FLAGS + } + + QMAKE_LFLAGS += $$EMCC_LFLAGS + QMAKE_LFLAGS_DEBUG += $$EMCC_LFLAGS + QMAKE_CFLAGS += $$EMCC_CFLAGS + QMAKE_CXXFLAGS += $$EMCC_CFLAGS +} + +# Create js and wasm files for applications +contains(TEMPLATE, .*app) { + TARGET_BASE = $${TARGET} + TARGET_HTML = $${TARGET}.html + TARGET_JS = $${TARGET}.js + + # Make the emscripten compiler generate a js file + TARGET = $$TARGET_JS + + QMAKE_INCDIR += $$(HOME)/.emscripten_ports/openssl/include + + CONFIG += static + js_file.files = $$TARGET_JS + js_file.path = $$target.path + isEmpty(js_file.path): \ + js_file.path += ./ + INSTALLS += js_file + + # Copy hosting html and javascript to the application build directory. + exists($$[QT_INSTALL_PLUGINS]/platforms/wasm_shell.html) { + # don't pass this until it's installed somewhere + # otherwise makespec test fails during qt configure + WASM_PLUGIN_PATH = $$[QT_INSTALL_PLUGINS]/platforms + } else { + ## internal build. not installed + WASM_PLUGIN_PATH = $$PWD/../../../src/plugins/platforms/wasm + } + + PRELOAD = "" + shared { + PRELOAD = "preload:\ ['qt_plugins.json',\ 'qt_qml_imports.json']," + } + + # Copy/Generate main .html file (e.g. myapp.html) from the webassembly_shell.html by + # replacing the app name placeholder with the actual app name. + apphtml.name = application main html file + apphtml.output = $$DESTDIR/$$TARGET_HTML + apphtml.commands = $$QMAKE_STREAM_EDITOR -e s/@APPNAME@/$$TARGET_BASE/g -e s/@APPEXPORTNAME@/$$EXPORT_NAME/g -e s/@PRELOAD@/$$PRELOAD/g $$WASM_PLUGIN_PATH/wasm_shell.html > $$DESTDIR/$$TARGET_HTML + apphtml.input = $$WASM_PLUGIN_PATH/wasm_shell.html + apphtml.depends = $$apphtml.input + QMAKE_EXTRA_COMPILERS += apphtml + + appjs.name = application qtloader.js + appjs.output = $$DESTDIR/qtloader.js + appjs.commands = $$QMAKE_COPY $$shell_path($$WASM_PLUGIN_PATH/qtloader.js) $$shell_path($$DESTDIR) + appjs.input = $$WASM_PLUGIN_PATH/qtloader.js + appjs.depends = $$appjs.input + QMAKE_EXTRA_COMPILERS += appjs + + appsvg.name = application qtlogo.svg + appsvg.output = $$DESTDIR/qtlogo.svg + appsvg.commands = $$QMAKE_COPY $$shell_path($$WASM_PLUGIN_PATH/qtlogo.svg) $$shell_path($$DESTDIR) + appsvg.input = $$WASM_PLUGIN_PATH/qtlogo.svg + appsvg.depends = $$appsvg.input + QMAKE_EXTRA_COMPILERS += appsvg + + QMAKE_EXTRA_TARGETS += apphtml appjs appsvg + POST_TARGETDEPS += apphtml appjs appsvg + + # Add manual target to make "make -B shellfiles" work. + shellfiles.target = shellfiles + shellfiles.depends = apphtml appjs appsvg + QMAKE_EXTRA_TARGETS += shellfiles + + # emscripten ports are linked into the main module (this app), not the Qt + # libs which reference them + qt { + qt_depends = $$resolve_depends(QT, "QT.") + contains(qt_depends, core(-private)?): QMAKE_LFLAGS += \ + $$QMAKE_LIBS_THREAD $$QMAKE_LIBS_ZLIB + contains(qt_depends, gui(-private)?): QMAKE_LFLAGS += \ + $$QMAKE_LIBS_FREETYPE $$QMAKE_LIBS_LIBPNG + } +} + +qtConfTest_emccVersion() + +CONFIG(debug):!isEmpty(QT_WASM_SOURCE_MAP) { + + EMCC_VERSION = $$qtSystemEmccVersion() + + QMAKE_LFLAGS += -gsource-map + # Pass --source-map-base on the linker line. This informs the + # browser where to find the source files when debugging. + WASM_SOURCE_MAP_BASE = http://localhost:8000/ + !isEmpty(QT_WASM_SOURCE_MAP_BASE):\ + WASM_SOURCE_MAP_BASE = $$QT_WASM_SOURCE_MAP_BASE + QMAKE_LFLAGS += --source-map-base $$WASM_SOURCE_MAP_BASE +} + + +# Creates the stand-alone version of the library from bitcode +!static:contains(TEMPLATE, .*lib): { + load(resolve_target) + QMAKE_POST_LINK += $$QMAKE_LINK_SHLIB $$QMAKE_RESOLVED_TARGET -o $${QMAKE_RESOLVED_TARGET}.js + + QMAKE_INCDIR += $$(HOME)/.emscripten_ports/openssl/include +} diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/console.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/console.prf new file mode 100644 index 0000000000000000000000000000000000000000..a2408a79ec4c97298a65d60289688f8818697145 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/console.prf @@ -0,0 +1,5 @@ +CONFIG -= windows +QMAKE_LFLAGS += $$QMAKE_LFLAGS_CONSOLE +contains(TEMPLATE, ".*app") { + QMAKE_LFLAGS += $$QMAKE_LFLAGS_EXE +} diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/default_pre.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/default_pre.prf new file mode 100644 index 0000000000000000000000000000000000000000..0ff14d32c3065e247a2469410b8b66163186682c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/default_pre.prf @@ -0,0 +1,2 @@ +CONFIG = windows $$CONFIG entrypoint +load(default_pre) diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/dumpcpp.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/dumpcpp.prf new file mode 100644 index 0000000000000000000000000000000000000000..821faf14be23955a06d6335048cee100cd18c56e --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/dumpcpp.prf @@ -0,0 +1,36 @@ +qtPrepareTool(QMAKE_DUMPCPP, dumpcpp) + +dumpcpp_decl.depends += $$QMAKE_DUMPCPP_EXE +dumpcpp_decl.commands = $$QMAKE_DUMPCPP ${QMAKE_FILE_IN} -o ${QMAKE_FILE_BASE} +qaxcontainer_compat: dumpcpp_decl.commands += -compat +dumpcpp_decl.output = ${QMAKE_FILE_BASE}.h +dumpcpp_decl.input = TYPELIBS +dumpcpp_decl.variable_out = HEADERS +dumpcpp_decl.name = DUMP +dumpcpp_decl.CONFIG += no_link + +QMAKE_EXTRA_COMPILERS += dumpcpp_decl + + +dumpcpp_impl.commands = $$escape_expand(\\n) # dummy command +dumpcpp_impl.output = ${QMAKE_FILE_BASE}.cpp +dumpcpp_impl.input = TYPELIBS +dumpcpp_impl.variable_out = SOURCES +dumpcpp_impl.name = CPP +dumpcpp_impl.depends += ${QMAKE_FILE_BASE}.h + +QMAKE_EXTRA_COMPILERS += dumpcpp_impl + + +# Call dumpcpp the first time if the files do not exist to help find dependencies +!build_pass:have_target:!contains(TEMPLATE, vc.*) { + for(tlb, TYPELIBS) { + tlbCopy = $$replace(tlb, \", ) + hdr = $$basename(tlbCopy) + hdr = $$section(hdr, ., 0, -2) + tmp_command = $$QMAKE_DUMPCPP $$system_quote($$absolute_path($$tlbCopy, $$_PRO_FILE_PWD_)) \ + -o $$system_quote($$OUT_PWD/$$hdr) + qaxcontainer_compat: tmp_command += -compat + !exists($$OUT_PWD/$${hdr}.h): system($$tmp_command) + } +} diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/idcidl.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/idcidl.prf new file mode 100644 index 0000000000000000000000000000000000000000..f2d2440a47d7b1a29eac7063788d95c1bf81c280 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/idcidl.prf @@ -0,0 +1,47 @@ +build_pass:console { + warning("QAxServer applications cannot be console applications.") + warning("Remove 'console' from your CONFIG.") +} + +CONFIG -= entrypoint + +ACTIVEQT_VERSION = $$VERSION +isEmpty(ACTIVEQT_VERSION):ACTIVEQT_VERSION = 1.0 + +qtPrepareTool(QMAKE_IDC, idc) +contains(TEMPLATE, "vc.*") { + ACTIVEQT_IDC = $${QMAKE_IDC} + ACTIVEQT_IDL = $${QMAKE_IDL} + ACTIVEQT_TARGET = \"$(TargetPath)\" + ACTIVEQT_NEWLINE = $$escape_expand(\\n\\t) + ACTIVEQT_OUTPUT = $(IntDir)$${TARGET} + ACTIVEQT_TLBOUT = \"$(TargetDir)/$${TARGET}.tlb\" + GENERATED += $${OBJECTS_DIR}/$${TARGET}.idl $${ACTIVEQT_TLBOUT} +} else { + ACTIVEQT_IDC = -$(IDC) + ACTIVEQT_IDL = -$(IDL) + ACTIVEQT_NEWLINE = $$escape_expand(\\n\\t) + ACTIVEQT_TARGET = $(DESTDIR_TARGET) + ACTIVEQT_OUTPUT = $(OBJECTS_DIR)/$${TARGET} + isEmpty(DESTDIR) { + ACTIVEQT_TLBOUT = $${TARGET}.tlb + } else { + ACTIVEQT_TLBOUT = $${DESTDIR}/$${TARGET}.tlb + } +} + +!qaxserver_no_postlink { + !isEmpty(QMAKE_POST_LINK):QMAKE_POST_LINK += $$quote($$ACTIVEQT_NEWLINE) + QMAKE_POST_LINK += $$quote($$ACTIVEQT_IDC $${ACTIVEQT_TARGET} /idl $${ACTIVEQT_OUTPUT}.idl -version $${ACTIVEQT_VERSION}$${ACTIVEQT_NEWLINE}) + !isEmpty(RC_FILE) { + QMAKE_POST_LINK += $$quote($$ACTIVEQT_IDL "$${ACTIVEQT_OUTPUT}.idl" /nologo /tlb "$${ACTIVEQT_OUTPUT}.tlb"$$ACTIVEQT_NEWLINE) + QMAKE_POST_LINK += $$quote($$ACTIVEQT_IDC $${ACTIVEQT_TARGET} /tlb $${ACTIVEQT_OUTPUT}.tlb$$ACTIVEQT_NEWLINE) + } else { + QMAKE_POST_LINK += $$quote($$ACTIVEQT_IDL "$${ACTIVEQT_OUTPUT}.idl" /nologo /tlb "$${ACTIVEQT_TLBOUT}"$$ACTIVEQT_NEWLINE) + message("No rc-file linked into project; type library will be a separate file.") + } + !qaxserver_no_register: \ + QMAKE_POST_LINK += $$quote($$ACTIVEQT_IDC $${ACTIVEQT_TARGET} /regserver) + QMAKE_CLEAN += $${ACTIVEQT_OUTPUT}.idl $${ACTIVEQT_OUTPUT}.tlb +} + diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/msvc_mp.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/msvc_mp.prf new file mode 100644 index 0000000000000000000000000000000000000000..b73af93cd5499ebb7703a7337293c93882822f16 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/msvc_mp.prf @@ -0,0 +1,2 @@ +QMAKE_CFLAGS += $$QMAKE_CFLAGS_MP +QMAKE_CXXFLAGS += $$QMAKE_CXXFLAGS_MP diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/opengl.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/opengl.prf new file mode 100644 index 0000000000000000000000000000000000000000..729bb59ef4506517e361e98a5b42d0329e92b5f5 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/opengl.prf @@ -0,0 +1,6 @@ +QT_FOR_CONFIG += gui + +!qtConfig(dynamicgl) { + QMAKE_LIBS += $$QMAKE_LIBS_OPENGL + QMAKE_LFLAGS += $$QMAKE_LFLAGS_OPENGL +} diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/separate_debug_info.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/separate_debug_info.prf new file mode 100644 index 0000000000000000000000000000000000000000..a1d2789f1bd9c00a04dcc68323436b89483e42b2 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/separate_debug_info.prf @@ -0,0 +1,22 @@ +have_target:!static:!isEmpty(QMAKE_OBJCOPY) { + load(resolve_target) + QMAKE_TARGET_DEBUG_INFO = $${QMAKE_RESOLVED_TARGET}.debug + + shell_target = $$shell_quote($$relative_path($$QMAKE_RESOLVED_TARGET, $$OUT_PWD)) + shell_target_debug_info = $$shell_quote($$relative_path($$QMAKE_TARGET_DEBUG_INFO, $$OUT_PWD)) + copy_debug_info = $$QMAKE_OBJCOPY --only-keep-debug $$shell_target $$shell_target_debug_info + link_debug_info = $$QMAKE_OBJCOPY --add-gnu-debuglink=$$shell_target_debug_info $$shell_target + strip_debug_info = $$QMAKE_OBJCOPY --strip-debug $$shell_target + + !isEmpty(QMAKE_POST_LINK):QMAKE_POST_LINK = $$escape_expand(\\n\\t)$$QMAKE_POST_LINK + + QMAKE_POST_LINK = $$copy_debug_info && $$strip_debug_info && $$link_debug_info $$QMAKE_POST_LINK + silent:QMAKE_POST_LINK = @echo creating $@.debug && $$QMAKE_POST_LINK + + contains(TEMPLATE, lib$):!plugin { + dlltarget.targets += $$QMAKE_TARGET_DEBUG_INFO + } else { + target.targets += $$QMAKE_TARGET_DEBUG_INFO + } + QMAKE_DISTCLEAN += $$QMAKE_TARGET_DEBUG_INFO +} diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/stl.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/stl.prf new file mode 100644 index 0000000000000000000000000000000000000000..487f8184d4f3510efa61bdf5cfc8af90044b31c1 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/stl.prf @@ -0,0 +1,3 @@ +CONFIG -= stl_off +QMAKE_CFLAGS *= $$QMAKE_CFLAGS_STL_ON +QMAKE_CXXFLAGS *= $$QMAKE_CXXFLAGS_STL_ON diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/stl_off.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/stl_off.prf new file mode 100644 index 0000000000000000000000000000000000000000..b20b2a6d794a6d0b5cfffd72bac232afa1ef9035 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/stl_off.prf @@ -0,0 +1,3 @@ +CONFIG -= stl +QMAKE_CFLAGS += $$QMAKE_CFLAGS_STL_OFF +QMAKE_CXXFLAGS += $$QMAKE_CXXFLAGS_STL_OFF diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windeployqt.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windeployqt.prf new file mode 100644 index 0000000000000000000000000000000000000000..f42c53ae364901aa238bf363be05d9747af55105 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windeployqt.prf @@ -0,0 +1,19 @@ +# Extra target for running windeployqt +qtPrepareTool(QMAKE_WINDEPLOYQT, windeployqt) +build_pass { + load(resolve_target) + + isEmpty(WINDEPLOYQT_OPTIONS): WINDEPLOYQT_OPTIONS = -qmldir $$shell_quote($$system_path($$_PRO_FILE_PWD_)) + WINDEPLOYQT_TARGET = $$shell_quote($$system_path($$QMAKE_RESOLVED_TARGET)) + WINDEPLOYQT_OUTPUT = $$shell_quote($$system_path($$dirname(QMAKE_RESOLVED_TARGET)/$$basename(TARGET).windeployqt)) + windeployqt.target = windeployqt + windeployqt.commands = $$QMAKE_WINDEPLOYQT $$WINDEPLOYQT_OPTIONS -list target $$WINDEPLOYQT_TARGET > $$WINDEPLOYQT_OUTPUT + + windeployqt_clean.commands = if exist $$WINDEPLOYQT_OUTPUT for /f %i in ($$WINDEPLOYQT_OUTPUT) do $$QMAKE_DEL_FILE %~fi && $$QMAKE_DEL_DIR %~pi + DISTCLEAN_DEPS += windeployqt_clean + QMAKE_DISTCLEAN += $$WINDEPLOYQT_OUTPUT +} else { + windeployqt.CONFIG += recursive + windeployqt_clean.CONFIG += recursive +} +QMAKE_EXTRA_TARGETS += windeployqt windeployqt_clean diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windows.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windows.prf new file mode 100644 index 0000000000000000000000000000000000000000..27a746b687d4f2ec6bee1d7958937e7a36911a8c --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windows.prf @@ -0,0 +1,5 @@ +CONFIG -= console +QMAKE_LFLAGS += $$QMAKE_LFLAGS_WINDOWS +contains(TEMPLATE, ".*app") { + QMAKE_LFLAGS += $$QMAKE_LFLAGS_EXE +} diff --git a/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windows_vulkan_sdk.prf b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windows_vulkan_sdk.prf new file mode 100644 index 0000000000000000000000000000000000000000..4b03320547d368486584b5b47d9db1e8baf7f9e4 --- /dev/null +++ b/qt/6.8.1/msvc2022_64/mkspecs/features/win32/windows_vulkan_sdk.prf @@ -0,0 +1,13 @@ +isEmpty(QMAKE_INCDIR_VULKAN) { + # Pick up the VULKAN_SDK env var set by the LunarG SDK so that the Vulkan + # headers are found out-of-the-box on typical Windows setups. + QMAKE_INCDIR_VULKAN = $$(VULKAN_SDK)/include + + # Do not add default include paths as that can knock std headers + # out of their stride due to their usage of #include_next. + contains(QMAKE_DEFAULT_INCDIRS, $$re_escape($$QMAKE_INCDIR_VULKAN)): \ + QMAKE_INCDIR_VULKAN = + + # Do not export the include dir but resolve it on every qmake call. + QMAKE_EXPORT_INCDIR_VULKAN = - +}