3b9>QA @FɥTKB+ϜyurP5o2v!լY̰%Ʈ97> Z;.>ڱ0SqmHQiG CL9#~cE[usr/share/ECM/cmake/ECMConfig.cmakeSYA{]Ͽ!g`.0Cusr/share/ECM/cmake/ECMConfigVersion.cmakeR!*v85_41z[E9 d9"]^ Iusr/share/ECM/find-modules/ECMFindModuleHelpersStub.cmake3] "%lυ_FL]]#C. Dusr/share/ECM/find-modules/Find7Zip.cmakeڤ+= fN+dusr/share/ECM/find-modules/FindLibExiv2.cmakee5TEvIx'1˔ޭxzT) $3usr/share/ECM/find-modules/FindLibGit2.cmakejHӚC$*k]e@ usr/share/ECM/find-modules/FindLibMount.cmake4{:ʎL4XDURVXwusr/share/ECM/find-modules/FindLibcap.cmakeqnhPWnKHBVD&9iZusr/share/ECM/find-modules/FindOpenEXR.cmake$֔,pȳ҅@~u(er߹9 usr/share/ECM/find-modules/FindPhoneNumber.cmakefd0wJG35ۢ P߇g usr/share/ECM/find-modules/FindPoppler.cmake5A}K;hBƣx06glUeusr/share/ECM/find-modules/FindPulseAudio.cmake}mUKixljFw2 ewusr/share/ECM/find-modules/FindQHelpGenerator.cmakedb`ڱ 'i*|I%w䳩f; usr/share/ECM/find-modules/FindQtWaylandScanner.cmake}/ _y2}h ;ě.[a! *usr/share/ECM/find-modules/FindReuseTool.cmake_ vyjnZ K9@E -6 usr/share/ECM/find-modules/FindSasl2.cmakedr~rnbf+`ȓ?D8'oU0-1:x%9usr/share/ECM/find-modules/FindSeccomp.cmake_-j| OAwH=F@ usr/share/ECM/find-modules/FindSharedMimeInfo.cmakeN~!ʽ?uHQS#},L usr/share/ECM/find-modules/FindTaglib.cmaken $YNKhapQKBPEY8 Xusr/share/ECM/find-modules/FindUDev.cmakeA2##ia|n@&mbJ8Q;_usr/share/ECM/find-modules/FindWayland.cmake~d/:0*d i%Byqrusr/share/ECM/find-modules/FindWaylandProtocols.cmakeOf%WgJ?\4QJwusr/share/ECM/find-modules/FindWaylandScanner.cmake-xxۭxulrYJ.oTxWq usr/share/ECM/find-modules/FindX11_XCB.cmake 6`E!94i738Do#3pusr/share/ECM/find-modules/FindXCB.cmakeieG e.iZubH"3. usr/share/ECM/find-modules/Findepoxy.cmaket,Vt$vn0 )00za2usr/share/ECM/find-modules/Findgzip.cmake`":@ t:E<*8M6Wusr/share/ECM/find-modules/local.properties.cmake)z[٧sGqʝJ8A usr/share/ECM/find-modules/settings.gradle.cmake祡Gz"+5ΤϽ:gOnb=usr/share/ECM/kde-modules/KDECMakeSettings.cmake d{2y^VRFn#usr/share/ECM/kde-modules/KDEClangFormat.cmake:#kȀRu(GhWr؃usr/share/ECM/kde-modules/KDECompilerSettings.cmake-ϟe0+$gfeR >W usr/share/ECM/kde-modules/KDEFrameworkCompilerLegacySettings.cmakeoBOҐ!14e g5rA>@uu usr/share/ECM/kde-modules/KDEFrameworkCompilerSettings.cmakeB -ဎzY HAo<`7ěgRUausr/share/ECM/kde-modules/KDEGitCommitHooks.cmake?9ٓ _T L;ɣ #^:usr/share/ECM/kde-modules/KDEInstallDirs.cmake 3Z$)p_* `1یe6E-x?usr/share/ECM/kde-modules/KDEInstallDirs5.cmakeb@1fN:Q.לޣʄusr/share/ECM/kde-modules/appstreamtest.cmakeZezDb1޴'ڟ5ʱDgCxP%a usr/share/ECM/kde-modules/clang-format.cmakeQZުk[3je $yybusr/share/ECM/kde-modules/kde-git-commit-hooks/clang-format.sh*\ڣ3ecŸ VR"busr/share/ECM/kde-modules/kde-git-commit-hooks/combined.schema.json.inhuW l]i 7[dd4Scusr/share/ECM/kde-modules/kde-git-commit-hooks/combined.schema.json.in.licenseV}S$-?SRrV* vWEusr/share/ECM/kde-modules/kde-git-commit-hooks/json-schema.pyidS))6>g̝a}˕۲+usr/share/ECM/kde-modules/kde-git-commit-hooks/pre-commit.inᔗZTO}Q[qզ5mvηusr/share/ECM/kde-modules/prefix.sh.cmake-ݚb9ǚ:̨inG%c\1|usr/share/ECM/kde-modules/prefix.sh.fish.cmake%b J(kJU)D-x*"N usr/share/ECM/modules/CheckAtomic.cmakeDZ y~-GD|qoXusr/share/ECM/modules/ECMAddAndroidApk.cmakeXMaV񸰔<YO9t$JglDusr/share/ECM/modules/ECMAddAppIcon.cmake`n =QzuV;IT< ͔'_37'usr/share/ECM/modules/ECMAddQch.cmakeLpY?b*PXIȡZYusr/share/ECM/modules/ECMAddQtDesignerPlugin.cmakea칾=125Y)yMEv4dFusr/share/ECM/modules/ECMAddTests.cmakei*TL{7kD1y^+8F렟3usr/share/ECM/modules/ECMCheckOutboundLicense.cmake8!OT өq |2 L usr/share/ECM/modules/ECMConfiguredInstall.cmake g|d)@դP(y8o["#pV*usr/share/ECM/modules/ECMCoverageOption.cmake>@Aݻ]j;&{Qm\ĀcZ"usr/share/ECM/modules/ECMCreateQmFromPoFiles.cmakeV[V7^wTI Knv@ְ*4 Vv;f}usr/share/ECM/modules/ECMDeprecationSettings.cmake.]#@I5 Rmk5wPsLq%usr/share/ECM/modules/ECMEnableSanitizers.cmake>ugyz]昩[φ5usr/share/ECM/modules/ECMFeatureSummary.cmake;pspf8wE./usr/share/ECM/modules/ECMFindModuleHelpers.cmake$E>-faIG&SmVDs\tF usr/share/ECM/modules/ECMFindQmlModule.cmake?e'FoSL {\㢨|X^f"usr/share/ECM/modules/ECMFindQmlModule.cmake.in:0PSnsNuܴ usr/share/ECM/modules/ECMGenerateDBusServiceFile.cmakeY86(ڏâwci]4(qڦdStusr/share/ECM/modules/ECMGenerateExportHeader.cmake,H 6q>I,줩1(U+#usr/share/ECM/modules/ECMGenerateHeaders.cmake\Vs_$|x~=_*t$F w*usr/share/ECM/modules/ECMGeneratePkgConfigFile.cmakeګP W&}$1?60M*usr/share/ECM/modules/ECMGeneratePriFile.cmake)("m>/7ZE64TC}x]˄ usr/share/ECM/modules/ECMGeneratePythonBindings.cmake[̱w9=P,ہ7T&B@U(usr/share/ECM/modules/ECMGeneratePythonBindings.toml.in}35./,!$,K s*rusr/share/ECM/modules/ECMGeneratePythonBindings.toml.in.licensejldaoL* [po&(Beٿ=M+A usr/share/ECM/modules/ECMGenerateQmlTypes.cmake)'_qan1V(Ȗbt܎4,usr/share/ECM/modules/ECMInstallIcons.cmakeW0fp^r;R̆se:\`usr/share/ECM/modules/ECMMarkAsTest.cmakexeNq>9[^ ͎@״F=eusr/share/ECM/modules/ECMMarkNonGuiExecutable.cmakeLNu EؖN$;Bhusr/share/ECM/modules/ECMOptionalAddSubdirectory.cmakeylei]]^#лy;ousr/share/ECM/modules/ECMPackageConfigHelpers.cmakeFI_,bǴa%׭Y$usr/share/ECM/modules/ECMPoQmTools.cmakexCg_y:a'fc@fkدCusr/share/ECM/modules/ECMQMLModules.cmakecvh>,v̈́c&aK)usr/share/ECM/modules/ECMQchDoxygen.config.inmzP$oܞ.&?2E}j fusr/share/ECM/modules/ECMQchDoxygenLayout.xmlOR[ zqگ@Xt ɲG{wusr/share/ECM/modules/ECMQmLoader.cpp.in{cBC09[Zb5싶ȕ!usr/share/ECM/modules/ECMQmlModule.cmake_;I β-AN)UK# e'usr/share/ECM/modules/ECMQmlModule.cpp.in+$4ay㹩(7|V8`b,$(busr/share/ECM/modules/ECMQmlModule.cpp.in.licenseg0V`D2ҖBqE`e2*r-s(dusr/share/ECM/modules/ECMQmlModule.h.in+$4ay㹩(7|V8`b,$)busr/share/ECM/modules/ECMQmlModule.h.in.license5A&i5g̎onz%O鍯9*7usr/share/ECM/modules/ECMQmlModule5.cmake>3N^QAS^9gߝV_рa>'usr/share/ECM/modules/ECMQmlModule6.cmake̡d&H&`\?v9AbwjK->6V@usr/share/ECM/modules/ECMQtDeclareLoggingCategory.cmakem\7;y2m C6?ꡓw@.usr/share/ECM/modules/ECMQtDeclareLoggingCategory.cpp.inA;hX{;%'MT,;wousr/share/ECM/modules/ECMQtDeclareLoggingCategory.h.in>zЇcj)S!kx\U}|[uusr/share/ECM/modules/ECMQueryQmake.cmake(m>vgbpJ՜O8hXoIEDuN usr/share/ECM/modules/ECMQueryQt.cmakeԖ9A?BZ=BKygrA!usr/share/ECM/modules/ECMSetupQtPluginMacroNames.cmakeͩǒoiԼ ӶjUuQӉ "usr/share/ECM/modules/ECMSetupVersion.cmakeT":v8o|طZ+F4s Ce$ )usr/share/ECM/modules/ECMSourceVersionControl.cmakeO&pVCig[+q3n|' usr/share/ECM/modules/ECMUninstallTarget.cmake+`u.M X|Ij~r6b#!0#=: S. usr/share/ECM/modules/ECMUseFindModules.cmake \$ x#&ĘN\̺+0: usr/share/ECM/modules/ECMVersionHeader.h.inN/{]k> 46n 6;%en#< usr/share/ECM/modules/ECMWinResolveSymlinks.cmake-gvyTFmyo~k}@C7L usr/share/ECM/modules/QtVersionOption.cmakebVERj mYsҌ;RbeQ usr/share/ECM/modules/check-outbound-license.pyB{24Gh/DaZ\"n3)pb ,usr/share/ECM/modules/ecm_uninstall.cmake.in<ODJZA& " ,/o4e (usr/share/ECM/test-modules/test_execute_and_compare.cmake4]kȜ%kaLYl ^$Pd5 \g 7usr/share/ECM/toolchain/Android.cmake@",.$kXwp"yr usr/share/ECM/toolchain/ECMAndroidDeployQt5.cmake)u#V~3&; qs(^>f| pusr/share/ECM/toolchain/deployment-file-qt514.json.inħ0 ۧ(AEQ?, usr/share/ECM/toolchain/deployment-file-qt6.json.in+cF*0ȁ!$BJSӾL gusr/share/ECM/toolchain/deployment-file-qt6.json.in.licensefЎ#'&+ R]KF usr/share/ECM/toolchain/deployment-file.json.inu.B'50(:sPK׬iJ Nusr/share/ECM/toolchain/generate-fastlane-metadata.py[&毚Z`;9'7ih8cx lusr/share/ECM/toolchain/hasMainSymbol.cmakeVh^ Vѐk'pz'n kusr/share/ECM/toolchain/specifydependencies.cmake ####### 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 ECMConfig.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() #################################################################################### set(ECM_FIND_MODULE_DIR "${PACKAGE_PREFIX_DIR}/share/ECM/find-modules/") set(ECM_MODULE_DIR "${PACKAGE_PREFIX_DIR}/share/ECM/modules/") set(ECM_KDE_MODULE_DIR "${PACKAGE_PREFIX_DIR}/share/ECM/kde-modules/") set(ECM_PREFIX "/usr") set(ECM_MODULE_PATH "${ECM_MODULE_DIR}" "${ECM_FIND_MODULE_DIR}" "${ECM_KDE_MODULE_DIR}") set(ECM_GLOBAL_FIND_VERSION "${ECM_FIND_VERSION}") include("${ECM_MODULE_DIR}/ECMUseFindModules.cmake") # 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.10.0") 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 "" 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 "") math(EXPR installedBits " * 8") set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") set(PACKAGE_VERSION_UNSUITABLE TRUE) endif() include(${CMAKE_CURRENT_LIST_DIR}/../modules/ECMFindModuleHelpers.cmake) # SPDX-FileCopyrightText: 2019, 2021, 2023 Friedrich W. H. Kossebau # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: Find7Zip -------- Try to find 7-Zip. If the 7-Zip executable is not in your PATH, you can provide an alternative name or full path location with the ``7Zip_EXECUTABLE`` variable. This will define the following variables: ``7Zip_FOUND`` TRUE if 7-Zip is available ``7Zip_EXECUTABLE`` Path to 7-Zip executable If ``7Zip_FOUND`` is TRUE, it will also define the following imported target: ``7Zip::7Zip`` Path to 7-Zip executable .. note:: It will see to only find the original 7-Zip, not one of the p7zip forks. Since 5.113.0. #]=======================================================================] if(WIN32) find_program(7Zip_EXECUTABLE NAMES 7z 7za) else() # Some p7zip used to be a fork for Linux of older 7-Zip, # just supporting the 7z format, and occupied the 7z binary name. # When 7-Zip got its official Linux support, it chose 7zz to not conflict, # given it also has another set of arguments. # Later p7zip was forked once more into some p7zip-zstd, using a newer copy of 7-Zip, # supporting more than 7z format, therefore also many of the arguments known from 7-Zip. # Being a different project though and now a real fork due to 7-Zip supporting Linux, # we try to only find the original here, so consumers can rely on the original 7-Zip documentation. find_program(7Zip_EXECUTABLE NAMES 7zz) endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(7Zip FOUND_VAR 7Zip_FOUND REQUIRED_VARS 7Zip_EXECUTABLE ) mark_as_advanced(7Zip_EXECUTABLE) if(NOT TARGET 7Zip::7Zip AND 7Zip_FOUND) add_executable(7Zip::7Zip IMPORTED) set_target_properties(7Zip::7Zip PROPERTIES IMPORTED_LOCATION "${7Zip_EXECUTABLE}" ) endif() include(FeatureSummary) set_package_properties(7Zip PROPERTIES URL "https://www.7-zip.org/" DESCRIPTION "Data (de)compression program" ) # SPDX-FileCopyrightText: 2019, 2021 Friedrich W. H. Kossebau # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: Find7z ------ Try to find 7z. If the 7z executable is not in your PATH, you can provide an alternative name or full path location with the ``7z_EXECUTABLE`` variable. This will define the following variables: ``7z_FOUND`` TRUE if 7z is available ``7z_EXECUTABLE`` Path to 7z executable If ``7z_FOUND`` is TRUE, it will also define the following imported target: ``7z::7z`` Path to 7z executable .. note:: Only works on Windows. Deprecated: since 5.113, use :find-module:`Find7Zip`. Since 5.85.0. #]=======================================================================] find_program(7z_EXECUTABLE NAMES 7z.exe 7za.exe) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(7z FOUND_VAR 7z_FOUND REQUIRED_VARS 7z_EXECUTABLE ) mark_as_advanced(7z_EXECUTABLE) if(NOT TARGET 7z::7z AND 7z_FOUND) add_executable(7z::7z IMPORTED) set_target_properties(7z::7z PROPERTIES IMPORTED_LOCATION "${7z_EXECUTABLE}" ) endif() include(FeatureSummary) set_package_properties(7z PROPERTIES URL "https://www.7-zip.org/" DESCRIPTION "Data (de)compression program" ) # SPDX-FileCopyrightText: 2012 Raphael Kubo da Costa # SPDX-FileCopyrightText: 2019 Harald Sitter # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindCanberra ------------ Try to find Canberra event sound library. This will define the following variables: ``Canberra_FOUND`` True if (the requested version of) Canberra is available ``Canberra_VERSION`` The version of Canberra ``Canberra_LIBRARIES`` The libraries of Canberra for use with target_link_libraries() ``Canberra_INCLUDE_DIRS`` The include dirs of Canberra for use with target_include_directories() If ``Canberra_FOUND`` is TRUE, it will also define the following imported target: ``Canberra::Canberra`` The Canberra library In general we recommend using the imported target, as it is easier to use. Bear in mind, however, that if the target is in the link interface of an exported library, it must be made available by the package config file. Since 5.56.0. #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PC_Canberra QUIET IMPORTED_TARGET libcanberra) find_library(Canberra_LIBRARIES NAMES canberra HINTS ${PC_Canberra_LIBRARY_DIRS} ) find_path(Canberra_INCLUDE_DIRS NAMES canberra.h HINTS ${PC_Canberra_INCLUDE_DIRS} ) set(Canberra_VERSION ${PC_Canberra_VERSION}) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Canberra FOUND_VAR Canberra_FOUND REQUIRED_VARS Canberra_LIBRARIES Canberra_INCLUDE_DIRS VERSION_VAR Canberra_VERSION ) if(Canberra_FOUND AND NOT TARGET Canberra::Canberra) add_library(Canberra::Canberra UNKNOWN IMPORTED) set_target_properties(Canberra::Canberra PROPERTIES IMPORTED_LOCATION "${Canberra_LIBRARIES}" INTERFACE_COMPILE_OPTIONS "${PC_Canberra_CFLAGS}" INTERFACE_INCLUDE_DIRECTORIES "${Canberra_INCLUDE_DIRS}" ) if (TARGET PkgConfig::PC_Canberra) target_link_libraries(Canberra::Canberra INTERFACE PkgConfig::PC_Canberra) endif() endif() mark_as_advanced(Canberra_LIBRARIES Canberra_INCLUDE_DIRS Canberra_VERSION) include(FeatureSummary) set_package_properties(Canberra PROPERTIES DESCRIPTION "Event sound library" URL "https://0pointer.de/lennart/projects/libcanberra" ) # Compatibility variables. In a previous life FindCanberra lived # in a number of different repos: don't break them if they use ECM but have not # been updated for this finder. set(CANBERRA_FOUND ${Canberra_FOUND}) set(CANBERRA_VERSION ${Canberra_VERSION}) set(CANBERRA_LIBRARIES ${Canberra_LIBRARIES}) set(CANBERRA_INCLUDE_DIRS ${Canberra_INCLUDE_DIRS}) mark_as_advanced(CANBERRA_VERSION CANBERRA_LIBRARIES CANBERRA_INCLUDE_DIRS) # SPDX-FileCopyrightText: 2014 Alex Merry # SPDX-FileCopyrightText: 2014 Martin Gräßlin # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindEGL ------- Try to find EGL. This will define the following variables: ``EGL_FOUND`` True if (the requested version of) EGL is available ``EGL_VERSION`` The version of EGL; note that this is the API version defined in the headers, rather than the version of the implementation (eg: Mesa) ``EGL_LIBRARIES`` This can be passed to target_link_libraries() instead of the ``EGL::EGL`` target ``EGL_INCLUDE_DIRS`` This should be passed to target_include_directories() if the target is not used for linking ``EGL_DEFINITIONS`` This should be passed to target_compile_options() if the target is not used for linking If ``EGL_FOUND`` is TRUE, it will also define the following imported target: ``EGL::EGL`` The EGL library In general we recommend using the imported target, as it is easier to use. Bear in mind, however, that if the target is in the link interface of an exported library, it must be made available by the package config file. Since pre-1.0.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) include(CheckCXXSourceCompiles) include(CMakePushCheckState) ecm_find_package_version_check(EGL) # Use pkg-config to get the directories and then use these values # in the FIND_PATH() and FIND_LIBRARY() calls find_package(PkgConfig QUIET) pkg_check_modules(PKG_EGL QUIET egl) set(EGL_DEFINITIONS ${PKG_EGL_CFLAGS_OTHER}) find_path(EGL_INCLUDE_DIR NAMES EGL/egl.h HINTS ${PKG_EGL_INCLUDE_DIRS} ) find_library(EGL_LIBRARY NAMES EGL libEGL HINTS ${PKG_EGL_LIBRARY_DIRS} ) # NB: We do *not* use the version information from pkg-config, as that # is the implementation version (eg: the Mesa version) if(EGL_INCLUDE_DIR) # egl.h has defines of the form EGL_VERSION_x_y for each supported # version; so the header for EGL 1.1 will define EGL_VERSION_1_0 and # EGL_VERSION_1_1. Finding the highest supported version involves # finding all these defines and selecting the highest numbered. file(READ "${EGL_INCLUDE_DIR}/EGL/egl.h" _EGL_header_contents) string(REGEX MATCHALL "[ \t]EGL_VERSION_[0-9_]+" _EGL_version_lines "${_EGL_header_contents}" ) unset(_EGL_header_contents) foreach(_EGL_version_line ${_EGL_version_lines}) string(REGEX REPLACE "[ \t]EGL_VERSION_([0-9_]+)" "\\1" _version_candidate "${_EGL_version_line}" ) string(REPLACE "_" "." _version_candidate "${_version_candidate}") if(NOT DEFINED EGL_VERSION OR EGL_VERSION VERSION_LESS _version_candidate) set(EGL_VERSION "${_version_candidate}") endif() endforeach() unset(_EGL_version_lines) endif() cmake_push_check_state(RESET) list(APPEND CMAKE_REQUIRED_LIBRARIES "${EGL_LIBRARY}") list(APPEND CMAKE_REQUIRED_INCLUDES "${EGL_INCLUDE_DIR}") check_cxx_source_compiles(" #include int main(int argc, char *argv[]) { EGLint x = 0; EGLDisplay dpy = 0; EGLContext ctx = 0; eglDestroyContext(dpy, ctx); }" HAVE_EGL) cmake_pop_check_state() set(required_vars EGL_INCLUDE_DIR HAVE_EGL) if(NOT EMSCRIPTEN) list(APPEND required_vars EGL_LIBRARY) endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(EGL FOUND_VAR EGL_FOUND REQUIRED_VARS ${required_vars} VERSION_VAR EGL_VERSION ) if(EGL_FOUND AND NOT TARGET EGL::EGL) if (EMSCRIPTEN) add_library(EGL::EGL INTERFACE IMPORTED) # Nothing further to be done, system include paths have headers and linkage is implicit. else() add_library(EGL::EGL UNKNOWN IMPORTED) set_target_properties(EGL::EGL PROPERTIES IMPORTED_LOCATION "${EGL_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${EGL_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${EGL_INCLUDE_DIR}" ) endif() endif() mark_as_advanced(EGL_LIBRARY EGL_INCLUDE_DIR HAVE_EGL) # compatibility variables set(EGL_LIBRARIES ${EGL_LIBRARY}) set(EGL_INCLUDE_DIRS ${EGL_INCLUDE_DIR}) set(EGL_VERSION_STRING ${EGL_VERSION}) include(FeatureSummary) set_package_properties(EGL PROPERTIES URL "https://www.khronos.org/egl/" DESCRIPTION "A platform-agnostic mechanism for creating rendering surfaces for use with other graphics libraries, such as OpenGL|ES and OpenVG." ) # SPDX-FileCopyrightText: 2008 Laurent Montel # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindGLIB2 --------- Try to locate the GLib2 library. If found, this will define the following variables: ``GLIB2_FOUND`` True if the GLib2 library is available ``GLIB2_INCLUDE_DIRS`` The GLib2 include directories ``GLIB2_LIBRARIES`` The GLib2 libraries for linking ``GLIB2_INCLUDE_DIR`` Deprecated, use ``GLIB2_INCLUDE_DIRS`` ``GLIB2_LIBRARY`` Deprecated, use ``GLIB2_LIBRARIES`` If ``GLIB2_FOUND`` is TRUE, it will also define the following imported target: ``GLIB2::GLIB2`` The GLIB2 library ``GLIB2::GTHREAD2`` The GThread2 library (since 6.7.0) ``GLIB2::GOBJECT`` The GObject library (since 6.7.0) ``GLIB2::GIO`` The GIO library (since 6.7.0) Since 5.41.0. #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PC_GLIB2 QUIET glib-2.0) find_path(GLIB2_INCLUDE_DIRS NAMES glib.h HINTS ${PC_GLIB2_INCLUDEDIR} PATH_SUFFIXES glib-2.0) find_library(GLIB2_LIBRARIES NAMES glib-2.0 HINTS ${PC_GLIB2_LIBDIR} ) pkg_check_modules(PC_GTHREAD2 QUIET gthread-2.0) find_library(GTHREAD2_LIBRARIES NAMES gthread-2.0 HINTS ${PC_GTHREAD2_LIBDIR} ) pkg_check_modules(PC_GOBJECT QUIET gobject-2.0) find_path(GLIB2_GOBJECT_INCLUDE_DIRS NAMES glib-object.h HINTS ${PC_GOBJECT_INCLUDEDIR} PATH_SUFFIXES glib-2.0) find_library(GLIB2_GOBJECT_LIBRARIES NAMES gobject-2.0 HINTS ${PC_GOBJECT_LIBDIR} ) pkg_check_modules(PC_GIO QUIET gio-2.0) find_path(GLIB2_GIO_INCLUDE_DIRS NAMES gio/gio.h HINTS ${PC_GIO_INCLUDEDIR} PATH_SUFFIXES glib-2.0) find_library(GLIB2_GIO_LIBRARIES NAMES gio-2.0 HINTS ${PC_GIO_LIBDIR} ) # search the glibconfig.h include dir under the same root where the library is found get_filename_component(glib2LibDir "${GLIB2_LIBRARIES}" PATH) find_path(GLIB2_INTERNAL_INCLUDE_DIR glibconfig.h PATH_SUFFIXES glib-2.0/include HINTS ${PC_GLIB2_INCLUDEDIR} "${glib2LibDir}" ${CMAKE_SYSTEM_LIBRARY_PATH}) # not sure if this include dir is optional or required # for now it is optional if(GLIB2_INTERNAL_INCLUDE_DIR) list(APPEND GLIB2_INCLUDE_DIRS "${GLIB2_INTERNAL_INCLUDE_DIR}") list(APPEND GLIB2_GOBJECT_INCLUDE_DIRS "${GLIB2_INTERNAL_INCLUDE_DIR}") list(APPEND GLIB2_GIO_INCLUDE_DIRS "${GLIB2_INTERNAL_INCLUDE_DIR}") endif() # Deprecated synonyms set(GLIB2_INCLUDE_DIR "${GLIB2_INCLUDE_DIRS}") set(GLIB2_LIBRARY "${GLIB2_LIBRARIES}") set(GLIB2_GOBJECT_INCLUDE_DIR "${GLIB2_GOBJECT_INCLUDE_DIRS}") set(GLIB2_GOBJECT_LIBRARY "${GLIB2_GOBJECT_LIBRARIES}") set(GLIB2_GIO_INCLUDE_DIR "${GLIB2_GIO_INCLUDE_DIRS}") set(GLIB2_GIO_LIBRARY "${GLIB2_GIO_LIBRARIES}") if(GLIB2_GOBJECT_LIBRARIES AND GLIB2_GOBJECT_INCLUDE_DIRS) set(GLIB2_GOBJECT_FOUND TRUE) endif() if(GLIB2_GIO_LIBRARIES AND GLIB2_GIO_INCLUDE_DIRS) set(GLIB2_GIO_FOUND TRUE) endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(GLIB2 REQUIRED_VARS GLIB2_LIBRARIES GTHREAD2_LIBRARIES GLIB2_INCLUDE_DIRS HANDLE_COMPONENTS) if(GLIB2_FOUND AND NOT TARGET GLIB2::GLIB2) add_library(GLIB2::GLIB2 UNKNOWN IMPORTED) set_target_properties(GLIB2::GLIB2 PROPERTIES IMPORTED_LOCATION "${GLIB2_LIBRARIES}" INTERFACE_LINK_LIBRARIES "${GTHREAD2_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${GLIB2_INCLUDE_DIRS}") endif() if(GLIB2_GOBJECT_FOUND AND NOT TARGET GLIB2::GOBJECT) add_library(GLIB2::GOBJECT UNKNOWN IMPORTED) set_target_properties(GLIB2::GOBJECT PROPERTIES IMPORTED_LOCATION "${GLIB2_GOBJECT_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${GLIB2_GOBJECT_INCLUDE_DIRS}") endif() if(GLIB2_GIO_FOUND AND NOT TARGET GLIB2::GIO) add_library(GLIB2::GIO UNKNOWN IMPORTED) set_target_properties(GLIB2::GIO PROPERTIES IMPORTED_LOCATION "${GLIB2_GIO_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${GLIB2_GIO_INCLUDE_DIRS}") endif() mark_as_advanced(GLIB2_INCLUDE_DIRS GLIB2_INCLUDE_DIR GLIB2_LIBRARIES GLIB2_LIBRARY GLIB2_GOBJECT_INCLUDE_DIRS GLIB2_GOBJECT_INCLUDE_DIR GLIB2_GOBJECT_LIBRARIES GLIB2_GOBJECT_LIBRARY GLIB2_GIO_INCLUDE_DIRS GLIB2_GIO_INCLUDE_DIR GLIB2_GIO_LIBRARIES GLIB2_GIO_LIBRARY) include(FeatureSummary) set_package_properties(GLIB2 PROPERTIES URL "https://wiki.gnome.org/Projects/GLib" DESCRIPTION "Event loop and utility library") # SPDX-FileCopyrightText: 2016-2017 Pino Toscano # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindGperf ----------- Try to find GNU gperf. If the gperf executable is not in your PATH, you can provide an alternative name or full path location with the ``Gperf_EXECUTABLE`` variable. This will define the following variables: ``Gperf_FOUND`` True if gperf is available. ``Gperf_EXECUTABLE`` The gperf executable. ``Gperf_VERSION`` The gperf version. (since 5.85) If ``Gperf_FOUND`` is TRUE, it will also define the following imported target: ``GPerf::Gperf`` The gperf executable. and the following public function: :: ecm_gperf_generate( [GENERATION_FLAGS ]) Run ``gperf`` on ```` to generate ````, adding it to the ```` variable which contains the source for the target where ```` is going to be built or, since KF 5.83, if the given argument is a target, to the list of private sources of that target. The target must not be an alias. The optional ``GENERATION_FLAGS`` argument is needed to pass extra parameters to ``gperf`` (note you cannot override that way the output file). A simple invocation would be: .. code-block:: cmake ecm_gperf_generate(simple.gperf ${CMAKE_CURRENT_BINARY_DIR}/simple.h MySources) Since 5.35.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(Gperf) # Find gperf find_program(Gperf_EXECUTABLE NAMES gperf) if(Gperf_EXECUTABLE) execute_process(COMMAND ${Gperf_EXECUTABLE} -v OUTPUT_VARIABLE _version_string ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) if(_version_string MATCHES "^GNU gperf ([-0-9\\.]+)") set(Gperf_VERSION "${CMAKE_MATCH_1}") endif() unset(_version_string) else() set(Gperf_VERSION) endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Gperf FOUND_VAR Gperf_FOUND REQUIRED_VARS Gperf_EXECUTABLE VERSION_VAR Gperf_VERSION ) mark_as_advanced(Gperf_EXECUTABLE) if (Gperf_FOUND) if (NOT TARGET GPerf::Gperf) add_executable(GPerf::Gperf IMPORTED) set_target_properties(GPerf::Gperf PROPERTIES IMPORTED_LOCATION "${Gperf_EXECUTABLE}" ) endif() endif() include(FeatureSummary) set_package_properties(Gperf PROPERTIES URL "https://www.gnu.org/software/gperf/" DESCRIPTION "Perfect hash function generator" ) function(ecm_gperf_generate input_file output_file _target_or_sources_var) # Parse arguments set(oneValueArgs GENERATION_FLAGS) cmake_parse_arguments(ARGS "" "${oneValueArgs}" "" ${ARGN}) if(ARGS_UNPARSED_ARGUMENTS) message(FATAL_ERROR "Unknown keywords given to ecm_gperf_generate(): \"${ARGS_UNPARSED_ARGUMENTS}\"") endif() if (TARGET ${_target_or_sources_var}) get_target_property(aliased_target ${_target_or_sources_var} ALIASED_TARGET) if(aliased_target) message(FATAL_ERROR "Target argument passed to ecm_gperf_generate must not be an alias: ${_target_or_sources_var}") endif() endif() get_filename_component(_infile ${input_file} ABSOLUTE) set(_extraopts "${ARGS_GENERATION_FLAGS}") separate_arguments(_extraopts) add_custom_command(OUTPUT ${output_file} COMMAND ${Gperf_EXECUTABLE} ${_extraopts} --output-file=${output_file} ${_infile} DEPENDS ${_infile} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} VERBATIM ) set_property(SOURCE ${output_file} PROPERTY SKIP_AUTOMOC ON) if (TARGET ${_target_or_sources_var}) target_sources(${_target_or_sources_var} PRIVATE ${output_file}) else() set(${_target_or_sources_var} ${${_target_or_sources_var}} ${output_file} PARENT_SCOPE) endif() endfunction() # SPDX-FileCopyrightText: 2019 Volker Krause # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindGradle ---------- Provides the ability to build Android AAR libraries using Gradle. This relies on the Qt provided Gradle, so a Qt for Android installation is required. :: gradle_add_aar( BUIDLFILE build.gradle NAME ) This builds an Android AAR library using the given ``build.gradle`` file. :: gradle_install_aar( DESTINATION ) Installs a Android AAR library that has been created with ``gradle_add_aar``. Since 5.76.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/../modules/QtVersionOption.cmake) include(FindPackageHandleStandardArgs) find_package(Qt${QT_MAJOR_VERSION}Core REQUIRED) set (Gradle_PRECOMMAND "") if (NOT WIN32) set(Gradle_EXECUTABLE ${CMAKE_BINARY_DIR}/gradle/gradlew) # the gradlew script installed by Qt6 is not executable, so running it directly fails if (QT_MAJOR_VERSION EQUAL "6") set(Gradle_PRECOMMAND "sh") endif() else() set(Gradle_EXECUTABLE ${CMAKE_BINARY_DIR}/gradle/gradlew.bat) endif() get_target_property(_qt_core_location Qt${QT_MAJOR_VERSION}::Core LOCATION) get_filename_component(_qt_install_root ${_qt_core_location} DIRECTORY) get_filename_component(_qt_install_root ${_qt_install_root}/../ ABSOLUTE) set(_gradle_template_dir ${CMAKE_CURRENT_LIST_DIR}) add_custom_command(OUTPUT ${Gradle_EXECUTABLE} COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/gradle COMMAND ${CMAKE_COMMAND} -E copy_directory ${_qt_install_root}/src/3rdparty/gradle ${CMAKE_BINARY_DIR}/gradle ) add_custom_target(gradle DEPENDS ${Gradle_EXECUTABLE}) # Android Gradle plugin version (not the Gradle version!) used by Qt, for use in our own build.gradle files file(READ ${_qt_install_root}/src/android/templates/build.gradle _build_grade_template) string(REGEX MATCH "[0-9]+\.[0-9]+\.[0-9]+" Gradle_ANDROID_GRADLE_PLUGIN_VERSION ${_build_grade_template}) find_package_handle_standard_args(Gradle DEFAULT_MSG Gradle_EXECUTABLE) function(gradle_add_aar target) cmake_parse_arguments(ARG "" "BUILDFILE;NAME" "" ${ARGN}) set(_build_root ${CMAKE_CURRENT_BINARY_DIR}/gradle_build/${ARG_NAME}) configure_file(${_gradle_template_dir}/local.properties.cmake ${_build_root}/local.properties) configure_file(${_gradle_template_dir}/settings.gradle.cmake ${_build_root}/settings.gradle) configure_file(${ARG_BUILDFILE} ${_build_root}/build.gradle) if (CMAKE_BUILD_TYPE MATCHES "[Dd][Ee][Bb][Uu][Gg]") set(_aar_suffix "-debug") set(_aar_gradleCmd "assembleDebug") else() set(_aar_suffix "-release") set(_aar_gradleCmd "assembleRelease") endif() file(GLOB_RECURSE _src_files CONFIGURE_DEPENDS "*") add_custom_command( OUTPUT ${_build_root}/build/outputs/aar/${ARG_NAME}${_aar_suffix}.aar COMMAND ${Gradle_PRECOMMAND} ${Gradle_EXECUTABLE} ${_aar_gradleCmd} # this allows make create-apk to work without installations for apps with AAR libs in the same repository COMMAND ${CMAKE_COMMAND} -E copy ${_build_root}/build/outputs/aar/${ARG_NAME}${_aar_suffix}.aar ${CMAKE_BINARY_DIR}/jar/${ARG_NAME}.aar DEPENDS ${Gradle_EXECUTABLE} ${_src_files} DEPENDS gradle WORKING_DIRECTORY ${_build_root} ) add_custom_target(${target} ALL DEPENDS ${_build_root}/build/outputs/aar/${ARG_NAME}${_aar_suffix}.aar) set_target_properties(${target} PROPERTIES LOCATION ${_build_root}/build/outputs/aar/${ARG_NAME}${_aar_suffix}.aar) set_target_properties(${target} PROPERTIES OUTPUT_NAME ${ARG_NAME}) endfunction() function(gradle_install_aar target) cmake_parse_arguments(ARG "" "DESTINATION" "" ${ARGN}) get_target_property(_loc ${target} LOCATION) get_target_property(_name ${target} OUTPUT_NAME) install(FILES ${_loc} DESTINATION ${ARG_DESTINATION} RENAME ${_name}.aar) endfunction() # SPDX-FileCopyrightText: 2017 Vincent Pinon # SPDX-FileCopyrightText: 2014 Alex Merry # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindIcoTool ----------- Try to find icotool. If the icotool executable is not in your PATH, you can provide an alternative name or full path location with the ``IcoTool_EXECUTABLE`` variable. This will define the following variables: ``IcoTool_FOUND`` True if icotool is available. ``IcoTool_EXECUTABLE`` The icotool executable. If ``IcoTool_FOUND`` is TRUE, it will also define the following imported target: ``IcoTool::IcoTool`` The icotool executable. Since 5.49. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(IcoTool) find_program(IcoTool_EXECUTABLE NAMES icotool) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(IcoTool FOUND_VAR IcoTool_FOUND REQUIRED_VARS IcoTool_EXECUTABLE ) mark_as_advanced(IcoTool_EXECUTABLE) if (IcoTool_FOUND) if (NOT TARGET IcoTool::IcoTool) add_executable(IcoTool::IcoTool IMPORTED) set_target_properties(IcoTool::IcoTool PROPERTIES IMPORTED_LOCATION "${IcoTool_EXECUTABLE}" ) endif() endif() include(FeatureSummary) set_package_properties(IcoTool PROPERTIES URL "https://www.nongnu.org/icoutils/" DESCRIPTION "Executable that converts a collection of PNG files into a Windows icon file" ) # SPDX-FileCopyrightText: 2016 Tobias C. Berner # SPDX-FileCopyrightText: 2017 Adriaan de Groot # # SPDX-License-Identifier: BSD-2-Clause #[=======================================================================[.rst: FindInotify -------------- Try to find inotify on this system. This finds: - libinotify on Unix like systems, or - the kernel's inotify on Linux systems. This will define the following variables: ``Inotify_FOUND`` True if inotify is available ``Inotify_LIBRARIES`` This has to be passed to target_link_libraries() ``Inotify_INCLUDE_DIRS`` This has to be passed to target_include_directories() On Linux and SunOS, the libraries and include directories are empty, even though ``Inotify_FOUND`` may be set to TRUE. This is because no special includes or libraries are needed. On other systems these may be needed to use inotify. Since 5.32.0. #]=======================================================================] find_path(Inotify_INCLUDE_DIRS sys/inotify.h) if(Inotify_INCLUDE_DIRS) # On Linux and SunOS, there is no library to link against, on the BSDs there is. # On the BSD's, inotify is implemented through a library, libinotify. if(CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "SunOS") set(Inotify_FOUND TRUE) set(Inotify_LIBRARIES "") set(Inotify_INCLUDE_DIRS "") else() find_library(Inotify_LIBRARIES NAMES inotify) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Inotify FOUND_VAR Inotify_FOUND REQUIRED_VARS Inotify_LIBRARIES Inotify_INCLUDE_DIRS ) mark_as_advanced(Inotify_LIBRARIES Inotify_INCLUDE_DIRS) include(FeatureSummary) set_package_properties(Inotify PROPERTIES URL "https://github.com/libinotify-kqueue/" DESCRIPTION "inotify API on the *BSD family of operating systems." ) endif() if(NOT TARGET Inotify::Inotify) add_library(Inotify::Inotify INTERFACE IMPORTED) set_property(TARGET Inotify::Inotify PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${Inotify_INCLUDE_DIRS}") set_property(TARGET Inotify::Inotify PROPERTY INTERFACE_LINK_LIBRARIES "${Inotify_LIBRARIES}") endif() else() set(Inotify_FOUND FALSE) endif() mark_as_advanced(Inotify_LIBRARIES Inotify_INCLUDE_DIRS) # SPDX-FileCopyrightText: 2016 Pino Toscano # SPDX-FileCopyrightText: 2021 Volker Krause # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindIsoCodes ------------ Try to find iso-codes data files. Once done this will define: ``IsoCodes_FOUND`` Whether the system has iso-codes ``IsoCodes_PREFIX`` The location in which the iso-codes data files are found ``IsoCodes_DOMAINS`` The available domains provided by iso-codes Since 5.80.0. #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PKG_iso_codes QUIET iso-codes) set(IsoCodes_VERSION ${PKG_iso_codes_VERSION}) set(IsoCodes_PREFIX ${PKG_iso_codes_PREFIX}) pkg_get_variable(IsoCodes_DOMAINS iso-codes domains) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(IsoCodes FOUND_VAR IsoCodes_FOUND REQUIRED_VARS IsoCodes_DOMAINS IsoCodes_PREFIX VERSION_VAR IsoCodes_VERSION ) include(FeatureSummary) set_package_properties(IsoCodes PROPERTIES URL "https://salsa.debian.org/iso-codes-team/iso-codes" DESCRIPTION "Data about various ISO standards (e.g. country, language, language scripts, and currency names)" ) # SPDX-FileCopyrightText: 2014 Alex Merry # SPDX-FileCopyrightText: 2013 Stephen Kelly # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindKF5 ------- Find KDE Frameworks 5 with a single find_package() call. This will use the package config files provided by the individual frameworks. For example, if you wish to find KArchive, which presents itself to CMake as KF5Archive (ie: you would do ``find_package(KF5Archive)`` to find it directly), you can do .. code-block:: cmake find_package(KF5 COMPONENTS Archive) If all the required components (those given in the COMPONENTS argument, but not those given in the OPTIONAL_COMPONENTS argument) are found, ``KF5_FOUND`` will be set to true. Otherwise, it will be set to false. Since pre-1.0.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(KF5) if (NOT KF5_FIND_COMPONENTS) set(KF5_NOT_FOUND_MESSAGE "The KF5 package requires at least one component") set(KF5_FOUND False) return() endif() set(_quiet_arg) if (KF5_FIND_QUIETLY) set(_quiet_arg QUIET) endif() set(_exact_arg) if (KF5_FIND_EXACT) set(_exact_arg EXACT) endif() include(FindPackageHandleStandardArgs) include(FeatureSummary) set(KF5_VERSION) foreach(_module ${KF5_FIND_COMPONENTS}) find_package(KF5${_module} ${KF5_FIND_VERSION} ${_exact_arg} ${_quiet_arg} CONFIG ) # CMake >= 3.17 wants to be explicitly told we are fine with name mismatch here set(_name_mismatched_arg) if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.17) set(_name_mismatched_arg NAME_MISMATCHED) endif() find_package_handle_standard_args(KF5${_module} CONFIG_MODE ${_name_mismatched_arg}) if (KF5_FIND_REQUIRED AND KF5_FIND_REQUIRED_${_module}) # If the component was required, we tell FeatureSummary so that it # will be displayed in the correct list. We do not use the REQUIRED # argument of find_package() to allow all the missing frameworks # to be listed at once (fphsa will error out at the end of this file # anyway). set_package_properties(KF5${_module} PROPERTIES TYPE REQUIRED) endif() # Component-based find modules are expected to set # __FOUND and __VERSION variables, # but the find_package calls above will have set KF5_* # variables. set(KF5_${_module}_FOUND ${KF5${_module}_FOUND}) if(KF5${_module}_FOUND) set(KF5_${_module}_VERSION ${KF5${_module}_VERSION}) # make KF5_VERSION the minimum found version if(NOT KF5_VERSION OR KF5_VERSION VERSION_GREATER KF5${_module}_VERSION) set(KF5_VERSION ${KF5${_module}_VERSION}) endif() endif() endforeach() # Annoyingly, find_package_handle_standard_args requires you to provide # REQUIRED_VARS even when using HANDLE_COMPONENTS, but all we actually # care about is whether the required components were found. So we provide # a dummy variable that is just set to something that will be printed # on success. set(_dummy_req_var "success") find_package_handle_standard_args(KF5 FOUND_VAR KF5_FOUND REQUIRED_VARS _dummy_req_var VERSION_VAR KF5_VERSION HANDLE_COMPONENTS ) # SPDX-FileCopyrightText: 2014 Alex Merry # SPDX-FileCopyrightText: 2013 Stephen Kelly # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindKF6 ------- Find KDE Frameworks 6 with a single find_package() call. This will use the package config files provided by the individual frameworks. For example, if you wish to find KArchive, which presents itself to CMake as KF6Archive (ie: you would do ``find_package(KF6Archive)`` to find it directly), you can do .. code-block:: cmake find_package(KF6 COMPONENTS Archive) If all the required components (those given in the COMPONENTS argument, but not those given in the OPTIONAL_COMPONENTS argument) are found, ``KF6_FOUND`` will be set to true. Otherwise, it will be set to false. Since 6.0.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(KF6) if (NOT KF6_FIND_COMPONENTS) set(KF6_NOT_FOUND_MESSAGE "The KF6 package requires at least one component") set(KF6_FOUND False) return() endif() set(_quiet_arg) if (KF6_FIND_QUIETLY) set(_quiet_arg QUIET) endif() set(_exact_arg) if (KF6_FIND_EXACT) set(_exact_arg EXACT) endif() include(FindPackageHandleStandardArgs) include(FeatureSummary) set(KF6_VERSION) set(KF6_MISSING_REQUIRED_COMPONENTS) foreach(_module ${KF6_FIND_COMPONENTS}) find_package(KF6${_module} ${KF6_FIND_VERSION} ${_exact_arg} ${_quiet_arg} CONFIG ) # CMake >= 3.17 wants to be explicitly told we are fine with name mismatch here set(_name_mismatched_arg) if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.17) set(_name_mismatched_arg NAME_MISMATCHED) endif() find_package_handle_standard_args(KF6${_module} CONFIG_MODE ${_name_mismatched_arg}) if (KF6_FIND_REQUIRED AND KF6_FIND_REQUIRED_${_module}) # If the component was required, we tell FeatureSummary so that it # will be displayed in the correct list. We do not use the REQUIRED # argument of find_package() to allow all the missing frameworks # to be listed at once (fphsa will error out at the end of this file # anyway). set_package_properties(KF6${_module} PROPERTIES TYPE REQUIRED) endif() # Component-based find modules are expected to set # __FOUND and __VERSION variables, # but the find_package calls above will have set KF6_* # variables. set(KF6_${_module}_FOUND ${KF6${_module}_FOUND}) if(KF6${_module}_FOUND) set(KF6_${_module}_VERSION ${KF6${_module}_VERSION}) # make KF6_VERSION the minimum found version if(NOT KF6_VERSION OR KF6_VERSION VERSION_GREATER KF6${_module}_VERSION) set(KF6_VERSION ${KF6${_module}_VERSION}) endif() elseif(KF6_FIND_REQUIRED_${_module}) list(APPEND KF6_MISSING_REQUIRED_COMPONENTS ${_module}) endif() endforeach() # Annoyingly, find_package_handle_standard_args requires you to provide # REQUIRED_VARS even when using HANDLE_COMPONENTS, but all we actually # care about is whether the required components were found. So we provide # a dummy variable that is just set to something that will be printed # on success. set(_dummy_req_var "success") list(JOIN KF6_MISSING_REQUIRED_COMPONENTS " " MISSING_COMPONENTS_STRING) find_package_handle_standard_args(KF6 FOUND_VAR KF6_FOUND REQUIRED_VARS _dummy_req_var VERSION_VAR KF6_VERSION HANDLE_COMPONENTS REASON_FAILURE_MESSAGE "Missing the following required components: ${MISSING_COMPONENTS_STRING}" ) unset(MISSING_COMPONENTS_STRING) unset(KF6_MISSING_REQUIRED_COMPONENTS) # SPDX-FileCopyrightText: 2018 Christophe Giboudeaux # SPDX-FileCopyrightText: 2010 Alexander Neundorf # SPDX-FileCopyrightText: 2008 Gilles Caulier # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindLibExiv2 ------------ Try to find the Exiv2 library. This will define the following variables: ``LibExiv2_FOUND`` True if (the requested version of) Exiv2 is available ``LibExiv2_VERSION`` The version of Exiv2 ``LibExiv2_INCLUDE_DIRS`` The include dirs of Exiv2 for use with target_include_directories() ``LibExiv2_LIBRARIES`` The Exiv2 library for use with target_link_libraries(). This can be passed to target_link_libraries() instead of the ``LibExiv2::LibExiv2`` target If ``LibExiv2_FOUND`` is TRUE, it will also define the following imported target: ``LibExiv2::LibExiv2`` The Exiv2 library In general we recommend using the imported target, as it is easier to use. Bear in mind, however, that if the target is in the link interface of an exported library, it must be made available by the package config file. Since 5.53.0. #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PC_EXIV2 QUIET exiv2) find_path(LibExiv2_INCLUDE_DIRS NAMES exiv2/exif.hpp HINTS ${PC_EXIV2_INCLUDEDIR} ) find_library(LibExiv2_LIBRARIES NAMES exiv2 libexiv2 HINTS ${PC_EXIV2_LIBRARY_DIRS} ) set(LibExiv2_VERSION ${PC_EXIV2_VERSION}) if(NOT LibExiv2_VERSION AND DEFINED LibExiv2_INCLUDE_DIRS) # With exiv >= 0.27, the version #defines are in exv_conf.h instead of version.hpp foreach(_exiv2_version_file "version.hpp" "exv_conf.h") if(EXISTS "${LibExiv2_INCLUDE_DIRS}/exiv2/${_exiv2_version_file}") file(READ "${LibExiv2_INCLUDE_DIRS}/exiv2/${_exiv2_version_file}" _exiv_version_file_content) string(REGEX MATCH "#define EXIV2_MAJOR_VERSION[ ]+\\([0-9]+U?\\)" EXIV2_MAJOR_VERSION_MATCH ${_exiv_version_file_content}) string(REGEX MATCH "#define EXIV2_MINOR_VERSION[ ]+\\([0-9]+U?\\)" EXIV2_MINOR_VERSION_MATCH ${_exiv_version_file_content}) string(REGEX MATCH "#define EXIV2_PATCH_VERSION[ ]+\\([0-9]+U?\\)" EXIV2_PATCH_VERSION_MATCH ${_exiv_version_file_content}) if(EXIV2_MAJOR_VERSION_MATCH) string(REGEX REPLACE ".*_MAJOR_VERSION[ ]+\\(([0-9]*)U?\\)" "\\1" EXIV2_MAJOR_VERSION ${EXIV2_MAJOR_VERSION_MATCH}) string(REGEX REPLACE ".*_MINOR_VERSION[ ]+\\(([0-9]*)U?\\)" "\\1" EXIV2_MINOR_VERSION ${EXIV2_MINOR_VERSION_MATCH}) string(REGEX REPLACE ".*_PATCH_VERSION[ ]+\\(([0-9]*)U?\\)" "\\1" EXIV2_PATCH_VERSION ${EXIV2_PATCH_VERSION_MATCH}) endif() endif() endforeach() set(LibExiv2_VERSION "${EXIV2_MAJOR_VERSION}.${EXIV2_MINOR_VERSION}.${EXIV2_PATCH_VERSION}") endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(LibExiv2 FOUND_VAR LibExiv2_FOUND REQUIRED_VARS LibExiv2_LIBRARIES LibExiv2_INCLUDE_DIRS VERSION_VAR LibExiv2_VERSION ) mark_as_advanced(LibExiv2_INCLUDE_DIRS LibExiv2_LIBRARIES) if(LibExiv2_FOUND AND NOT TARGET LibExiv2::LibExiv2) add_library(LibExiv2::LibExiv2 UNKNOWN IMPORTED) set_target_properties(LibExiv2::LibExiv2 PROPERTIES IMPORTED_LOCATION "${LibExiv2_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${LibExiv2_INCLUDE_DIRS}" ) if (LibExiv2_VERSION VERSION_LESS 0.28.0) # exiv2 0.27 or older still uses std::auto_ptr, which is no longer available # by default when using newer C++ versions set_target_properties(LibExiv2::LibExiv2 PROPERTIES INTERFACE_COMPILE_DEFINITIONS "_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR=1;_HAS_AUTO_PTR_ETC=1" ) endif() endif() include(FeatureSummary) set_package_properties(LibExiv2 PROPERTIES URL "https://www.exiv2.org" DESCRIPTION "Image metadata support" ) # SPDX-FileCopyrightText: 2014 Alex Merry # SPDX-FileCopyrightText: 2014 Martin Gräßlin # SPDX-FileCopyrightText: 2014 Christoph Cullmann # SPDX-FileCopyrightText: 2023 Louis Moureaux # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindLibGit2 ----------- Try to find libgit2 on a Unix system. This will define the following variables: ``LIBGIT2_FOUND`` True if (the requested version of) libgit2 is available ``LIBGIT2_VERSION`` The version of libgit2 ``LIBGIT2_LIBRARIES`` This can be passed to target_link_libraries() instead of the ``LibGit2::LibGit2`` target ``LIBGIT2_INCLUDE_DIRS`` This should be passed to target_include_directories() if the target is not used for linking ``LIBGIT2_DEFINITIONS`` This should be passed to target_compile_options() if the target is not used for linking If ``LIBGIT2_FOUND`` is TRUE, it will also define the following imported target: ``LibGit2::LibGit2`` The libgit2 library In general we recommend using the imported target, as it is easier to use. Bear in mind, however, that if the target is in the link interface of an exported library, it must be made available by the package config file. Since 1.3.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(LibGit2) # Use pkg-config to get the directories and then use these values # in the FIND_PATH() and FIND_LIBRARY() calls find_package(PkgConfig QUIET) pkg_check_modules(PKG_GIT2 QUIET libgit2) set(LIBGIT2_DEFINITIONS ${PKG_GIT2_CFLAGS_OTHER}) find_path(LIBGIT2_INCLUDE_DIR NAMES git2.h HINTS ${PKG_GIT2_INCLUDE_DIRS} ) find_library(LIBGIT2_LIBRARY NAMES git2 HINTS ${PKG_GIT2_LIBRARY_DIRS} ) # get version from header, should work on windows, too if(LIBGIT2_INCLUDE_DIR) file(STRINGS "${LIBGIT2_INCLUDE_DIR}/git2/version.h" LIBGIT2_H REGEX "^#define LIBGIT2_VERSION +\"[^\"]*\"$") string(REGEX REPLACE "^.*LIBGIT2_VERSION +\"([0-9]+).*$" "\\1" LIBGIT2_VERSION_MAJOR "${LIBGIT2_H}") string(REGEX REPLACE "^.*LIBGIT2_VERSION +\"[0-9]+\\.([0-9]+).*$" "\\1" LIBGIT2_VERSION_MINOR "${LIBGIT2_H}") string(REGEX REPLACE "^.*LIBGIT2_VERSION +\"[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" LIBGIT2_VERSION_PATCH "${LIBGIT2_H}") set(LIBGIT2_VERSION "${LIBGIT2_VERSION_MAJOR}.${LIBGIT2_VERSION_MINOR}.${LIBGIT2_VERSION_PATCH}") set(LIBGIT2_MAJOR_VERSION "${LIBGIT2_VERSION_MAJOR}") set(LIBGIT2_MINOR_VERSION "${LIBGIT2_VERSION_MINOR}") set(LIBGIT2_PATCH_VERSION "${LIBGIT2_VERSION_PATCH}") unset(LIBGIT2_H) endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(LibGit2 FOUND_VAR LIBGIT2_FOUND REQUIRED_VARS LIBGIT2_LIBRARY LIBGIT2_INCLUDE_DIR VERSION_VAR LIBGIT2_VERSION ) if(LIBGIT2_FOUND AND NOT TARGET LibGit2::LibGit2) add_library(LibGit2::LibGit2 UNKNOWN IMPORTED) set_target_properties(LibGit2::LibGit2 PROPERTIES IMPORTED_LOCATION "${LIBGIT2_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${LIBGIT2_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${LIBGIT2_INCLUDE_DIR}" ) endif() mark_as_advanced(LIBGIT2_LIBRARY LIBGIT2_INCLUDE_DIR) set(LIBGIT2_LIBRARIES ${LIBGIT2_LIBRARY}) set(LIBGIT2_INCLUDE_DIRS ${LIBGIT2_INCLUDE_DIR}) include(FeatureSummary) set_package_properties(LibGit2 PROPERTIES URL "https://libgit2.github.com/" DESCRIPTION "A plain C library to interface with the git version control system." ) # SPDX-FileCopyrightText: 2021 Ahmad Samir # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindLibMount ------------ Try to find the libmount library (part of util-linux), once done this will define: ``LibMount_FOUND`` LibMount was found on the system. ``LibMount_INCLUDE_DIRS`` The libmount include directory. ``LibMount_LIBRARIES`` The libmount libraries. ``LibMount_VERSION`` The libmount version. If ``LibMount_FOUND`` is TRUE, it will also define the following imported target: ``LibMount::LibMount`` The libmount library Since 5.83.0 #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PC_LIBMOUNT QUIET IMPORTED_TARGET mount) find_path(LibMount_INCLUDE_DIRS NAMES libmount.h PATH_SUFFIXES libmount HINTS ${PC_LIBMOUNT_INCLUDE_DIRS}) find_library(LibMount_LIBRARIES NAMES mount HINTS ${PC_LIBMOUNT_LIBRARY_DIRS}) set(LibMount_VERSION ${PC_LIBMOUNT_VERSION}) if(LibMount_INCLUDE_DIRS AND NOT LibMount_VERSION) file(READ "${LibMount_INCLUDE_DIRS}/libmount.h" _LibMount_header_contents) string(REGEX MATCHALL "#define[ \t]+LIBMOUNT_VERSION[ \t]+\"*[0-9.]+" _LibMount_version_line "${_LibMount_header_contents}") unset(_LibMount_header_contents) string(REGEX REPLACE ".*LIBMOUNT_VERSION[ \t]+\"*([0-9.]+)\"*" "\\1" _version "${_LibMount_version_line}") set(LibMount_VERSION "${_version}") unset(_LibMount_version_line) endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(LibMount FOUND_VAR LibMount_FOUND REQUIRED_VARS LibMount_INCLUDE_DIRS LibMount_LIBRARIES VERSION_VAR LibMount_VERSION ) mark_as_advanced(LibMount_INCLUDE_DIRS LibMount_LIBRARIES) if(LibMount_FOUND AND NOT TARGET LibMount::LibMount) add_library(LibMount::LibMount UNKNOWN IMPORTED) set_target_properties(LibMount::LibMount PROPERTIES IMPORTED_LOCATION "${LibMount_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${LibMount_INCLUDE_DIRS}" INTERFACE_COMPILE_DEFINITIONS "${PC_LIBMOUNT_CFLAGS_OTHER}" ) if (TARGET PkgConfig::PC_LIBMOUNT) target_link_libraries(LibMount::LibMount INTERFACE PkgConfig::PC_LIBMOUNT) endif() endif() include(FeatureSummary) set_package_properties(LibMount PROPERTIES DESCRIPTION "API for getting info about mounted filesystems (part of util-linux)" URL "https://www.kernel.org/pub/linux/utils/util-linux/" ) # SPDX-FileCopyrightText: 2014 Hrvoje Senjan # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindLibcap ---------- Try to find the setcap binary and cap libraries This will define: ``Libcap_FOUND`` system has the cap library and setcap binary ``Libcap_LIBRARIES`` cap libraries to link against ``SETCAP_EXECUTABLE`` path of the setcap binary In addition, the following targets are defined: ``Libcap::SetCapabilities`` Since 5.80.0 #]=======================================================================] find_program(SETCAP_EXECUTABLE NAMES setcap DOC "The setcap executable") find_library(Libcap_LIBRARIES NAMES cap DOC "The cap (capabilities) library") include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Libcap FOUND_VAR Libcap_FOUND REQUIRED_VARS SETCAP_EXECUTABLE Libcap_LIBRARIES) if(Libcap_FOUND AND NOT TARGET Libcap::SetCapabilities) add_executable(Libcap::SetCapabilities IMPORTED) set_target_properties(Libcap::SetCapabilities PROPERTIES IMPORTED_LOCATION "${SETCAP_EXECUTABLE}" ) endif() mark_as_advanced(SETCAP_EXECUTABLE Libcap_LIBRARIES) include(FeatureSummary) set_package_properties(Libcap PROPERTIES URL https://sites.google.com/site/fullycapable/ DESCRIPTION "Capabilities are a measure to limit the omnipotence of the superuser.") # SPDX-FileCopyrightText: 2013-2014 Alex Merry # SPDX-FileCopyrightText: 2006 Alexander Neundorf # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindOpenEXR ----------- Try to find the OpenEXR libraries. This will define the following variables: ``OpenEXR_FOUND`` True if OpenEXR is available ``OpenEXR_LIBRARIES`` Link to these to use OpenEXR ``OpenEXR_INCLUDE_DIRS`` Include directory for OpenEXR ``OpenEXR_DEFINITIONS`` Compiler flags required to link against OpenEXR and the following imported targets: ``OpenEXR::IlmImf`` The OpenEXR core library In general we recommend using the imported target, as it is easier to use. Bear in mind, however, that if the target is in the link interface of an exported library, it must be made available by the package config file. Since pre-1.0.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(OpenEXR) # use pkg-config to get the directories and then use these values # in the FIND_PATH() and FIND_LIBRARY() calls find_package(PkgConfig QUIET) pkg_check_modules(PC_OpenEXR QUIET OpenEXR) set(OpenEXR_DEFINITIONS ${PC_OpenEXR_CFLAGS_OTHER}) find_path(OpenEXR_INCLUDE_DIR ImfRgbaFile.h PATHS ${PC_OpenEXR_INCLUDEDIR} ${PC_OpenEXR_INCLUDE_DIRS} PATH_SUFFIXES OpenEXR ) # Required libraries for OpenEXR find_library(OpenEXR_HALF_LIBRARY NAMES Half PATHS ${PC_OpenEXR_LIBDIR} ${PC_OpenEXR_LIBRARY_DIRS} ) find_library(OpenEXR_IEX_LIBRARY NAMES Iex PATHS ${PC_OpenEXR_LIBDIR} ${PC_OpenEXR_LIBRARY_DIRS} ) find_library(OpenEXR_IMATH_LIBRARY NAMES Imath PATHS ${PC_OpenEXR_LIBDIR} ${PC_OpenEXR_LIBRARY_DIRS} ) find_library(OpenEXR_ILMTHREAD_LIBRARY NAMES IlmThread PATHS ${PC_OpenEXR_LIBDIR} ${PC_OpenEXR_LIBRARY_DIRS} ) # This is the actual OpenEXR library find_library(OpenEXR_ILMIMF_LIBRARY NAMES IlmImf PATHS ${PC_OpenEXR_LIBDIR} ${PC_OpenEXR_LIBRARY_DIRS} ) set(_OpenEXR_deps ${OpenEXR_HALF_LIBRARY} ${OpenEXR_IEX_LIBRARY} ${OpenEXR_IMATH_LIBRARY} ${OpenEXR_ILMTHREAD_LIBRARY}) set(OpenEXR_LIBRARIES ${_OpenEXR_deps} ${OpenEXR_ILMIMF_LIBRARY}) if (OpenEXR_INCLUDE_DIR AND EXISTS "${OpenEXR_INCLUDE_DIR}/OpenEXRConfig.h") file(STRINGS "${OpenEXR_INCLUDE_DIR}/OpenEXRConfig.h" openexr_version_str REGEX "^#define[\t ]+OPENEXR_VERSION_STRING[\t ]+\"[^\"]*\"") string(REGEX REPLACE "^#define[\t ]+OPENEXR_VERSION_STRING[\t ]+\"([^\"]*).*" "\\1" OpenEXR_VERSION_STRING "${openexr_version_str}") unset(openexr_version_str) endif () include(FindPackageHandleStandardArgs) # find_package_handle_standard_args reports the value of the first variable # on success, so make sure this is the actual OpenEXR library find_package_handle_standard_args(OpenEXR FOUND_VAR OpenEXR_FOUND REQUIRED_VARS OpenEXR_ILMIMF_LIBRARY OpenEXR_HALF_LIBRARY OpenEXR_IEX_LIBRARY OpenEXR_IMATH_LIBRARY OpenEXR_ILMTHREAD_LIBRARY OpenEXR_INCLUDE_DIR VERSION_VAR OpenEXR_VERSION_STRING) set(OpenEXR_INCLUDE_DIRS ${OpenEXR_INCLUDE_DIR}) include(FeatureSummary) set_package_properties(OpenEXR PROPERTIES URL https://www.openexr.com/ DESCRIPTION "A library for handling OpenEXR high dynamic-range image files") mark_as_advanced( OpenEXR_INCLUDE_DIR OpenEXR_LIBRARIES OpenEXR_DEFINITIONS OpenEXR_ILMIMF_LIBRARY OpenEXR_ILMTHREAD_LIBRARY OpenEXR_IMATH_LIBRARY OpenEXR_IEX_LIBRARY OpenEXR_HALF_LIBRARY ) if(OpenEXR_FOUND AND NOT TARGET OpenEXR::IlmImf) add_library(OpenEXR::IlmImf UNKNOWN IMPORTED) set_target_properties(OpenEXR::IlmImf PROPERTIES IMPORTED_LOCATION "${OpenEXR_ILMIMF_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${OpenEXR_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${OpenEXR_INCLUDE_DIR}" INTERFACE_LINK_LIBRARIES "${_OpenEXR_deps}" ) endif() # SPDX-FileCopyrightText: 2017 Klaralvdalens Datakonsult AB, a KDAB Group company # SPDX-FileCopyrightText: 2018 Volker Krause # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindPhoneNumber --------------- Try to find PhoneNumber. This is a component-based find module, which makes use of the COMPONENTS and OPTIONAL_COMPONENTS arguments to find_module. The following components are available:: PhoneNumber GeoCoding If no components are specified, this module will act as though all components were passed to OPTIONAL_COMPONENTS. This module will define the following variables, independently of the components searched for or found: ``PhoneNumber_FOUND`` True if (the requestion version of) PhoneNumber is available For each searched-for components, ``PhoneNumber__FOUND`` will be set to TRUE if the corresponding library was found, and FALSE otherwise. If ``PhoneNumber__FOUND`` is TRUE, the imported target ``PhoneNumber::`` will be defined. Since 5.54.0. #]=======================================================================] include(ECMFindModuleHelpersStub) ecm_find_package_version_check(PhoneNumber) set(PhoneNumber_known_components PhoneNumber GeoCoding ) set(PhoneNumber_default_components ${PhoneNumber_known_components}) set(PhoneNumber_PhoneNumber_lib phonenumber) set(PhoneNumber_PhoneNumber_header phonenumbers/phonenumberutil.h) set(PhoneNumber_GeoCoding_lib geocoding) set(PhoneNumber_GeoCoding_header phonenumbers/geocoding/phonenumber_offline_geocoder.h) ecm_find_package_parse_components(PhoneNumber RESULT_VAR PhoneNumber_components KNOWN_COMPONENTS ${PhoneNumber_known_components} DEFAULT_COMPONENTS ${PhoneNumber_default_components} ) ecm_find_package_handle_library_components(PhoneNumber COMPONENTS ${PhoneNumber_components} ) find_package_handle_standard_args(PhoneNumber FOUND_VAR PhoneNumber_FOUND REQUIRED_VARS PhoneNumber_LIBRARIES VERSION_VAR PhoneNumber_VERSION HANDLE_COMPONENTS ) set(PhoneNumber_VERSION 0) # there is no observable version number in the installed files include(FeatureSummary) set_package_properties(PhoneNumber PROPERTIES URL "https://github.com/googlei18n/libphonenumber" DESCRIPTION "Library for parsing, formatting, and validating international phone numbers") # SPDX-FileCopyrightText: 2015 Alex Richardson # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindPoppler ----------- Try to find Poppler. This is a component-based find module, which makes use of the COMPONENTS and OPTIONAL_COMPONENTS arguments to find_module. The following components are available:: Core Cpp Qt5 Qt4 Glib If no components are specified, this module will act as though all components were passed to OPTIONAL_COMPONENTS. This module will define the following variables, independently of the components searched for or found: ``Poppler_FOUND`` TRUE if (the requested version of) Poppler is available ``Poppler_VERSION`` Found Poppler version ``Poppler_TARGETS`` A list of all targets imported by this module (note that there may be more than the components that were requested) ``Poppler_LIBRARIES`` This can be passed to target_link_libraries() instead of the imported targets ``Poppler_INCLUDE_DIRS`` This should be passed to target_include_directories() if the targets are not used for linking ``Poppler_DEFINITIONS`` This should be passed to target_compile_options() if the targets are not used for linking For each searched-for components, ``Poppler__FOUND`` will be set to TRUE if the corresponding Poppler library was found, and FALSE otherwise. If ``Poppler__FOUND`` is TRUE, the imported target ``Poppler::`` will be defined. This module will also attempt to determine ``Poppler_*_VERSION`` variables for each imported target, although ``Poppler_VERSION`` should normally be sufficient. In general we recommend using the imported targets, as they are easier to use and provide more control. Bear in mind, however, that if any target is in the link interface of an exported library, it must be made available by the package config file. Since 5.19 #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(Poppler) set(Poppler_known_components Cpp Qt4 Qt5 Qt6 Glib ) foreach(_comp ${Poppler_known_components}) string(TOLOWER "${_comp}" _lc_comp) set(Poppler_${_comp}_component_deps "Core") set(Poppler_${_comp}_pkg_config "poppler-${_lc_comp}") set(Poppler_${_comp}_lib "poppler-${_lc_comp}") set(Poppler_${_comp}_header_subdir "poppler/${_lc_comp}") endforeach() set(Poppler_known_components Core ${Poppler_known_components}) set(Poppler_Core_component_deps "") set(Poppler_Core_pkg_config "poppler") # poppler-config.h header is only installed with --enable-xpdf-headers # fall back to using any header from a submodule with a path to make it work in that case too set(Poppler_Core_header "poppler-config.h" "cpp/poppler-version.h" "qt6/poppler-qt6.h" "qt5/poppler-qt5.h" "qt4/poppler-qt4.h" "glib/poppler.h") set(Poppler_Core_header_subdir "poppler") set(Poppler_Core_lib "poppler") set(Poppler_Cpp_header "poppler-version.h") set(Poppler_Qt6_header "poppler-qt6.h") set(Poppler_Qt5_header "poppler-qt5.h") set(Poppler_Qt4_header "poppler-qt4.h") set(Poppler_Glib_header "poppler.h") ecm_find_package_parse_components(Poppler RESULT_VAR Poppler_components KNOWN_COMPONENTS ${Poppler_known_components} ) ecm_find_package_handle_library_components(Poppler COMPONENTS ${Poppler_components} ) # If pkg-config didn't provide us with version information, # try to extract it from poppler-version.h or poppler-config.h if(NOT Poppler_VERSION) find_file(Poppler_VERSION_HEADER NAMES "poppler-config.h" "cpp/poppler-version.h" HINTS ${Poppler_INCLUDE_DIRS} PATH_SUFFIXES ${Poppler_Core_header_subdir} ) mark_as_advanced(Poppler_VERSION_HEADER) if(Poppler_VERSION_HEADER) file(READ ${Poppler_VERSION_HEADER} _poppler_version_header_contents) string(REGEX REPLACE "^.*[ \t]+POPPLER_VERSION[ \t]+\"([0-9d.]*)\".*$" "\\1" Poppler_VERSION "${_poppler_version_header_contents}" ) unset(_poppler_version_header_contents) endif() endif() find_package_handle_standard_args(Poppler FOUND_VAR Poppler_FOUND REQUIRED_VARS Poppler_LIBRARIES VERSION_VAR Poppler_VERSION HANDLE_COMPONENTS ) include(FeatureSummary) set_package_properties(Poppler PROPERTIES DESCRIPTION "A PDF rendering library" URL "https://poppler.freedesktop.org/" ) # SPDX-FileCopyrightText: 2008 Matthias Kretz # SPDX-FileCopyrightText: 2009 Marcus Hufgard # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindPulseAudio -------------- Try to locate the PulseAudio library. If found, this will define the following variables: ``PulseAudio_FOUND`` True if the system has the PulseAudio library of at least the minimum version specified by either the version parameter to find_package() or the variable PulseAudio_MINIMUM_VERSION ``PulseAudio_INCLUDE_DIRS`` The PulseAudio include directory ``PulseAudio_LIBRARIES`` The PulseAudio libraries for linking ``PulseAudio_MAINLOOP_LIBRARY`` The libraries needed to use PulseAudio Mainloop ``PulseAudio_VERSION`` The version of PulseAudio that was found ``PulseAudio_INCLUDE_DIR`` Deprecated, use ``PulseAudio_INCLUDE_DIRS`` ``PulseAudio_LIBRARY`` Deprecated, use ``PulseAudio_LIBRARIES`` If ``PulseAudio_FOUND`` is TRUE, it will also define the following imported target: ``PulseAudio::PulseAudio`` The PulseAudio library Since 5.41.0. #]=======================================================================] # Support PulseAudio_MINIMUM_VERSION for compatibility: if(NOT PulseAudio_FIND_VERSION) set(PulseAudio_FIND_VERSION "${PulseAudio_MINIMUM_VERSION}") endif() # the minimum version of PulseAudio we require if(NOT PulseAudio_FIND_VERSION) set(PulseAudio_FIND_VERSION "0.9.9") endif() find_package(PkgConfig QUIET) pkg_check_modules(PC_PulseAudio QUIET libpulse>=${PulseAudio_FIND_VERSION}) pkg_check_modules(PC_PulseAudio_MAINLOOP QUIET libpulse-mainloop-glib) find_path(PulseAudio_INCLUDE_DIRS pulse/pulseaudio.h HINTS ${PC_PulseAudio_INCLUDEDIR} ${PC_PulseAudio_INCLUDE_DIRS} ) find_library(PulseAudio_LIBRARIES NAMES pulse libpulse HINTS ${PC_PulseAudio_LIBDIR} ${PC_PulseAudio_LIBRARY_DIRS} ) find_library(PulseAudio_MAINLOOP_LIBRARY NAMES pulse-mainloop pulse-mainloop-glib libpulse-mainloop-glib HINTS ${PC_PulseAudio_LIBDIR} ${PC_PulseAudio_LIBRARY_DIRS} ) # Store the version number in the cache, so we don't have to search every time again: if (PulseAudio_INCLUDE_DIRS AND NOT PulseAudio_VERSION) # get PulseAudio's version from its version.h file(STRINGS "${PulseAudio_INCLUDE_DIRS}/pulse/version.h" pulse_version_h REGEX ".*pa_get_headers_version\\(\\).*") string(REGEX REPLACE ".*pa_get_headers_version\\(\\)\ \\(\"([0-9]+\\.[0-9]+\\.[0-9]+)[^\"]*\"\\).*" "\\1" _PulseAudio_VERSION "${pulse_version_h}") set(PulseAudio_VERSION "${_PulseAudio_VERSION}" CACHE STRING "Version number of PulseAudio" FORCE) endif() # Use the new extended syntax of find_package_handle_standard_args(), which also handles version checking: include(FindPackageHandleStandardArgs) find_package_handle_standard_args(PulseAudio REQUIRED_VARS PulseAudio_LIBRARIES PulseAudio_INCLUDE_DIRS VERSION_VAR PulseAudio_VERSION) # Deprecated synonyms set(PULSEAUDIO_INCLUDE_DIR "${PulseAudio_INCLUDE_DIRS}") set(PULSEAUDIO_LIBRARY "${PulseAudio_LIBRARIES}") set(PULSEAUDIO_MAINLOOP_LIBRARY "${PulseAudio_MAINLOOP_LIBRARY}") set(PULSEAUDIO_FOUND "${PulseAudio_FOUND}") if(PulseAudio_FOUND AND NOT TARGET PulseAudio::PulseAudio) add_library(PulseAudio::PulseAudio UNKNOWN IMPORTED) set_target_properties(PulseAudio::PulseAudio PROPERTIES IMPORTED_LOCATION "${PulseAudio_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${PulseAudio_INCLUDE_DIRS}") endif() mark_as_advanced(PulseAudio_INCLUDE_DIRS PULSEAUDIO_INCLUDE_DIR PulseAudio_LIBRARIES PULSEAUDIO_LIBRARY PulseAudio_MAINLOOP_LIBRARY PULSEAUDIO_MAINLOOP_LIBRARY) include(FeatureSummary) set_package_properties(PulseAudio PROPERTIES URL "https://www.freedesktop.org/wiki/Software/PulseAudio" DESCRIPTION "Sound server, for sound stream routing and mixing") # SPDX-FileCopyrightText: 2016 Friedrich W. H. Kossebau # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: WARNING: FOR ECM-INTERNAL USE ONLY, DO NOT USE IN OWN PROJECTS THIS FILE MIGHT DISAPPEAR IN FUTURE VERSIONS OF ECM. Finds the Qt5 QHelpGenerator QHelpGenerator_FOUND - True if QHelpGenerator found. QHelpGenerator_EXECUTABLE - Path to executable #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/../modules/QtVersionOption.cmake) find_package(Qt${QT_MAJOR_VERSION}Help QUIET) if (TARGET Qt5::qhelpgenerator) get_target_property(QHelpGenerator_EXECUTABLE Qt5::qhelpgenerator LOCATION) else() # assume same folder as qmake executable if (TARGET Qt5::qmake) get_target_property(_qmake_EXECUTABLE Qt5::qmake LOCATION) get_filename_component(_path ${_qmake_EXECUTABLE} DIRECTORY) else() set(_path) endif() find_program(QHelpGenerator_EXECUTABLE NAMES qhelpgenerator-qt5 qhelpgenerator PATHS ${_path} NO_DEFAULT_PATH ) endif() mark_as_advanced(QHelpGenerator_EXECUTABLE) if(QHelpGenerator_EXECUTABLE) set(QHelpGenerator_FOUND TRUE) else() set(QHelpGenerator_FOUND FALSE) endif() if(QHelpGenerator_FOUND) if(NOT QHelpGenerator_FIND_QUIETLY ) message( STATUS "Found QHelpGenerator executable: ${QHelpGenerator_EXECUTABLE}") endif() else() if(QHelpGenerator_FIND_REQUIRED) message( FATAL_ERROR "Could not find QHelpGenerator executable" ) else() message( STATUS "Optional QHelpGenerator executable was not found" ) endif() endif() # SPDX-FileCopyrightText: 2012-2014 Pier Luigi Fiorini # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindQtWaylandScanner -------------------- Try to find qtwaylandscanner. If the qtwaylandscanner executable is not in your PATH, you can provide an alternative name or full path location with the ``QtWaylandScanner_EXECUTABLE`` variable. This will define the following variables: ``QtWaylandScanner_FOUND`` True if qtwaylandscanner is available ``QtWaylandScanner_EXECUTABLE`` The qtwaylandscanner executable. If ``QtWaylandScanner_FOUND`` is TRUE, it will also define the following imported target: ``Wayland::QtScanner`` The qtwaylandscanner executable. This module provides the following functions to generate C++ protocol implementations: - ``ecm_add_qtwayland_client_protocol`` - ``ecm_add_qtwayland_server_protocol`` :: ecm_add_qtwayland_client_protocol( PROTOCOL BASENAME [PREFIX ] [PRIVATE_CODE]) ecm_add_qtwayland_client_protocol( PROTOCOL BASENAME [PREFIX ] [PRIVATE_CODE]) Generate C++ wrapper to Wayland client protocol files from ```` XML definition for the ```` interface and append those files to ```` or ````. Pass the ```` argument if the interface names don't start with ``qt_`` or ``wl_``. ``PRIVATE_CODE`` instructs wayland-scanner to hide marshalling code from the compiled DSO for use in other DSOs. The default is to export this code. WaylandScanner is required and will be searched for. :: ecm_add_qtwayland_server_protocol( PROTOCOL BASENAME [PREFIX ] [PRIVATE_CODE]) ecm_add_qtwayland_server_protocol( PROTOCOL BASENAME [PREFIX ] [PRIVATE_CODE]) Generate C++ wrapper to Wayland server protocol files from ```` XML definition for the ```` interface and append those files to ```` or ````. Pass the ```` argument if the interface names don't start with ``qt_`` or ``wl_``. ``PRIVATE_CODE`` instructs wayland-scanner to hide marshalling code from the compiled DSO for use in other DSOs. The default is to export this code. WaylandScanner is required and will be searched for. Since 1.4.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) include("${ECM_MODULE_DIR}/ECMQueryQt.cmake") ecm_find_package_version_check(QtWaylandScanner) if (QT_MAJOR_VERSION STREQUAL "5") ecm_query_qt(qtwaylandscanner_dir QT_HOST_BINS) else() ecm_query_qt(qtwaylandscanner_dir QT_HOST_LIBEXECS) endif() # Find qtwaylandscanner find_program(QtWaylandScanner_EXECUTABLE NAMES qtwaylandscanner HINTS ${qtwaylandscanner_dir}) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(QtWaylandScanner FOUND_VAR QtWaylandScanner_FOUND REQUIRED_VARS QtWaylandScanner_EXECUTABLE ) mark_as_advanced(QtWaylandScanner_EXECUTABLE) if(NOT TARGET Wayland::QtScanner AND QtWaylandScanner_FOUND) add_executable(Wayland::QtScanner IMPORTED) set_target_properties(Wayland::QtScanner PROPERTIES IMPORTED_LOCATION "${QtWaylandScanner_EXECUTABLE}" ) endif() include(FeatureSummary) set_package_properties(QtWaylandScanner PROPERTIES URL "https://qt.io/" DESCRIPTION "Executable that converts XML protocol files to C++ code" ) function(ecm_add_qtwayland_client_protocol target_or_sources_var) # Parse arguments set(oneValueArgs PROTOCOL BASENAME PREFIX) set(options PRIVATE_CODE) cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "" ${ARGN}) if(ARGS_UNPARSED_ARGUMENTS) message(FATAL_ERROR "Unknown keywords given to ecm_add_qtwayland_client_protocol(): \"${ARGS_UNPARSED_ARGUMENTS}\"") endif() set(_prefix "${ARGS_PREFIX}") if(ARGS_PRIVATE_CODE) set(_private_code_option PRIVATE_CODE) endif() find_package(WaylandScanner REQUIRED QUIET) ecm_add_wayland_client_protocol(${target_or_sources_var} PROTOCOL ${ARGS_PROTOCOL} BASENAME ${ARGS_BASENAME} ${_private_code_option}) get_filename_component(_infile ${ARGS_PROTOCOL} ABSOLUTE) set(_header "${CMAKE_CURRENT_BINARY_DIR}/qwayland-${ARGS_BASENAME}.h") set(_code "${CMAKE_CURRENT_BINARY_DIR}/qwayland-${ARGS_BASENAME}.cpp") set_source_files_properties(${_header} ${_code} GENERATED) add_custom_command(OUTPUT "${_header}" COMMAND ${QtWaylandScanner_EXECUTABLE} client-header ${_infile} "" ${_prefix} > ${_header} DEPENDS ${_infile} ${_cheader} VERBATIM) add_custom_command(OUTPUT "${_code}" COMMAND ${QtWaylandScanner_EXECUTABLE} client-code ${_infile} "" ${_prefix} > ${_code} DEPENDS ${_infile} ${_header} VERBATIM) set_property(SOURCE ${_header} ${_code} PROPERTY SKIP_AUTOMOC ON) if (TARGET ${target_or_sources_var}) target_sources(${target_or_sources_var} PRIVATE "${_code}") else() list(APPEND ${target_or_sources_var} "${_code}") set(${target_or_sources_var} ${${target_or_sources_var}} PARENT_SCOPE) endif() endfunction() function(ecm_add_qtwayland_server_protocol target_or_sources_var) # Parse arguments set(oneValueArgs PROTOCOL BASENAME PREFIX) set(options PRIVATE_CODE) cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "" ${ARGN}) if(ARGS_UNPARSED_ARGUMENTS) message(FATAL_ERROR "Unknown keywords given to ecm_add_qtwayland_server_protocol(): \"${ARGS_UNPARSED_ARGUMENTS}\"") endif() set(_prefix "${ARGS_PREFIX}") if(ARGS_PRIVATE_CODE) set(_private_code_option PRIVATE_CODE) endif() find_package(WaylandScanner REQUIRED QUIET) ecm_add_wayland_server_protocol(${target_or_sources_var} PROTOCOL ${ARGS_PROTOCOL} BASENAME ${ARGS_BASENAME} ${_private_code_option}) get_filename_component(_infile ${ARGS_PROTOCOL} ABSOLUTE) set(_header "${CMAKE_CURRENT_BINARY_DIR}/qwayland-server-${ARGS_BASENAME}.h") set(_code "${CMAKE_CURRENT_BINARY_DIR}/qwayland-server-${ARGS_BASENAME}.cpp") set_source_files_properties(${_header} ${_code} GENERATED) add_custom_command(OUTPUT "${_header}" COMMAND ${QtWaylandScanner_EXECUTABLE} server-header ${_infile} "" ${_prefix} > ${_header} DEPENDS ${_infile} VERBATIM) add_custom_command(OUTPUT "${_code}" COMMAND ${QtWaylandScanner_EXECUTABLE} server-code ${_infile} "" ${_prefix} > ${_code} DEPENDS ${_infile} ${_header} VERBATIM) set_property(SOURCE ${_header} ${_code} PROPERTY SKIP_AUTOMOC ON) if (TARGET ${target_or_sources_var}) target_sources(${target_or_sources_var} PRIVATE "${_code}") else() list(APPEND ${target_or_sources_var} "${_code}") set(${target_or_sources_var} ${${target_or_sources_var}} PARENT_SCOPE) endif() endfunction() # SPDX-FileCopyrightText: 2020 Andreas Cord-Landwehr # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: WARNING: FOR ECM-INTERNAL USE ONLY, DO NOT USE IN OWN PROJECTS THIS FILE MIGHT DISAPPEAR IN FUTURE VERSIONS OF ECM. Finds the REUSE Tool by FSFE: https://github.com/fsfe/reuse-tool REUSETOOL_FOUND - True if REUSE tool is found. REUSETOOL_EXECUTABLE - Path to executable #]=======================================================================] find_program(REUSETOOL_EXECUTABLE NAMES reuse) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(ReuseTool FOUND_VAR REUSETOOL_FOUND REQUIRED_VARS REUSETOOL_EXECUTABLE ) # SPDX-FileCopyrightText: 2006, 2007 Laurent Montel # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindSasl2 --------- Try to find the SASL2 library. This will define the following variables: ``Sasl2_FOUND`` System has SASL2. ``Sasl2_VERSION`` The version of SASL2. ``Sasl2_INCLUDE_DIRS`` This should be passed to target_include_directories() if the target is not used for linking. ``Sasl2_LIBRARIES`` The SASL2 library. This can be passed to target_link_libraries() instead of the ``Sasl2::Sasl2`` target If ``Sasl2_FOUND`` is TRUE, the following imported target will be available: ``Sasl2::Sasl2`` The SASL2 library Since 5.41.0. #]=======================================================================] # NOTE: libsasl2.pc doesn't export the include dir. find_package(PkgConfig QUIET) pkg_check_modules(PC_Sasl2 libsasl2) find_path(Sasl2_INCLUDE_DIRS NAMES sasl/sasl.h) # libsasl2 add for windows, because the windows package of cyrus-sasl2 # contains a libsasl2 also for msvc which is not standard conform find_library(Sasl2_LIBRARIES NAMES sasl2 libsasl2 HINTS ${PC_Sasl2_LIBRARY_DIRS} ) set(Sasl2_VERSION "${PC_Sasl2_VERSION}") if(NOT Sasl2_VERSION) if(EXISTS "${Sasl2_INCLUDE_DIRS}/sasl/sasl.h") file(READ "${Sasl2_INCLUDE_DIRS}/sasl/sasl.h" SASL2_H_CONTENT) string(REGEX MATCH "#define SASL_VERSION_MAJOR[ ]+[0-9]+" SASL2_VERSION_MAJOR_MATCH ${SASL2_H_CONTENT}) string(REGEX MATCH "#define SASL_VERSION_MINOR[ ]+[0-9]+" SASL2_VERSION_MINOR_MATCH ${SASL2_H_CONTENT}) string(REGEX MATCH "#define SASL_VERSION_STEP[ ]+[0-9]+" SASL2_VERSION_STEP_MATCH ${SASL2_H_CONTENT}) string(REGEX REPLACE ".*_MAJOR[ ]+(.*)" "\\1" SASL2_VERSION_MAJOR ${SASL2_VERSION_MAJOR_MATCH}) string(REGEX REPLACE ".*_MINOR[ ]+(.*)" "\\1" SASL2_VERSION_MINOR ${SASL2_VERSION_MINOR_MATCH}) string(REGEX REPLACE ".*_STEP[ ]+(.*)" "\\1" SASL2_VERSION_STEP ${SASL2_VERSION_STEP_MATCH}) set(Sasl2_VERSION "${SASL2_VERSION_MAJOR}.${SASL2_VERSION_MINOR}.${SASL2_VERSION_STEP}") else() # Could not find the version set(Sasl2_VERSION "0.0.0") endif() endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Sasl2 FOUND_VAR Sasl2_FOUND REQUIRED_VARS Sasl2_LIBRARIES Sasl2_INCLUDE_DIRS VERSION_VAR Sasl2_VERSION ) if(Sasl2_FOUND AND NOT TARGET Sasl2::Sasl2) add_library(Sasl2::Sasl2 UNKNOWN IMPORTED) set_target_properties(Sasl2::Sasl2 PROPERTIES IMPORTED_LOCATION "${Sasl2_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${Sasl2_INCLUDE_DIRS}") endif() mark_as_advanced(Sasl2_LIBRARIES Sasl2_INCLUDE_DIRS Sasl2_VERSION) include(FeatureSummary) set_package_properties(Sasl2 PROPERTIES URL "https://www.cyrusimap.org/sasl/" DESCRIPTION "The Cyrus-sasl library." ) # SPDX-FileCopyrightText: 2017 Martin Flöser # SPDX-FileCopyrightText: 2017 David Kahles # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindSeccomp ----------- Try to locate the libseccomp library. This will define the following variables: ``Seccomp_FOUND`` True if the seccomp library is available ``Seccomp_INCLUDE_DIRS`` The seccomp include directories ``Seccomp_LIBRARIES`` The seccomp libraries for linking If ``Seccomp_FOUND`` is TRUE, it will also define the following imported target: ``Seccomp::Seccomp`` The Seccomp library Since 5.44.0. #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PKG_Libseccomp QUIET libseccomp) find_path(Seccomp_INCLUDE_DIRS NAMES seccomp.h HINTS ${PKG_Libseccomp_INCLUDE_DIRS} ) find_library(Seccomp_LIBRARIES NAMES seccomp HINTS ${PKG_Libseccomp_LIBRARY_DIRS} ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Seccomp FOUND_VAR Seccomp_FOUND REQUIRED_VARS Seccomp_LIBRARIES Seccomp_INCLUDE_DIRS ) if (Seccomp_FOUND AND NOT TARGET Seccomp::Seccomp) add_library(Seccomp::Seccomp UNKNOWN IMPORTED) set_target_properties(Seccomp::Seccomp PROPERTIES IMPORTED_LOCATION "${Seccomp_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${Seccomp_INCLUDE_DIRS}" ) endif() mark_as_advanced(Seccomp_LIBRARIES Seccomp_INCLUDE_DIRS) include(FeatureSummary) set_package_properties(Seccomp PROPERTIES URL "https://github.com/seccomp/libseccomp" DESCRIPTION "The enhanced seccomp library." ) # SPDX-FileCopyrightText: 2013-2014 Alex Merry # SPDX-FileCopyrightText: 2007 Pino Toscano # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindSharedMimeInfo ------------------ Try to find the shared-mime-info package. This will define the following variables: ``SharedMimeInfo_FOUND`` True if system has the shared-mime-info package ``UPDATE_MIME_DATABASE_EXECUTABLE`` The update-mime-database executable and the following imported targets: ``SharedMimeInfo::UpdateMimeDatabase`` The update-mime-database executable The follow macro is available:: update_xdg_mimetypes() Updates the XDG mime database at install time (unless the ``$DESTDIR`` environment variable is set, in which case it is up to package managers to perform this task). Since pre-1.0.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(SharedMimeInfo) find_program (UPDATE_MIME_DATABASE_EXECUTABLE NAMES update-mime-database) if (UPDATE_MIME_DATABASE_EXECUTABLE) execute_process( COMMAND "${UPDATE_MIME_DATABASE_EXECUTABLE}" -v OUTPUT_VARIABLE _smiVersionRaw ERROR_VARIABLE _smiVersionRaw) string(REGEX REPLACE "update-mime-database \\([a-zA-Z\\-]+\\) ([0-9]\\.[0-9]+).*" "\\1" SharedMimeInfo_VERSION_STRING "${_smiVersionRaw}") endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(SharedMimeInfo FOUND_VAR SharedMimeInfo_FOUND REQUIRED_VARS UPDATE_MIME_DATABASE_EXECUTABLE VERSION_VAR SharedMimeInfo_VERSION_STRING) if(SharedMimeInfo_FOUND AND NOT TARGET SharedMimeInfo::UpdateMimeDatabase) add_executable(SharedMimeInfo::UpdateMimeDatabase IMPORTED) set_target_properties(SharedMimeInfo::UpdateMimeDatabase PROPERTIES IMPORTED_LOCATION "${UPDATE_MIME_DATABASE_EXECUTABLE}" ) endif() mark_as_advanced(UPDATE_MIME_DATABASE_EXECUTABLE) function(UPDATE_XDG_MIMETYPES _path) get_filename_component(_xdgmimeDir "${_path}" NAME) if("${_xdgmimeDir}" STREQUAL packages ) get_filename_component(_xdgmimeDir "${_path}" PATH) else() set(_xdgmimeDir "${_path}") endif() # Note that targets and most variables are not available to install code install(CODE " set(DESTDIR_VALUE \"\$ENV{DESTDIR}\") if (NOT DESTDIR_VALUE) # under Windows relative paths are used, that's why it runs from CMAKE_INSTALL_PREFIX message(STATUS \"Updating MIME database at \${CMAKE_INSTALL_PREFIX}/${_xdgmimeDir}\") execute_process(COMMAND \"${UPDATE_MIME_DATABASE_EXECUTABLE}\" -n \"${_xdgmimeDir}\" WORKING_DIRECTORY \"\${CMAKE_INSTALL_PREFIX}\") endif (NOT DESTDIR_VALUE) ") endfunction() include(FeatureSummary) set_package_properties(SharedMimeInfo PROPERTIES URL https://freedesktop.org/wiki/Software/shared-mime-info/ DESCRIPTION "A database of common MIME types") # SPDX-FileCopyrightText: 2006 Laurent Montel # SPDX-FileCopyrightText: 2019 Heiko Becker # SPDX-FileCopyrightText: 2020 Elvis Angelaccio # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindTaglib ---------- Try to find the Taglib library. This will define the following variables: ``Taglib_FOUND`` True if the system has the taglib library of at least the minimum version specified by the version parameter to find_package() ``Taglib_INCLUDE_DIRS`` The taglib include dirs for use with target_include_directories ``Taglib_LIBRARIES`` The taglib libraries for use with target_link_libraries() ``Taglib_VERSION`` The version of taglib that was found If ``Taglib_FOUND`` is TRUE, it will also define the following imported target: ``Taglib::Taglib`` The Taglib library Since 5.72.0 #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PC_TAGLIB QUIET taglib) find_path(Taglib_INCLUDE_DIRS NAMES tag.h PATH_SUFFIXES taglib HINTS ${PC_TAGLIB_INCLUDEDIR} ) find_library(Taglib_LIBRARIES NAMES tag HINTS ${PC_TAGLIB_LIBDIR} ) set(Taglib_VERSION ${PC_TAGLIB_VERSION}) if (Taglib_INCLUDE_DIRS AND NOT Taglib_VERSION) if(EXISTS "${Taglib_INCLUDE_DIRS}/taglib.h") file(READ "${Taglib_INCLUDE_DIRS}/taglib.h" TAGLIB_H) string(REGEX MATCH "#define TAGLIB_MAJOR_VERSION[ ]+[0-9]+" TAGLIB_MAJOR_VERSION_MATCH ${TAGLIB_H}) string(REGEX MATCH "#define TAGLIB_MINOR_VERSION[ ]+[0-9]+" TAGLIB_MINOR_VERSION_MATCH ${TAGLIB_H}) string(REGEX MATCH "#define TAGLIB_PATCH_VERSION[ ]+[0-9]+" TAGLIB_PATCH_VERSION_MATCH ${TAGLIB_H}) string(REGEX REPLACE ".*_MAJOR_VERSION[ ]+(.*)" "\\1" TAGLIB_MAJOR_VERSION "${TAGLIB_MAJOR_VERSION_MATCH}") string(REGEX REPLACE ".*_MINOR_VERSION[ ]+(.*)" "\\1" TAGLIB_MINOR_VERSION "${TAGLIB_MINOR_VERSION_MATCH}") string(REGEX REPLACE ".*_PATCH_VERSION[ ]+(.*)" "\\1" TAGLIB_PATCH_VERSION "${TAGLIB_PATCH_VERSION_MATCH}") set(Taglib_VERSION "${TAGLIB_MAJOR_VERSION}.${TAGLIB_MINOR_VERSION}.${TAGLIB_PATCH_VERSION}") endif() endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Taglib FOUND_VAR Taglib_FOUND REQUIRED_VARS Taglib_LIBRARIES Taglib_INCLUDE_DIRS VERSION_VAR Taglib_VERSION ) if (Taglib_FOUND AND NOT TARGET Taglib::Taglib) add_library(Taglib::Taglib UNKNOWN IMPORTED) set_target_properties(Taglib::Taglib PROPERTIES IMPORTED_LOCATION "${Taglib_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${Taglib_INCLUDE_DIRS}" ) endif() mark_as_advanced(Taglib_LIBRARIES Taglib_INCLUDE_DIRS) include(FeatureSummary) set_package_properties(Taglib PROPERTIES URL "https://taglib.org/" DESCRIPTION "A library for reading and editing the meta-data of audio formats" ) # SPDX-FileCopyrightText: 2010 Rafael Fernández López # SPDX-FileCopyrightText: 2019 Volker Krause # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindUDev -------- Try to find the UDev library. This will define the following variables: ``UDev_FOUND`` System has UDev. ``UDev_INCLUDE_DIRS`` The libudev include directory. ``UDev_LIBRARIES`` The libudev libraries. ``UDev_VERSION`` The libudev version. If ``UDev_FOUND`` is TRUE, it will also define the following imported target: ``UDev::UDev`` The UDev library Since 5.57.0. #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PC_UDEV QUIET libudev) find_path(UDev_INCLUDE_DIRS NAMES libudev.h HINTS ${PC_UDEV_INCLUDE_DIRS}) find_library(UDev_LIBRARIES NAMES udev HINTS ${PC_UDEV_LIBRARY_DIRS}) set(UDev_VERSION ${PC_UDEV_VERSION}) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(UDev FOUND_VAR UDev_FOUND REQUIRED_VARS UDev_INCLUDE_DIRS UDev_LIBRARIES VERSION_VAR UDev_VERSION ) mark_as_advanced(UDev_INCLUDE_DIRS UDev_LIBRARIES) if(UDev_FOUND AND NOT TARGET UDev::UDev) add_library(UDev::UDev UNKNOWN IMPORTED) set_target_properties(UDev::UDev PROPERTIES IMPORTED_LOCATION "${UDev_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${UDev_INCLUDE_DIRS}" INTERFACE_COMPILE_DEFINITIONS "${PC_UDEV_CFLAGS_OTHER}" ) endif() # backward compat variables, remove for KF6 set(UDEV_FOUND ${UDev_FOUND}) set(UDEV_LIBS ${UDev_LIBRARIES}) set(UDEV_INCLUDE_DIR ${UDev_INCLUDE_DIRS}) mark_as_advanced(UDEV_FOUND UDEV_LIBS UDEV_INCLUDE_DIR) include(FeatureSummary) set_package_properties(UDev PROPERTIES DESCRIPTION "API for enumerating and introspecting local devices (part of systemd)" URL "https://www.freedesktop.org/wiki/Software/systemd/" ) # SPDX-FileCopyrightText: 2014 Alex Merry # SPDX-FileCopyrightText: 2014 Martin Gräßlin # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindWayland ----------- Try to find Wayland. This is a component-based find module, which makes use of the COMPONENTS and OPTIONAL_COMPONENTS arguments to find_module. The following components are available:: Client Server Cursor Egl If no components are specified, this module will act as though all components were passed to OPTIONAL_COMPONENTS. This module will define the following variables, independently of the components searched for or found: ``Wayland_FOUND`` TRUE if (the requested version of) Wayland is available ``Wayland_VERSION`` Found Wayland version ``Wayland_TARGETS`` A list of all targets imported by this module (note that there may be more than the components that were requested) ``Wayland_LIBRARIES`` This can be passed to target_link_libraries() instead of the imported targets ``Wayland_INCLUDE_DIRS`` This should be passed to target_include_directories() if the targets are not used for linking ``Wayland_DEFINITIONS`` This should be passed to target_compile_options() if the targets are not used for linking ``Wayland_DATADIR`` The core wayland protocols data directory Since 5.73.0 For each searched-for components, ``Wayland__FOUND`` will be set to TRUE if the corresponding Wayland library was found, and FALSE otherwise. If ``Wayland__FOUND`` is TRUE, the imported target ``Wayland::`` will be defined. This module will also attempt to determine ``Wayland_*_VERSION`` variables for each imported target, although ``Wayland_VERSION`` should normally be sufficient. In general we recommend using the imported targets, as they are easier to use and provide more control. Bear in mind, however, that if any target is in the link interface of an exported library, it must be made available by the package config file. Since pre-1.0.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(Wayland) set(Wayland_known_components Client Server Cursor Egl ) foreach(_comp ${Wayland_known_components}) string(TOLOWER "${_comp}" _lc_comp) set(Wayland_${_comp}_component_deps) set(Wayland_${_comp}_pkg_config "wayland-${_lc_comp}") set(Wayland_${_comp}_lib "wayland-${_lc_comp}") set(Wayland_${_comp}_header "wayland-${_lc_comp}.h") endforeach() set(Wayland_Egl_component_deps Client) ecm_find_package_parse_components(Wayland RESULT_VAR Wayland_components KNOWN_COMPONENTS ${Wayland_known_components} ) ecm_find_package_handle_library_components(Wayland COMPONENTS ${Wayland_components} ) # If pkg-config didn't provide us with version information, # try to extract it from wayland-version.h # (Note that the version from wayland-egl.pc will probably be # the Mesa version, rather than the Wayland version, but that # version will be ignored as we always find wayland-client.pc # first). if(NOT Wayland_VERSION) find_file(Wayland_VERSION_HEADER NAMES wayland-version.h HINTS ${Wayland_INCLUDE_DIRS} ) mark_as_advanced(Wayland_VERSION_HEADER) if(Wayland_VERSION_HEADER) file(READ ${Wayland_VERSION_HEADER} _wayland_version_header_contents) string(REGEX REPLACE "^.*[ \t]+WAYLAND_VERSION[ \t]+\"([0-9.]*)\".*$" "\\1" Wayland_VERSION "${_wayland_version_header_contents}" ) unset(_wayland_version_header_contents) endif() endif() find_package_handle_standard_args(Wayland FOUND_VAR Wayland_FOUND REQUIRED_VARS Wayland_LIBRARIES VERSION_VAR Wayland_VERSION HANDLE_COMPONENTS ) pkg_get_variable(Wayland_DATADIR wayland-scanner pkgdatadir) if (CMAKE_CROSSCOMPILING AND (NOT EXISTS "${Wayland_DATADIR}/wayland.xml")) # PKG_CONFIG_SYSROOT_DIR only applies to -I and -L flags, so pkg-config # does not prepend CMAKE_SYSROOT when cross-compiling unless you pass # --define-prefix explicitly. Therefore we have to manually do prepend # it here when cross-compiling. # See https://gitlab.kitware.com/cmake/cmake/-/issues/16647#note_844761 set(Wayland_DATADIR ${CMAKE_SYSROOT}${Wayland_DATADIR}) endif() if (NOT EXISTS "${Wayland_DATADIR}/wayland.xml") message(WARNING "Could not find wayland.xml in ${Wayland_DATADIR}") endif() include(FeatureSummary) set_package_properties(Wayland PROPERTIES URL "https://wayland.freedesktop.org/" DESCRIPTION "C library implementation of the Wayland protocol: a protocol for a compositor to talk to its clients" ) # SPDX-FileCopyrightText: 2019 Vlad Zahorodnii # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindWaylandProtocols -------------------- Try to find wayland-protocols on a Unix system. This will define the following variables: ``WaylandProtocols_FOUND`` True if (the requested version of) wayland-protocols is available ``WaylandProtocols_VERSION`` The version of wayland-protocols ``WaylandProtocols_DATADIR`` The wayland protocols data directory #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PKG_wayland_protocols QUIET wayland-protocols) set(WaylandProtocols_VERSION ${PKG_wayland_protocols_VERSION}) pkg_get_variable(WaylandProtocols_DATADIR wayland-protocols pkgdatadir) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(WaylandProtocols FOUND_VAR WaylandProtocols_FOUND REQUIRED_VARS WaylandProtocols_DATADIR VERSION_VAR WaylandProtocols_VERSION ) include(FeatureSummary) set_package_properties(WaylandProtocols PROPERTIES DESCRIPTION "Specifications of extended Wayland protocols" URL "https://wayland.freedesktop.org/" ) # SPDX-FileCopyrightText: 2012-2014 Pier Luigi Fiorini # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindWaylandScanner ------------------ Try to find wayland-scanner. If the wayland-scanner executable is not in your PATH, you can provide an alternative name or full path location with the ``WaylandScanner_EXECUTABLE`` variable. This will define the following variables: ``WaylandScanner_FOUND`` True if wayland-scanner is available. ``WaylandScanner_EXECUTABLE`` The wayland-scanner executable. If ``WaylandScanner_FOUND`` is TRUE, it will also define the following imported target: ``Wayland::Scanner`` The wayland-scanner executable. This module provides the following functions to generate C protocol implementations: - ``ecm_add_wayland_client_protocol`` - ``ecm_add_wayland_server_protocol`` :: ecm_add_wayland_client_protocol( PROTOCOL BASENAME [PRIVATE_CODE]) ecm_add_wayland_client_protocol( PROTOCOL BASENAME [PRIVATE_CODE]) Generate Wayland client protocol files from ```` XML definition for the ```` interface and append those files to ```` or ````. ``PRIVATE_CODE`` instructs wayland-scanner to hide marshalling code from the compiled DSO for use in other DSOs. The default is to export this code. :: ecm_add_wayland_server_protocol( PROTOCOL BASENAME [PRIVATE_CODE]) ecm_add_wayland_server_protocol( PROTOCOL BASENAME [PRIVATE_CODE]) Generate Wayland server protocol files from ```` XML definition for the ```` interface and append those files to ```` or ````. ``PRIVATE_CODE`` instructs wayland-scanner to hide marshalling code from the compiled DSO for use in other DSOs. The default is to export this code. Since 1.4.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(WaylandScanner) # Find wayland-scanner find_program(WaylandScanner_EXECUTABLE NAMES wayland-scanner) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(WaylandScanner FOUND_VAR WaylandScanner_FOUND REQUIRED_VARS WaylandScanner_EXECUTABLE ) mark_as_advanced(WaylandScanner_EXECUTABLE) if(NOT TARGET Wayland::Scanner AND WaylandScanner_FOUND) add_executable(Wayland::Scanner IMPORTED) set_target_properties(Wayland::Scanner PROPERTIES IMPORTED_LOCATION "${WaylandScanner_EXECUTABLE}" ) endif() include(FeatureSummary) set_package_properties(WaylandScanner PROPERTIES URL "https://wayland.freedesktop.org/" DESCRIPTION "Executable that converts XML protocol files to C code" ) function(ecm_add_wayland_client_protocol target_or_sources_var) # Parse arguments set(options PRIVATE_CODE) set(oneValueArgs PROTOCOL BASENAME) cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "" ${ARGN}) if(ARGS_UNPARSED_ARGUMENTS) message(FATAL_ERROR "Unknown keywords given to ecm_add_wayland_client_protocol(): \"${ARGS_UNPARSED_ARGUMENTS}\"") endif() get_filename_component(_infile ${ARGS_PROTOCOL} ABSOLUTE) set(_client_header "${CMAKE_CURRENT_BINARY_DIR}/wayland-${ARGS_BASENAME}-client-protocol.h") set(_code "${CMAKE_CURRENT_BINARY_DIR}/wayland-${ARGS_BASENAME}-protocol.c") if(ARGS_PRIVATE_CODE) set(_code_type private-code) else() set(_code_type public-code) endif() set_source_files_properties(${_client_header} GENERATED) set_source_files_properties(${_code} GENERATED) set_property(SOURCE ${_client_header} ${_code} PROPERTY SKIP_AUTOMOC ON) add_custom_command(OUTPUT "${_client_header}" COMMAND ${WaylandScanner_EXECUTABLE} client-header ${_infile} ${_client_header} DEPENDS ${_infile} VERBATIM) add_custom_command(OUTPUT "${_code}" COMMAND ${WaylandScanner_EXECUTABLE} ${_code_type} ${_infile} ${_code} DEPENDS ${_infile} ${_client_header} VERBATIM) if (TARGET ${target_or_sources_var}) target_sources(${target_or_sources_var} PRIVATE "${_client_header}" "${_code}") else() list(APPEND ${target_or_sources_var} "${_client_header}" "${_code}") set(${target_or_sources_var} ${${target_or_sources_var}} PARENT_SCOPE) endif() endfunction() function(ecm_add_wayland_server_protocol target_or_sources_var) # Parse arguments set(options PRIVATE_CODE) set(oneValueArgs PROTOCOL BASENAME) cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "" ${ARGN}) if(ARGS_UNPARSED_ARGUMENTS) message(FATAL_ERROR "Unknown keywords given to ecm_add_wayland_server_protocol(): \"${ARGS_UNPARSED_ARGUMENTS}\"") endif() if(ARGS_PRIVATE_CODE) set(_private_code_option PRIVATE_CODE) endif() ecm_add_wayland_client_protocol(${target_or_sources_var} PROTOCOL ${ARGS_PROTOCOL} BASENAME ${ARGS_BASENAME} ${_private_code_option}) get_filename_component(_infile ${ARGS_PROTOCOL} ABSOLUTE) set(_server_header "${CMAKE_CURRENT_BINARY_DIR}/wayland-${ARGS_BASENAME}-server-protocol.h") set(_server_code "${CMAKE_CURRENT_BINARY_DIR}/wayland-${ARGS_BASENAME}-protocol.c") set_property(SOURCE ${_server_header} ${_server_code} PROPERTY SKIP_AUTOMOC ON) set_source_files_properties(${_server_header} GENERATED) add_custom_command(OUTPUT "${_server_header}" COMMAND ${WaylandScanner_EXECUTABLE} server-header ${_infile} ${_server_header} DEPENDS ${_infile} VERBATIM) if (TARGET ${target_or_sources_var}) target_sources(${target_or_sources_var} PRIVATE "${_server_header}") else() list(APPEND ${target_or_sources_var} "${_server_header}") set(${target_or_sources_var} ${${target_or_sources_var}} PARENT_SCOPE) endif() endfunction() # SPDX-FileCopyrightText: 2014 Alex Merry # SPDX-FileCopyrightText: 2011 Fredrik Höglund # SPDX-FileCopyrightText: 2008 Helio Chissini de Castro # SPDX-FileCopyrightText: 2007 Matthias Kretz # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindX11_XCB ----------- Try to find the X11 XCB compatibility library. This will define the following variables: ``X11_XCB_FOUND`` True if (the requested version of) libX11-xcb is available ``X11_XCB_VERSION`` The version of libX11-xcb (this is not guaranteed to be set even when X11_XCB_FOUND is true) ``X11_XCB_LIBRARIES`` This can be passed to target_link_libraries() instead of the ``EGL::EGL`` target ``X11_XCB_INCLUDE_DIR`` This should be passed to target_include_directories() if the target is not used for linking ``X11_XCB_DEFINITIONS`` This should be passed to target_compile_options() if the target is not used for linking If ``X11_XCB_FOUND`` is TRUE, it will also define the following imported target: ``X11::XCB`` The X11 XCB compatibility library In general we recommend using the imported target, as it is easier to use. Bear in mind, however, that if the target is in the link interface of an exported library, it must be made available by the package config file. Since pre-1.0.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(X11_XCB) # use pkg-config to get the directories and then use these values # in the FIND_PATH() and FIND_LIBRARY() calls find_package(PkgConfig QUIET) pkg_check_modules(PKG_X11_XCB QUIET x11-xcb) set(X11_XCB_DEFINITIONS ${PKG_X11_XCB_CFLAGS_OTHER}) set(X11_XCB_VERSION ${PKG_X11_XCB_VERSION}) find_path(X11_XCB_INCLUDE_DIR NAMES X11/Xlib-xcb.h HINTS ${PKG_X11_XCB_INCLUDE_DIRS} ) find_library(X11_XCB_LIBRARY NAMES X11-xcb HINTS ${PKG_X11_XCB_LIBRARY_DIRS} ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(X11_XCB FOUND_VAR X11_XCB_FOUND REQUIRED_VARS X11_XCB_LIBRARY X11_XCB_INCLUDE_DIR VERSION_VAR X11_XCB_VERSION ) if(X11_XCB_FOUND AND NOT TARGET X11::XCB) add_library(X11::XCB UNKNOWN IMPORTED) set_target_properties(X11::XCB PROPERTIES IMPORTED_LOCATION "${X11_XCB_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${X11_XCB_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${X11_XCB_INCLUDE_DIR}" ) endif() mark_as_advanced(X11_XCB_INCLUDE_DIR X11_XCB_LIBRARY) # compatibility variables set(X11_XCB_LIBRARIES ${X11_XCB_LIBRARY}) set(X11_XCB_INCLUDE_DIRS ${X11_XCB_INCLUDE_DIR}) set(X11_XCB_VERSION_STRING ${X11_XCB_VERSION}) include(FeatureSummary) set_package_properties(X11_XCB PROPERTIES URL "https://xorg.freedesktop.org/" DESCRIPTION "A compatibility library for code that translates Xlib API calls into XCB calls" ) # SPDX-FileCopyrightText: 2011 Fredrik Höglund # SPDX-FileCopyrightText: 2013 Martin Gräßlin # SPDX-FileCopyrightText: 2014-2015 Alex Merry # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: FindXCB ------- Try to find XCB. This is a component-based find module, which makes use of the COMPONENTS and OPTIONAL_COMPONENTS arguments to find_module. The following components are available:: XCB ATOM AUX COMPOSITE CURSOR DAMAGE DPMS DRI2 DRI3 EVENT EWMH GLX ICCCM IMAGE KEYSYMS PRESENT RANDR RECORD RENDER RENDERUTIL RES SCREENSAVER SHAPE SHM SYNC UTIL XF86DRI XFIXES XINERAMA XINPUT XKB XTEST XV XVMC If no components are specified, this module will act as though all components were passed to OPTIONAL_COMPONENTS. Before 5.82 this excluded XINPUT. Since 5.82 all components are searched for. This module will define the following variables, independently of the components searched for or found: ``XCB_FOUND`` True if (the requestion version of) xcb is available ``XCB_VERSION`` Found xcb version ``XCB_TARGETS`` A list of all targets imported by this module (note that there may be more than the components that were requested) ``XCB_LIBRARIES`` This can be passed to target_link_libraries() instead of the imported targets ``XCB_INCLUDE_DIRS`` This should be passed to target_include_directories() if the targets are not used for linking ``XCB_DEFINITIONS`` This should be passed to target_compile_options() if the targets are not used for linking For each searched-for components, ``XCB__FOUND`` will be set to true if the corresponding xcb library was found, and false otherwise. If ``XCB__FOUND`` is true, the imported target ``XCB::`` will be defined. This module will also attempt to determine ``XCB_*_VERSION`` variables for each imported target, although ``XCB_VERSION`` should normally be sufficient. In general we recommend using the imported targets, as they are easier to use and provide more control. Bear in mind, however, that if any target is in the link interface of an exported library, it must be made available by the package config file. Since pre-1.0.0. #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake) ecm_find_package_version_check(XCB) # Note that this list needs to be ordered such that any component # appears after its dependencies set(XCB_known_components XCB RENDER SHAPE XFIXES SHM ATOM AUX COMPOSITE CURSOR DAMAGE DPMS DRI2 DRI3 EVENT EWMH GLX ICCCM IMAGE KEYSYMS PRESENT RANDR RECORD RENDERUTIL RES SCREENSAVER SYNC UTIL XF86DRI XINERAMA XINPUT XKB XTEST XV XVMC ) # default component info: xcb components have fairly predictable # header files, library names and pkg-config names foreach(_comp ${XCB_known_components}) string(TOLOWER "${_comp}" _lc_comp) set(XCB_${_comp}_component_deps XCB) set(XCB_${_comp}_pkg_config "xcb-${_lc_comp}") set(XCB_${_comp}_lib "xcb-${_lc_comp}") set(XCB_${_comp}_header "xcb/${_lc_comp}.h") endforeach() # exceptions set(XCB_XCB_component_deps) set(XCB_COMPOSITE_component_deps XCB XFIXES) set(XCB_DAMAGE_component_deps XCB XFIXES) set(XCB_IMAGE_component_deps XCB SHM) set(XCB_RENDERUTIL_component_deps XCB RENDER) set(XCB_XFIXES_component_deps XCB RENDER SHAPE) set(XCB_XVMC_component_deps XCB XV) set(XCB_XV_component_deps XCB SHM) set(XCB_XCB_pkg_config "xcb") set(XCB_XCB_lib "xcb") set(XCB_ATOM_header "xcb/xcb_atom.h") set(XCB_ATOM_lib "xcb-util") set(XCB_AUX_header "xcb/xcb_aux.h") set(XCB_AUX_lib "xcb-util") set(XCB_CURSOR_header "xcb/xcb_cursor.h") set(XCB_EVENT_header "xcb/xcb_event.h") set(XCB_EVENT_lib "xcb-util") set(XCB_EWMH_header "xcb/xcb_ewmh.h") set(XCB_ICCCM_header "xcb/xcb_icccm.h") set(XCB_IMAGE_header "xcb/xcb_image.h") set(XCB_KEYSYMS_header "xcb/xcb_keysyms.h") set(XCB_PIXEL_header "xcb/xcb_pixel.h") set(XCB_RENDERUTIL_header "xcb/xcb_renderutil.h") set(XCB_RENDERUTIL_lib "xcb-render-util") set(XCB_UTIL_header "xcb/xcb_util.h") ecm_find_package_parse_components(XCB RESULT_VAR XCB_components KNOWN_COMPONENTS ${XCB_known_components} DEFAULT_COMPONENTS ${XCB_default_components} ) ecm_find_package_handle_library_components(XCB COMPONENTS ${XCB_components} ) find_package_handle_standard_args(XCB FOUND_VAR XCB_FOUND REQUIRED_VARS XCB_LIBRARIES VERSION_VAR XCB_VERSION HANDLE_COMPONENTS ) include(FeatureSummary) set_package_properties(XCB PROPERTIES URL "https://xcb.freedesktop.org/" DESCRIPTION "X protocol C-language Binding" ) # SPDX-FileCopyrightText: 2014 Fredrik Höglund # SPDX-FileCopyrightText: 2020 Vlad Zahorodnii # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: Findepoxy --------- Try to find libepoxy on a Unix system. This will define the following variables: ``epoxy_FOUND`` True if (the requested version of) libepoxy is available ``epoxy_VERSION`` The version of libepoxy ``epoxy_LIBRARIES`` This should be passed to target_link_libraries() if the target is not used for linking ``epoxy_INCLUDE_DIRS`` This should be passed to target_include_directories() if the target is not used for linking ``epoxy_DEFINITIONS`` This should be passed to target_compile_options() if the target is not used for linking ``epoxy_HAS_GLX`` True if GLX support is available If ``epoxy_FOUND`` is TRUE, it will also define the following imported target: ``epoxy::epoxy`` The epoxy library In general we recommend using the imported target, as it is easier to use. Bear in mind, however, that if the target is in the link interface of an exported library, it must be made available by the package config file. #]=======================================================================] find_package(PkgConfig QUIET) pkg_check_modules(PKG_epoxy QUIET epoxy) set(epoxy_VERSION ${PKG_epoxy_VERSION}) set(epoxy_DEFINITIONS ${PKG_epoxy_CFLAGS}) find_path(epoxy_INCLUDE_DIRS NAMES epoxy/gl.h HINTS ${PKG_epoxy_INCLUDEDIR} ${PKG_epoxy_INCLUDE_DIRS} ) find_library(epoxy_LIBRARIES NAMES epoxy HINTS ${PKG_epoxy_LIBDIR} ${PKG_epoxy_LIBRARY_DIRS} ) find_file(epoxy_GLX_HEADER NAMES epoxy/glx.h HINTS ${epoxy_INCLUDE_DIR}) if (epoxy_GLX_HEADER STREQUAL "epoxy_GLX_HEADER-NOTFOUND") set(epoxy_HAS_GLX FALSE CACHE BOOL "whether glx is available") else () set(epoxy_HAS_GLX TRUE CACHE BOOL "whether glx is available") endif() include(FindPackageHandleStandardArgs) find_package_handle_standard_args(epoxy FOUND_VAR epoxy_FOUND REQUIRED_VARS epoxy_LIBRARIES epoxy_INCLUDE_DIRS VERSION_VAR epoxy_VERSION ) if (epoxy_FOUND AND NOT TARGET epoxy::epoxy) add_library(epoxy::epoxy UNKNOWN IMPORTED) set_target_properties(epoxy::epoxy PROPERTIES IMPORTED_LOCATION "${epoxy_LIBRARIES}" INTERFACE_COMPILE_OPTIONS "${epoxy_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${epoxy_INCLUDE_DIRS}" ) endif() mark_as_advanced( epoxy_DEFINITIONS epoxy_HAS_GLX epoxy_INCLUDE_DIRS epoxy_LIBRARIES epoxy_VERSION ) # SPDX-FileCopyrightText: 2019, 2021 Friedrich W. H. Kossebau # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: Findgzip -------- Try to find gzip. If the gzip executable is not in your PATH, you can provide an alternative name or full path location with the ``gzip_EXECUTABLE`` variable. This will define the following variables: ``gzip_FOUND`` TRUE if gzip is available ``gzip_EXECUTABLE`` Path to gzip executable If ``gzip_FOUND`` is TRUE, it will also define the following imported target: ``gzip::gzip`` Path to gzip executable Since 5.85.0. #]=======================================================================] find_program(gzip_EXECUTABLE NAMES gzip) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(gzip FOUND_VAR gzip_FOUND REQUIRED_VARS gzip_EXECUTABLE ) mark_as_advanced(gzip_EXECUTABLE) if(NOT TARGET gzip::gzip AND gzip_FOUND) add_executable(gzip::gzip IMPORTED) set_target_properties(gzip::gzip PROPERTIES IMPORTED_LOCATION "${gzip_EXECUTABLE}" ) endif() include(FeatureSummary) set_package_properties(gzip PROPERTIES URL "https://www.gnu.org/software/gzip" DESCRIPTION "Data compression program for the gzip format" ) sdk.dir=@ANDROID_SDK_ROOT@ rootProject.name = '@ARG_NAME@' # SPDX-FileCopyrightText: 2014 Alex Merry # SPDX-FileCopyrightText: 2013 Aleix Pol # SPDX-FileCopyrightText: 2012-2013 Stephen Kelly # SPDX-FileCopyrightText: 2007 Matthias Kretz # SPDX-FileCopyrightText: 2006-2007 Laurent Montel # SPDX-FileCopyrightText: 2006-2013 Alex Neundorf # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: KDECMakeSettings ---------------- Changes various CMake settings to what the KDE community views as more sensible defaults. It is recommended to include this module with the ``NO_POLICY_SCOPE`` flag, otherwise you may get spurious warnings with some versions of CMake. It is split into three parts, which can be independently disabled if desired. Runtime Paths ~~~~~~~~~~~~~ The default runtime path (used on Unix systems to search for dynamically-linked libraries) is set to include the location that libraries will be installed to (as set in ``LIB_INSTALL_DIR`` or, if the former is not set, ``KDE_INSTALL_LIBDIR``), and also the linker search path. .. note:: ``LIB_INSTALL_DIR`` or alternatively ``KDE_INSTALL_LIBDIR`` needs to be set before including this module. Typically, this is done by including the :kde-module:`KDEInstallDirs` module. This section can be disabled by setting ``KDE_SKIP_RPATH_SETTINGS`` to ``TRUE`` before including this module. Testing ~~~~~~~ Testing is enabled by default, and an option ``BUILD_TESTING`` is provided for users to control this. See the CTest module documentation in the CMake manual for more details. This section can be disabled by setting ``KDE_SKIP_TEST_SETTINGS`` to ``TRUE`` before including this module. Build Settings ~~~~~~~~~~~~~~ Various CMake build defaults are altered, such as searching source and build directories for includes first, enabling automoc by default. When ``find_package(ECM 5.38)`` or higher is called, this also selects a layout for the build dir that helps running executables without installing: all executables are built into a toplevel "bin" dir, making it possible to find helper binaries, and to find uninstalled plugins (provided that you use ``kcoreaddons_add_plugin()`` or set ``LIBRARY_OUTPUT_DIRECTORY`` as documented on https://community.kde.org/Guidelines_and_HOWTOs/Making_apps_run_uninstalled). This section can be disabled by setting ``KDE_SKIP_BUILD_SETTINGS`` to ``TRUE`` before including this module. This section also provides an ``uninstall`` target that can be individually disabled by setting ``KDE_SKIP_UNINSTALL_TARGET`` to ``TRUE`` before including this module. By default on OS X, X11 and XCB related detections are disabled. However if the need would arise to use these technologies, the detection can be enabled by setting ``APPLE_FORCE_X11`` to ``ON``. A warning is printed for the developer to know that the detection is disabled on OS X. This message can be turned off by setting ``APPLE_SUPPRESS_X11_WARNING`` to ``ON``. Since pre-1.0.0. ``ENABLE_CLAZY`` option is added (``OFF`` by default) when clang is being used. Turning this option on will force clang to load the clazy plugins for richer warnings on Qt-related code. If clang is not being used, this won't have an effect. See https://commits.kde.org/clazy?path=README.md Since 5.17.0 - ``uninstall`` target functionality since 1.7.0 - ``APPLE_FORCE_X11`` option since 5.14.0 (detecting X11 was previously the default behavior) - ``APPLE_SUPPRESS_X11_WARNING`` option since 5.14.0 - ``CMAKE_AUTORCC`` enabled by default when supported by CMake (>= 3.0) since 5.62.0 Translations (deprecated) ~~~~~~~~~~~~~~~~~~~~~~~~~ A fetch-translations target will be set up that will download translations for projects using l10n.kde.org. ``KDE_L10N_BRANCH`` will be responsible for choosing which l10n branch to use for the translations. ``KDE_L10N_AUTO_TRANSLATIONS`` (``OFF`` by default) will indicate whether translations should be downloaded when building the project. Since 5.34.0 ``KDE_L10N_SYNC_TRANSLATIONS`` (``OFF`` by default) will download the translations at configuration time instead of build time. Since 5.50.0 All ``KDE_L10N_*`` options have been deprecated since 5.102.0, as translations are meanwhile present inside the source code repositories. #]=======================================================================] ################# RPATH handling ################################## if(NOT KDE_SKIP_RPATH_SETTINGS) # Set the default RPATH to point to useful locations, namely where the # libraries will be installed and the linker search path # First look for the old LIB_INSTALL_DIR, then fallback to newer KDE_INSTALL_LIBDIR if(NOT LIB_INSTALL_DIR) if(NOT KDE_INSTALL_LIBDIR) message(FATAL_ERROR "Neither KDE_INSTALL_LIBDIR nor LIB_INSTALL_DIR is set. Setting one is necessary for using the RPATH settings.") else() set(_abs_LIB_INSTALL_DIR "${KDE_INSTALL_LIBDIR}") endif() else() set(_abs_LIB_INSTALL_DIR "${LIB_INSTALL_DIR}") endif() if (NOT IS_ABSOLUTE "${_abs_LIB_INSTALL_DIR}") set(_abs_LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${_abs_LIB_INSTALL_DIR}") endif() if (UNIX) # for macOS: add install name dir in addition # check: is the rpath stuff below really required on macOS? at least it seems so to use a stock qt from qt.io if (APPLE) set(CMAKE_INSTALL_NAME_DIR ${_abs_LIB_INSTALL_DIR}) endif () # add our LIB_INSTALL_DIR to the RPATH (but only when it is not one of # the standard system link directories - such as /usr/lib on UNIX) list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${_abs_LIB_INSTALL_DIR}" _isSystemLibDir) list(FIND CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "${_abs_LIB_INSTALL_DIR}" _isSystemCxxLibDir) list(FIND CMAKE_C_IMPLICIT_LINK_DIRECTORIES "${_abs_LIB_INSTALL_DIR}" _isSystemCLibDir) if("${_isSystemLibDir}" STREQUAL "-1" AND "${_isSystemCxxLibDir}" STREQUAL "-1" AND "${_isSystemCLibDir}" STREQUAL "-1") set(CMAKE_INSTALL_RPATH "${_abs_LIB_INSTALL_DIR}") endif() # Append directories in the linker search path (but outside the project) set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) endif (UNIX) endif() ################ Testing setup #################################### find_program(APPSTREAMCLI appstreamcli) function(appstreamtest) cmake_policy(PUSH) cmake_policy(SET CMP0064 NEW) # enable TEST operator if(TEST appstreamtest) # already configured elseif(APPSTREAMCLI) add_test(NAME appstreamtest COMMAND ${CMAKE_COMMAND} -DAPPSTREAMCLI=${APPSTREAMCLI} -DINSTALL_FILES=${CMAKE_BINARY_DIR}/install_manifest.txt -P ${CMAKE_CURRENT_LIST_DIR}/appstreamtest.cmake) else() message(STATUS "Could not set up the appstream test. appstreamcli is missing.") endif() cmake_policy(POP) endfunction() if(NOT KDE_SKIP_TEST_SETTINGS) # If there is a CTestConfig.cmake, include CTest. # Otherwise, there will not be any useful settings, so just # fake the functionality we care about from CTest. if (EXISTS ${CMAKE_SOURCE_DIR}/CTestConfig.cmake) include(CTest) else() option(BUILD_TESTING "Build the testing tree." ON) if(BUILD_TESTING) enable_testing() appstreamtest() endif () endif () endif() ################ Build-related settings ########################### if(NOT KDE_SKIP_BUILD_SETTINGS) # Always include srcdir and builddir in include path # This saves typing ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} in about every subdir # since cmake 2.4.0 set(CMAKE_INCLUDE_CURRENT_DIR ON) # put the include dirs which are in the source or build tree # before all other include dirs, so the headers in the sources # are preferred over the already installed ones # since cmake 2.4.1 set(CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE ON) # Add the src and build dir to the BUILD_INTERFACE include directories # of all targets. Similar to CMAKE_INCLUDE_CURRENT_DIR, but transitive. # Since CMake 2.8.11 set(CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE ON) # When a shared library changes, but its includes do not, don't relink # all dependencies. It is not needed. # Since CMake 2.8.11 set(CMAKE_LINK_DEPENDS_NO_SHARED ON) # Default to shared libs for KDE, if no type is explicitly given to add_library(): set(BUILD_SHARED_LIBS TRUE CACHE BOOL "If enabled, shared libs will be built by default, otherwise static libs") # Enable automoc in cmake # Since CMake 2.8.6 set(CMAKE_AUTOMOC ON) # Enable autorcc and in cmake so qrc files get generated. # Since CMake 3.0 # TODO KF6: discuss enabling AUTOUIC and note porting requirements. autouic # acts on all #include "ui_*.h" assuming *.ui exists set(CMAKE_AUTORCC ON) # By default, create 'GUI' executables. This can be reverted on a per-target basis # using ECMMarkNonGuiExecutable # Since CMake 2.8.8 set(CMAKE_WIN32_EXECUTABLE ON) set(CMAKE_MACOSX_BUNDLE ON) # By default, don't put a prefix on MODULE targets. add_library(MODULE) is basically for plugin targets, # and in KDE plugins don't have a prefix. set(CMAKE_SHARED_MODULE_PREFIX "") unset(EXECUTABLE_OUTPUT_PATH) unset(LIBRARY_OUTPUT_PATH) unset(CMAKE_ARCHIVE_OUTPUT_DIRECTORY) unset(CMAKE_LIBRARY_OUTPUT_DIRECTORY) unset(CMAKE_RUNTIME_OUTPUT_DIRECTORY) # under Windows, output all executables and dlls into # one common directory, and all static|import libraries and plugins # into another one. This way test executables can find their dlls # even without installation. # We do the same under Unix to make it possible to run tests and apps without installing if (WIN32 OR ECM_GLOBAL_FIND_VERSION VERSION_GREATER_EQUAL 5.38.0) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib") set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin") endif() # For Android we need to put shared libraries into "lib" for androiddeployqt to work without prior installation. # That fact that this conflicts with the above isn't really an issue, as we can't run things while cross-compiling # for Android anyway. if (ANDROID) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib") endif() if (APPLE) # Disable detection of X11 and related package on OS X because when using # brew or macports, X11 can be installed and thus is detected. option(APPLE_FORCE_X11 "Force enable X11 related detection on OS X" OFF) option(APPLE_SUPPRESS_X11_WARNING "Suppress X11 and related technologies search disabling warning on OS X" OFF) if(NOT APPLE_FORCE_X11) if (NOT APPLE_SUPPRESS_X11_WARNING) message(WARNING "Searching for X11 and related technologies is disabled on Apple systems. Set APPLE_FORCE_X11 to ON to change this behaviour. Set APPLE_SUPPRESS_X11_WARNING to ON to hide this warning.") endif() set(CMAKE_DISABLE_FIND_PACKAGE_X11 true) set(CMAKE_DISABLE_FIND_PACKAGE_XCB true) set(CMAKE_DISABLE_FIND_PACKAGE_Qt5X11Extras true) endif() endif() option(KDE_SKIP_UNINSTALL_TARGET "Prevent an \"uninstall\" target from being generated." OFF) if(NOT KDE_SKIP_UNINSTALL_TARGET) include("${ECM_MODULE_DIR}/ECMUninstallTarget.cmake") endif() endif() if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") option(ENABLE_CLAZY "Enable Clazy warnings" OFF) if(ENABLE_CLAZY) find_library(CLAZY_v1_5_FOUND ClazyPlugin${CMAKE_SHARED_LIBRARY_SUFFIX}) if(CLAZY_v1_5_FOUND) # clazy >= 1.5 set(CMAKE_CXX_COMPILE_OBJECT "${CMAKE_CXX_COMPILE_OBJECT} -Xclang -load -Xclang ClazyPlugin${CMAKE_SHARED_LIBRARY_SUFFIX} -Xclang -add-plugin -Xclang clazy") else() # clazy < 1.5 set(CMAKE_CXX_COMPILE_OBJECT "${CMAKE_CXX_COMPILE_OBJECT} -Xclang -load -Xclang ClangLazy${CMAKE_SHARED_LIBRARY_SUFFIX} -Xclang -add-plugin -Xclang clang-lazy") endif() endif() endif() ################################################################### # Download translations function(_repository_name reponame dir) execute_process(COMMAND git rev-parse --symbolic-full-name @{u} OUTPUT_VARIABLE upstream_ref RESULT_VARIABLE exitCode WORKING_DIRECTORY "${dir}") if(exitCode EQUAL 0) string(REGEX REPLACE "refs/remotes/([^/]+)/.*" "\\1" gitorigin "${upstream_ref}") message(DEBUG "Git upstream inferred as ${gitorigin}, upstream ref was ${upstream_ref}") else() set(gitorigin "origin") message(DEBUG "Assuming origin as the git remote as we are in detached mode") endif() execute_process(COMMAND git remote get-url --all "${gitorigin}" OUTPUT_VARIABLE giturl RESULT_VARIABLE exitCode WORKING_DIRECTORY "${dir}") if(exitCode EQUAL 0) message(DEBUG "Git URL inferred as ${giturl}") string(REGEX MATCHALL ".+kde\\.org[:\\/]([-A-Za-z0-9\\/]+)(.git)?\\s*" "" ${giturl}) set(${reponame} ${CMAKE_MATCH_1}) message(DEBUG "Repository inferred as ${${reponame}}") endif() if(NOT ${reponame}) set(${reponame} ${CMAKE_PROJECT_NAME}) endif() set(${reponame} ${${reponame}} PARENT_SCOPE) endfunction() if(NOT EXISTS ${CMAKE_SOURCE_DIR}/po AND NOT TARGET fetch-translations) option(KDE_L10N_AUTO_TRANSLATIONS "Automatically 'make fetch-translations`" OFF) option(KDE_L10N_SYNC_TRANSLATIONS "Fetch translations when KDECMakeSettings.cmake is processed." OFF) set(KDE_L10N_BRANCH "trunk" CACHE STRING "Branch from l10n.kde.org to fetch from: trunk | stable | lts | trunk_kde4 | stable_kde4") if(KDE_L10N_AUTO_TRANSLATIONS AND NOT KDE_L10N_SYNC_TRANSLATIONS) set(_EXTRA_ARGS "ALL") else() set(_EXTRA_ARGS) endif() set(_reponame "") _repository_name(_reponame "${CMAKE_SOURCE_DIR}") set(releaseme_clone_commands COMMAND git clone --depth 1 https://invent.kde.org/sdk/releaseme.git ) add_custom_command( OUTPUT "${CMAKE_BINARY_DIR}/releaseme" ${releaseme_clone_commands} WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" COMMENT "Fetching releaseme scripts to download translations..." ) set(_l10n_po_dir "${CMAKE_BINARY_DIR}/po") set(_l10n_poqm_dir "${CMAKE_BINARY_DIR}/poqm") set(extra BYPRODUCTS ${_l10n_po_dir} ${_l10n_poqm_dir}) set(fetch_commands COMMAND ruby "${CMAKE_BINARY_DIR}/releaseme/fetchpo.rb" --origin ${KDE_L10N_BRANCH} --project "${_reponame}" --output-dir "${_l10n_po_dir}" --output-poqm-dir "${_l10n_poqm_dir}" "${CMAKE_CURRENT_SOURCE_DIR}" ) add_custom_target(fetch-translations ${_EXTRA_ARGS} COMMENT "Downloading translations for ${_reponame} branch ${KDE_L10N_BRANCH}..." COMMAND git -C "${CMAKE_BINARY_DIR}/releaseme" pull COMMAND cmake -E remove_directory ${_l10n_po_dir} COMMAND cmake -E remove_directory ${_l10n_poqm_dir} ${fetch_commands} ${extra} DEPENDS "${CMAKE_BINARY_DIR}/releaseme" ) if (KDE_L10N_SYNC_TRANSLATIONS AND (NOT EXISTS ${_l10n_po_dir} OR NOT EXISTS ${_l10n_poqm_dir})) execute_process(${releaseme_clone_commands}) execute_process(${fetch_commands}) endif() endif() # SPDX-FileCopyrightText: 2019 Christoph Cullmann # SPDX-FileCopyrightText: 2021 Alexander Lohnau # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: KDEClangFormat -------------------- This module provides a functionality to format the source code of your repository according to a predefined KDE clang-format file. This module provides the following function: :: kde_clang_format() Using this function will create a clang-format target that will format all ```` passed to the function with the predefined KDE clang-format style. To format the files you have to invoke the target with ``make clang-format`` or ``ninja clang-format``. Once the project is formatted it is recommended to enforce the formatting using a pre-commit hook, this can be done using :kde-module:`KDEGitCommitHooks`. The ``.clang-format`` file from ECM will be copied to the source directory. This file should not be added to version control. It is recommended to add it to the ``.gitignore`` file: ``/.clang-format``. Since 5.79: If the source folder already contains a .clang-format file it is not overwritten. Since version 5.80 this function is called by default in :kde-module:`KDEFrameworkCompilerSettings`. If directories should be excluded from the formatting a .clang-format file with ``DisableFormat: true`` and ``SortIncludes: false`` should be created. Example usage: .. code-block:: cmake include(KDEClangFormat) file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h *.hpp *.c) kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES}) To exclude directories from the formatting add a ``.clang-format`` file in the directory with the following contents: .. code-block:: yaml DisableFormat: true SortIncludes: false Since 5.64 #]=======================================================================] # try to find clang-format in path find_program(KDE_CLANG_FORMAT_EXECUTABLE clang-format) # instantiate our clang-format file, must be in source directory for tooling if we have the tool if(KDE_CLANG_FORMAT_EXECUTABLE) set(CLANG_FORMAT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/.clang-format) if (EXISTS ${CLANG_FORMAT_FILE}) file(READ ${CLANG_FORMAT_FILE} CLANG_FORMAT_CONTENTS LIMIT 1000) string(FIND "${CLANG_FORMAT_CONTENTS}" "This file got automatically created by ECM, do not edit" matchres) if(${matchres} EQUAL -1) message(WARNING "The .clang-format file already exists. Please remove it in order to use the file provided by ECM") else() configure_file(${CMAKE_CURRENT_LIST_DIR}/clang-format.cmake ${CLANG_FORMAT_FILE} @ONLY) endif() else() configure_file(${CMAKE_CURRENT_LIST_DIR}/clang-format.cmake ${CLANG_FORMAT_FILE} @ONLY) endif() endif() # formatting target function(KDE_CLANG_FORMAT) if (TARGET clang-format) # We can only define one clang-format target return() endif() # add target without specific commands first, we add the real calls file-per-file to avoid command line length issues and enable parallelization add_custom_target(clang-format COMMENT "Formatting sources in ${CMAKE_CURRENT_SOURCE_DIR} with ${KDE_CLANG_FORMAT_EXECUTABLE}...") # run clang-format only if available, else signal the user what is missing if(KDE_CLANG_FORMAT_EXECUTABLE) get_filename_component(_binary_dir ${CMAKE_BINARY_DIR} REALPATH) set(_ci_install_dir "${CMAKE_SOURCE_DIR}/_install") # on the KDE-CI, we install dependencies in-source foreach(_file ${ARGV}) # check if the file is inside the build directory => ignore such files get_filename_component(_full_file_path ${_file} REALPATH) string(FIND ${_full_file_path} ${_binary_dir} _binary_idx) string(FIND ${_full_file_path} ${_ci_install_dir} _dependency_idx) if(NOT _binary_idx EQUAL 0 AND NOT _dependency_idx EQUAL 0) get_filename_component(_file_name ${_file} NAME) file(RELATIVE_PATH _rel_file_path ${CMAKE_SOURCE_DIR} ${_full_file_path}) string(REPLACE "/" "_" unique_target_name "clang-format-${_rel_file_path}") string(REPLACE "%" "_" unique_target_name ${unique_target_name}) # some imvalid cmake target names string(REPLACE "{" "_" unique_target_name ${unique_target_name}) string(REPLACE "}" "_" unique_target_name ${unique_target_name}) add_custom_target(${unique_target_name} DEPENDS ${_full_file_path} ) add_custom_command(TARGET ${unique_target_name} POST_BUILD COMMAND ${KDE_CLANG_FORMAT_EXECUTABLE} -style=file -i ${_full_file_path} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ) add_dependencies(clang-format ${unique_target_name}) endif() endforeach() else() add_custom_command(TARGET clang-format COMMAND ${CMAKE_COMMAND} -E echo "Could not set up the clang-format target as the clang-format executable is missing." ) endif() endfunction() # SPDX-FileCopyrightText: 2014 Alex Merry # SPDX-FileCopyrightText: 2013 Stephen Kelly # SPDX-FileCopyrightText: 2012-2013 Raphael Kubo da Costa # SPDX-FileCopyrightText: 2007 Matthias Kretz # SPDX-FileCopyrightText: 2006-2007 Laurent Montel # SPDX-FileCopyrightText: 2006-2013 Alex Neundorf # SPDX-FileCopyrightText: 2021 Friedrich W. H. Kossebau # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: KDECompilerSettings ------------------- Set useful compile and link flags for C++ (and C) code. Enables many more warnings than the default, and sets stricter modes for some compiler features. By default, exceptions are disabled; ``kde_target_enable_exceptions()`` can be used to re-enable them for a specific target. .. note:: It is recommended to include this module with the ``NO_POLICY_SCOPE`` flag, otherwise you may get spurious warnings with some versions of CMake. Since 5.85 newer settings are controlled by a variable ``KDE_COMPILERSETTINGS_LEVEL``, taking an ECM version as value. That version can not be greater than the minimum required ECM version. The settings which are default at that version will then be used, but can be overridden by more fine-grained controls (see respective settings). This variable needs to be set before including this module, otherwise defaults to the minimum required ECM version. Modern code ~~~~~~~~~~~ The following CMake C standard default variables are set: For ``KDE_COMPILERSETTINGS_LEVEL`` >= 5.85: - ``CMAKE_C_STANDARD``: ``99`` - ``CMAKE_C_STANDARD_REQUIRED``: ``TRUE`` - ``CMAKE_C_EXTENSIONS``: ``OFF`` Otherwise: - ``CMAKE_C_STANDARD``: ``90`` - ``CMAKE_C_STANDARD_REQUIRED``: not modified - ``CMAKE_C_EXTENSIONS``: not modified If the variable ``CMAKE_C_STANDARD`` is already set when including this module, none of the above variables will be modified. The following CMake C++ standard default variables are set: For ``KDE_COMPILERSETTINGS_LEVEL`` >= 5.85: - ``CMAKE_CXX_STANDARD``: ``17`` - ``CMAKE_CXX_STANDARD_REQUIRED``: ``TRUE`` - ``CMAKE_CXX_EXTENSIONS``: ``OFF`` Otherwise: - ``CMAKE_CXX_STANDARD``: ``11`` - ``CMAKE_CXX_STANDARD_REQUIRED``: ``TRUE`` - ``CMAKE_CXX_EXTENSIONS``: not modified. If the variable ``CMAKE_CXX_STANDARD`` is already set when including this module, none of the above variables will be modified. The following C++ compiler flags are set: - ``-pedantic`` (GNU and Clang compilers, since 5.85) Can be disabled by setting ``KDE_SKIP_PEDANTIC_WARNINGS_SETTINGS`` to ``TRUE`` before including this module (default is ``FALSE`` for ``KDE_COMPILERSETTINGS_LEVEL`` >= 5.85, ``TRUE`` otherwise). - ``-Wmissing-include-dirs`` (GNU compilers, since 5.85) Can be disabled by setting ``KDE_SKIP_MISSING_INCLUDE_DIRS_WARNINGS_SETTINGS`` to ``TRUE`` before including this module (default is ``FALSE`` for ``KDE_COMPILERSETTINGS_LEVEL`` >= 5.85, ``TRUE`` otherwise). - ``-Wzero-as-null-pointer-constant`` (GNU and Clang compilers, since 5.85) Can be disabled by setting ``KDE_SKIP_NULLPTR_WARNINGS_SETTINGS`` to ``TRUE`` before including this module (default is ``FALSE`` for ``KDE_COMPILERSETTINGS_LEVEL`` >= 5.85, ``TRUE`` otherwise). - ``-Werror=undef`` (GNU and Clang compilers, since 5.96.0) - Qt related preprocessor definitions (since 5.85.0): - ``-DQT_NO_CAST_TO_ASCII`` - ``-DQT_NO_CAST_FROM_ASCII`` - ``-DQT_NO_URL_CAST_FROM_STRING`` - ``-DQT_NO_CAST_FROM_BYTEARRAY`` - ``-DQT_USE_QSTRINGBUILDER`` - ``-DQT_NO_NARROWING_CONVERSIONS_IN_CONNECT`` - ``-DQT_NO_KEYWORDS`` - ``-DQT_NO_FOREACH`` - ``-DQT_STRICT_ITERATORS`` Strict iterators are not enabled on Windows, because they lead to a link error when application code iterates over a QVector for instance, unless Qt itself was also built with strict iterators. See example at https://bugreports.qt.io/browse/AUTOSUITE-946 Can be controlled by setting ``KDE_QT_MODERNCODE_DEFINITIONS_LEVEL`` to the version of ECM where the wanted set of definitions has been added before including this module (default is ``KDE_COMPILERSETTINGS_LEVEL``). To disable individual definitions instead use ``remove_definitions()`` directly after including this module. Functions ~~~~~~~~~ This module provides the following functions:: kde_source_files_enable_exceptions([file1 [file2 [...]]]) Enables exceptions for specific source files. This should not be used on source files in a language other than C++. :: kde_target_enable_exceptions(target ) Enables exceptions for a specific target. This should not be used on a target that has source files in a language other than C++. :: kde_enable_exceptions() Enables exceptions for C++ source files compiled for the CMakeLists.txt file in the current directory and all subdirectories. Variables ~~~~~~~~~ Inclusion of this module defines the following variables: ``ENABLE_BSYMBOLICFUNCTIONS`` indicates whether we make use of ``-Bsymbolic-functions`` for linking. It ensures libraries bind global function references locally rather than at runtime. This option only has an effect on ELF-based systems. The option is disabled by default except when using :kde-module:`KDEFrameworkCompilerSettings` where it's enabled. Projects can enable it by calling ``set(ENABLE_BSYMBOLICFUNCTIONS ON)`` or passing ``-DENABLE BSYMBOLICFUNCTIONS=ON`` when configuring the build directory. Since 5.85 Example usages: .. code-block:: cmake # needing some macro/feature only available with ECM 5.80.0 find_package(ECM 5.80.0 NO_MODULE) # requiring ECM 5.80.0 above will default KDE_COMPILERSETTINGS_LEVEL also to 5.80.0, # thus not activate any newer settings include(KDECompilerSettings NO_POLICY_SCOPE) .. code-block:: cmake # needing some macro/feature only available with ECM 5.87.0 find_package(ECM 5.87.0 NO_MODULE) # project uses settings default as of KDECompilerSettings in ECM 5.85.0 set(KDE_COMPILERSETTINGS_LEVEL 5.85.0) include(KDECompilerSettings NO_POLICY_SCOPE) .. code-block:: cmake # needing some macro/feature only available with ECM 5.87.0 find_package(ECM 5.87.0 NO_MODULE) # project mainly uses settings default as of KDECompilerSettings in ECM 5.85.0 # with some small twisting set(KDE_COMPILERSETTINGS_LEVEL 5.85.0) # not ready yet for pedantic compilers set(KDE_SKIP_PEDANTIC_WARNINGS_SETTINGS TRUE) # avoid any Qt definitions set(KDE_QT_MODERNCODE_DEFINITIONS_LEVEL 5.84.0) include(KDECompilerSettings NO_POLICY_SCOPE) .. code-block:: cmake # needing some macro/feature only available with ECM 5.85.0 find_package(ECM 5.85.0 NO_MODULE) # requiring ECM 5.85.0 above will default KDE_COMPILERSETTINGS_LEVEL also to 5.85.0, # which again defaults KDE_QT_MODERNCODE_DEFINITIONS_LEVEL also to 5.85.0 include(KDECompilerSettings NO_POLICY_SCOPE) # project is fine with almost all added Qt definitions as of 5.85.0, but not these ones: remove_definitions( -DQT_NO_KEYWORDS -DQT_NO_FOREACH ) Since pre-1.0.0. #]=======================================================================] ############################################################ # Select and check KDE_COMPILERSETTINGS_LEVEL # For a specified version of KDE_COMPILERSETTINGS_LEVEL always the same set # of settings needs to be used, to give that version a meaning, even more as # the settings are usually more strict and can break builds which build fine # without the setting. # As at the time of version x it is usually unknown what future versions x+y # will offer as settings, the minimum required version of ECM sets the upper # limit then for the level version. if(NOT DEFINED KDE_COMPILERSETTINGS_LEVEL) set(KDE_INTERNAL_COMPILERSETTINGS_LEVEL "${ECM_GLOBAL_FIND_VERSION}") else() if(KDE_COMPILERSETTINGS_LEVEL VERSION_GREATER "${ECM_GLOBAL_FIND_VERSION}") message(FATAL_ERROR "KDE_COMPILERSETTINGS_LEVEL (${KDE_COMPILERSETTINGS_LEVEL}) cannot be newer than the min. required ECM version (${ECM_GLOBAL_FIND_VERSION}).") endif() set(KDE_INTERNAL_COMPILERSETTINGS_LEVEL "${KDE_COMPILERSETTINGS_LEVEL}") endif() include("${ECM_MODULE_DIR}/ECMSourceVersionControl.cmake") ############################################################ # Default build type # If no build type was specified, default to using a debug build if the # source directory is a git clone. # Otherwise, leave it empty, to let distro packagers choose the flags. ############################################################ if (ECM_SOURCE_UNDER_VERSION_CONTROL AND NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) set(default_build_type "Debug") message(STATUS "Setting build type to '${default_build_type}' as none was specified.") set_property(CACHE CMAKE_BUILD_TYPE PROPERTY VALUE "${default_build_type}") # Set the possible values of build type for cmake-gui set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo") endif() ############################################################ # Toolchain minimal requirements # # Note that only compilers officially supported by Qt are # supported by this file; workarounds for older compilers # will generally not be included. See # https://qt-project.org/doc/qt-5/supported-platforms.html # and # https://community.kde.org/Frameworks/Policies#Frameworks_compiler_requirements_and_C.2B.2B11 # for more details. ############################################################ macro(_kde_compiler_min_version min_version) if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${min_version}) message(WARNING "Version ${CMAKE_CXX_COMPILER_VERSION} of the ${CMAKE_CXX_COMPILER_ID} C++ compiler is not supported. Please use version ${min_version} or later.") endif() endmacro() if (MSVC) # MSVC_VERSION 1600 = VS 10.0 = Windows SDK 7 # See: cmake --help-variable MSVC_VERSION # and https://developer.mozilla.org/en-US/docs/Windows_SDK_versions if (${MSVC_VERSION} LESS 1600) message(WARNING "Your MSVC version (${MSVC_VERSION}) is not supported. Please use the Windows SDK version 7 or later (or Microsoft Visual Studio 2010 or later).") endif() elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") if (WIN32) _kde_compiler_min_version("4.7") elseif (APPLE) # FIXME: Apple heavily modifies GCC, so checking the # GCC version on OS/X is not very useful. else() _kde_compiler_min_version("4.5") endif() elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang") _kde_compiler_min_version("3.1") else() message(WARNING "${CMAKE_CXX_COMPILER_ID} is not a supported C++ compiler.") endif() ############################################################ # System API features ############################################################ # This macro is for adding definitions that affect the underlying # platform API. It makes sure that configure checks will also have # the same defines, so that the checks match compiled code. macro (_KDE_ADD_PLATFORM_DEFINITIONS) add_definitions(${ARGV}) set(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ${ARGV}) endmacro() include(CheckSymbolExists) check_symbol_exists("__GLIBC__" "stdlib.h" LIBC_IS_GLIBC) if (LIBC_IS_GLIBC) # Enable everything in GNU libc. Any code using non-portable features # needs to perform feature tests, but this ensures that any such features # will be found if they exist. # # NB: we do NOT define _BSD_SOURCE, as with GNU libc that requires linking # against the -lbsd-compat library (it changes the behaviour of some # functions). This, however, means that strlcat and strlcpy are not # provided by glibc. _kde_add_platform_definitions(-D_GNU_SOURCE) endif () if (UNIX) # Enable extra API for using 64-bit file offsets on 32-bit systems. # FIXME: this is included in _GNU_SOURCE in glibc; do other libc # implementation recognize it? _kde_add_platform_definitions(-D_LARGEFILE64_SOURCE) include(CheckCXXSourceCompiles) # By default (in glibc, at least), on 32bit platforms off_t is 32 bits, # which causes a SIGXFSZ when trying to manipulate files larger than 2Gb # using libc calls (note that this issue does not occur when using QFile). check_cxx_source_compiles(" #include /* Check that off_t can represent 2**63 - 1 correctly. We can't simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. */ #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; int main() { return 0; } " _OFFT_IS_64BIT) if (NOT _OFFT_IS_64BIT) _kde_add_platform_definitions(-D_FILE_OFFSET_BITS=64) endif () endif() if (WIN32) # Speeds up compile times by not including everything with windows.h # See http://msdn.microsoft.com/en-us/library/windows/desktop/aa383745%28v=vs.85%29.aspx _kde_add_platform_definitions(-DWIN32_LEAN_AND_MEAN) if (KDE_INTERNAL_COMPILERSETTINGS_LEVEL VERSION_GREATER_EQUAL 5.240.0 OR QT_MAJOR_VERSION STREQUAL "6") # Target Windows 10 # This enables various bits of new API # See http://msdn.microsoft.com/en-us/library/windows/desktop/aa383745%28v=vs.85%29.aspx # Windows 10 is the default by Qt6 hence we do not need the next line, but we keep it disabled # to not to start from scratch in case we want to target a different version in the future # _kde_add_platform_definitions(-D_WIN32_WINNT=0x0A00 -DWINVER=0x0A00 -D_WIN32_IE=0x0A00) else() # Target Windows Vista # This enables various bits of new API # See http://msdn.microsoft.com/en-us/library/windows/desktop/aa383745%28v=vs.85%29.aspx _kde_add_platform_definitions(-D_WIN32_WINNT=0x0600 -DWINVER=0x0600 -D_WIN32_IE=0x0600) endif() # Use the Unicode versions of Windows API by default # See http://msdn.microsoft.com/en-us/library/windows/desktop/dd317766%28v=vs.85%29.aspx _kde_add_platform_definitions(-DUNICODE -D_UNICODE) # As stated in http://msdn.microsoft.com/en-us/library/4hwaceh6.aspx M_PI only gets defined # if _USE_MATH_DEFINES is defined, with mingw this has a similar effect as -D_GNU_SOURCE on math.h _kde_add_platform_definitions(-D_USE_MATH_DEFINES) # Don't define MIN and MAX in windows.h # the defines break the use of std::max _kde_add_platform_definitions(-DNOMINMAX) endif() ############################################################ # Language and toolchain features ############################################################ # Pick sensible versions of the C and C++ standards. if (NOT CMAKE_C_STANDARD) if (KDE_INTERNAL_COMPILERSETTINGS_LEVEL VERSION_GREATER_EQUAL 5.85.0) set(CMAKE_C_STANDARD 99) set(CMAKE_C_STANDARD_REQUIRED TRUE) set(CMAKE_C_EXTENSIONS OFF) else() set(CMAKE_C_STANDARD 90) endif() endif() if (NOT CMAKE_CXX_STANDARD) if (KDE_INTERNAL_COMPILERSETTINGS_LEVEL VERSION_GREATER_EQUAL 5.85.0) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_EXTENSIONS OFF) else() set(CMAKE_CXX_STANDARD 11) endif() set(CMAKE_CXX_STANDARD_REQUIRED TRUE) endif() # Do not merge uninitialized global variables. # This is mostly a "principle of least surprise" thing, but also # has performance benefits. # See https://www.ibm.com/developerworks/community/blogs/zTPF/entry/benefits_of_the_fnocommon_compile_option_peter_lemieszewski?lang=en # Note that this only applies to C code; C++ already behaves like this. if (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang" OR (CMAKE_C_COMPILER_ID STREQUAL "Intel" AND NOT WIN32)) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-common") endif() # Do not treat the operator name keywords and, bitand, bitor, compl, not, or and xor as synonyms as keywords. # They're not supported under Visual Studio out of the box thus using them limits the portability of code if (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang" OR (CMAKE_C_COMPILER_ID STREQUAL "Intel" AND NOT WIN32)) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-operator-names") endif() # Default to hidden visibility for symbols set(CMAKE_C_VISIBILITY_PRESET hidden) set(CMAKE_CXX_VISIBILITY_PRESET hidden) set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) if (POLICY CMP0063) # No sane project should be affected by CMP0063, so suppress the warnings # generated by the above visibility settings in CMake >= 3.3 cmake_policy(SET CMP0063 NEW) endif() if (UNIX AND NOT APPLE AND NOT CYGWIN) # Enable adding DT_RUNPATH, which means that LD_LIBRARY_PATH takes precedence # over the built-in rPath set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_SHARED_LINKER_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_MODULE_LINKER_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "-Wl,--enable-new-dtags ${CMAKE_EXE_LINKER_FLAGS}") endif() if (CMAKE_SYSTEM_NAME STREQUAL GNU) # Enable multithreading with the pthread library # FIXME: Is this actually necessary to have here? # Can CMakeLists.txt files that require it use FindThreads.cmake # instead? set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pthread") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -pthread") endif() if (MSVC) # Our source files are UTF-8 encoded, and assuming that is also the # default behavior of GCC/Clang. Not so for MSVC though, so force # that to UTF-8 explicitly, as that will otherwise cause compile-time # and runtime issues when dealing with string literals outside of 7-bit ASCII. add_compile_options(/utf-8) endif() ############################################################ # Turn off exceptions by default # # This involves enough code to be separate from the # previous section. ############################################################ # TODO: Deal with QT_NO_EXCEPTIONS for non-gnu compilers? # This should be defined if and only if exceptions are disabled. # qglobal.h has some magic to set it when exceptions are disabled # with gcc, but other compilers are unaccounted for. # Turn off exceptions by default if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions") elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions") elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel" AND NOT WIN32) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions") #elseif (MSVC OR (WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "Intel")) # Exceptions appear to be disabled by default for MSVC # http://msdn.microsoft.com/en-us/library/1deeycx5.aspx # FIXME: are exceptions disabled by default for Intel? endif() macro(_kdecompilersettings_append_exception_flag VAR) if (MSVC) set(${VAR} "${${VAR}} -EHsc") elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel") if (WIN32) set(${VAR} "${${VAR}} -EHsc") else() set(${VAR} "${${VAR}} -fexceptions") endif() elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") set(${VAR} "${${VAR}} -fexceptions") elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(${VAR} "${${VAR}} -fexceptions") endif() string(STRIP "${${VAR}}" ${VAR}) endmacro() function(KDE_SOURCE_FILES_ENABLE_EXCEPTIONS) foreach(source_file ${ARGV}) get_source_file_property(flags ${source_file} COMPILE_FLAGS) if(NOT flags) # If COMPILE_FLAGS is not set, get_source_file_property() sets it to # NOTFOUND, which breaks build if we concatenate anything to # the "NOTFOUND" string. # Note that NOTFOUND evaluates to False, so we do enter the if. set(flags "") endif() _kdecompilersettings_append_exception_flag(flags) set_source_files_properties(${source_file} COMPILE_FLAGS "${flags}") endforeach() endfunction() function(KDE_TARGET_ENABLE_EXCEPTIONS target mode) target_compile_options(${target} ${mode} "$<$:-EHsc>") if (WIN32) target_compile_options(${target} ${mode} "$<$:-EHsc>") else() target_compile_options(${target} ${mode} "$<$:-fexceptions>") endif() target_compile_options(${target} ${mode} "$<$,$,$>:-fexceptions>") endfunction() function(KDE_ENABLE_EXCEPTIONS) # We set CMAKE_CXX_FLAGS, rather than add_compile_options(), because # we only want to affect the compilation of C++ source files. # strip any occurrences of -DQT_NO_EXCEPTIONS; this should only be defined # if exceptions are disabled # the extra spaces mean we will not accentially mangle any other options string(REPLACE " -DQT_NO_EXCEPTIONS " " " CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} ") # this option is common to several compilers, so just always remove it string(REPLACE " -fno-exceptions " " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") # strip undoes the extra spaces we put in above string(STRIP "${CMAKE_CXX_FLAGS}" CMAKE_CXX_FLAGS) _kdecompilersettings_append_exception_flag(CMAKE_CXX_FLAGS) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" PARENT_SCOPE) endfunction() ############################################################ # Better diagnostics (warnings, errors) ############################################################ if ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT APPLE) OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT APPLE) OR (CMAKE_CXX_COMPILER_ID STREQUAL "Intel" AND NOT WIN32)) # Linker warnings should be treated as errors set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings ${CMAKE_SHARED_LINKER_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings ${CMAKE_MODULE_LINKER_FLAGS}") string(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" compileflags) if("${CMAKE_CXX_FLAGS} ${${compileflags}}" MATCHES "-fsanitize") set(sanitizers_enabled TRUE) else() set(sanitizers_enabled FALSE) endif() # Do not allow undefined symbols, even in non-symbolic shared libraries # On OpenBSD we must disable this to allow the stuff to properly compile without explicit libc specification if (NOT CMAKE_SYSTEM_NAME MATCHES "OpenBSD" AND (NOT sanitizers_enabled OR NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")) set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined ${CMAKE_SHARED_LINKER_FLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--no-undefined ${CMAKE_MODULE_LINKER_FLAGS}") endif() endif() set(_KDE_GCC_COMMON_WARNING_FLAGS "-Wall -Wextra -Wcast-align -Wchar-subscripts -Wformat-security -Wno-long-long -Wpointer-arith -Wundef") if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") # -Wgnu-zero-variadic-macro-arguments (part of -pedantic) is triggered by every qCDebug() call and therefore results # in a lot of noise. This warning is only notifying us that clang is emulating the GCC behaviour # instead of the exact standard wording so we can safely ignore it set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-gnu-zero-variadic-macro-arguments") endif() if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_KDE_GCC_COMMON_WARNING_FLAGS} -Wmissing-format-attribute -Wwrite-strings") # Make some warnings errors set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=implicit-function-declaration") endif() if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_KDE_GCC_COMMON_WARNING_FLAGS} -Wnon-virtual-dtor -Woverloaded-virtual") # Make some warnings errors set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=return-type -Werror=init-self") if (KDE_INTERNAL_COMPILERSETTINGS_LEVEL VERSION_GREATER_EQUAL 5.96.0) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=undef") endif() elseif(MSVC) # similar to -Werror=return-type # https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4715?view=msvc-170 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /we4715") endif() if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 3.5)) # -Wvla: use of variable-length arrays (an extension to C++) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wvla") endif() if ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 5.0) OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 3.5)) include(CheckCXXCompilerFlag) check_cxx_compiler_flag(-Wdate-time HAVE_DATE_TIME) if (HAVE_DATE_TIME) # -Wdate-time: warn if we use __DATE__ or __TIME__ (we want to be able to reproduce the exact same binary) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wdate-time") endif() endif() if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 5.0.0) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsuggest-override -Wlogical-op" ) endif() endif() # -w1 turns on warnings and errors # FIXME: someone needs to have a closer look at the Intel compiler options if (CMAKE_C_COMPILER_ID STREQUAL "Intel" AND NOT WIN32) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -w1 -Wpointer-arith") endif() if (CMAKE_CXX_COMPILER_ID STREQUAL "Intel" AND NOT WIN32) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -w1 -Wpointer-arith") endif() if (MSVC) # enable linter like warnings including deprecation warnings # https://learn.microsoft.com/en-us/cpp/build/reference/compiler-option-warning-level?view=msvc-170 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3") # Disable warnings: # C4250: 'class1' : inherits 'class2::member' via dominance set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250") # C4251: 'identifier' : class 'type' needs to have dll-interface to be # used by clients of class 'type2' set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4251") # C4396: 'identifier' : 'function' the inline specifier cannot be used # when a friend declaration refers to a specialization of a # function template set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4396") # C4661: 'identifier' : no suitable definition provided for explicit # template instantiation request set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4661") if (CMAKE_CXX_STANDARD GREATER_EQUAL 11) # Ensure __cplusplus is correct, otherwise it defaults to 199711L which isn't true # https://docs.microsoft.com/en-us/cpp/build/reference/zc-cplusplus?view=msvc-160 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:__cplusplus") endif() endif() option(ENABLE_BSYMBOLICFUNCTIONS "Make use of -Bsymbolic-functions" OFF) if (ENABLE_BSYMBOLICFUNCTIONS) set(_SYMBOLIC_FUNCTIONS_COMPILER_OPTION "-Wl,-Bsymbolic-functions") list(APPEND CMAKE_REQUIRED_LIBRARIES "${_SYMBOLIC_FUNCTIONS_COMPILER_OPTION}") include(CheckCXXSourceCompiles) check_cxx_source_compiles( "int main () { return 0; }" BSYMBOLICFUNCTIONS_AVAILABLE ) list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "${_SYMBOLIC_FUNCTIONS_COMPILER_OPTION}") if (BSYMBOLICFUNCTIONS_AVAILABLE) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${_SYMBOLIC_FUNCTIONS_COMPILER_OPTION}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${_SYMBOLIC_FUNCTIONS_COMPILER_OPTION}") endif() endif() if (WIN32) # Disable deprecation warnings for some API # FIXME: do we really want this? add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS ) endif() if (APPLE) #full Single Unix Standard v3 (SUSv3) conformance (the Unix API) _kde_add_platform_definitions(-D_DARWIN_C_SOURCE) #Cocoa is unconditional since we only support OS X 10.6 and above _kde_add_platform_definitions(-DQT_MAC_USE_COCOA) endif() ############################################################ # Modern code ############################################################ function(_kde_set_default_skip_variable_by_min_ecm _var_name _ecm_version) if(NOT DEFINED ${_var_name}) if (KDE_INTERNAL_COMPILERSETTINGS_LEVEL VERSION_LESS ${_ecm_version}) set(${_var_name} TRUE PARENT_SCOPE) else() set(${_var_name} FALSE PARENT_SCOPE) endif() endif() endfunction() if(NOT DEFINED KDE_QT_MODERNCODE_DEFINITIONS_LEVEL) set(KDE_INTERNAL_QT_MODERNCODE_DEFINITIONS_LEVEL ${KDE_INTERNAL_COMPILERSETTINGS_LEVEL}) else() set(KDE_INTERNAL_QT_MODERNCODE_DEFINITIONS_LEVEL ${KDE_QT_MODERNCODE_DEFINITIONS_LEVEL}) endif() if (KDE_INTERNAL_QT_MODERNCODE_DEFINITIONS_LEVEL VERSION_GREATER_EQUAL "5.85.0") add_definitions( -DQT_NO_CAST_TO_ASCII -DQT_NO_CAST_FROM_ASCII -DQT_NO_URL_CAST_FROM_STRING -DQT_NO_CAST_FROM_BYTEARRAY -DQT_USE_QSTRINGBUILDER -DQT_NO_NARROWING_CONVERSIONS_IN_CONNECT -DQT_NO_KEYWORDS -DQT_NO_FOREACH ) if (NOT WIN32) # Strict iterators can't be used on Windows, they lead to a link error # when application code iterates over a QVector for instance, unless # Qt itself was also built with strict iterators. # See example at https://bugreports.qt.io/browse/AUTOSUITE-946 add_definitions(-DQT_STRICT_ITERATORS) endif() endif() _kde_set_default_skip_variable_by_min_ecm(KDE_SKIP_PEDANTIC_WARNINGS_SETTINGS "5.85.0") if (NOT KDE_SKIP_PEDANTIC_WARNINGS_SETTINGS) if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic") endif() endif() _kde_set_default_skip_variable_by_min_ecm(KDE_SKIP_NULLPTR_WARNINGS_SETTINGS "5.85.0") if (NOT KDE_SKIP_NULLPTR_WARNINGS_SETTINGS) if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "5.0.0") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wzero-as-null-pointer-constant" ) endif() endif() if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "5.0.0") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wzero-as-null-pointer-constant" ) endif() endif() endif() _kde_set_default_skip_variable_by_min_ecm(KDE_SKIP_MISSING_INCLUDE_DIRS_WARNINGS_SETTINGS "5.85.0") if (NOT KDE_SKIP_MISSING_INCLUDE_DIRS_WARNINGS_SETTINGS) if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wmissing-include-dirs") endif() endif() ############################################################ # Hacks # # Anything in this section should be thoroughly documented, # including what problems it is supposed to fix and in what # circumstances those problems occur. Include links to any # relevant bug reports. ############################################################ if (APPLE) # FIXME: why are these needed? The commit log is unhelpful # (it was introduced in svn path=/trunk/KDE/kdelibs/; revision=503025 - # kdelibs git commit 4e4cb9cb9a2216b63d3eabf88b8fe94ee3c898cf - # with the message "mac os x fixes for the cmake build") set (CMAKE_SHARED_LINKER_FLAGS "-single_module -multiply_defined suppress ${CMAKE_SHARED_LINKER_FLAGS}") set (CMAKE_MODULE_LINKER_FLAGS "-multiply_defined suppress ${CMAKE_MODULE_LINKER_FLAGS}") endif() if (MINGW AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU") # This was copied from the Phonon build settings, where it had the comment # "otherwise undefined symbol in phononcore.dll errors occurs", with the commit # message "set linker flag --export-all-symbols for all targets, otherwise # some depending targets could not be build" # FIXME: do our export macros not deal with this properly? set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--export-all-symbols") set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--export-all-symbols") endif() if (CMAKE_GENERATOR STREQUAL "Ninja" AND ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 4.9) OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 3.5))) # Force colored warnings in Ninja's output, if the compiler has -fdiagnostics-color support. # Rationale in https://github.com/ninja-build/ninja/issues/814 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=always") endif() include("${ECM_MODULE_DIR}/ECMEnableSanitizers.cmake") include("${ECM_MODULE_DIR}/ECMCoverageOption.cmake") ############################################################ # Clean-up ############################################################ # unset again, to not leak into caller scope and avoid usage there set(KDE_INTERNAL_COMPILERSETTINGS_LEVEL) set(KDE_INTERNAL_QT_MODERNCODE_DEFINITIONS_LEVEL) # SPDX-FileCopyrightText: 2013 Albert Astals Cid # SPDX-FileCopyrightText: 2007 Matthias Kretz # SPDX-FileCopyrightText: 2006-2007 Laurent Montel # SPDX-FileCopyrightText: 2006-2013 Alex Neundorf # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[ Backward-compatibility support ------------------------------ For all the non-KF projects which reused the KDEFrameworkCompilerSettings module to get more strict settings. Kept as is, to be removed on next backward-compatibility-breakage occasion. #]=======================================================================] if (NOT CMAKE_CXX_STANDARD) if (ECM_GLOBAL_FIND_VERSION VERSION_GREATER_EQUAL 5.84.0) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) endif() endif() include(KDECompilerSettings NO_POLICY_SCOPE) add_definitions(-DQT_NO_CAST_TO_ASCII -DQT_NO_CAST_FROM_ASCII -DQT_NO_URL_CAST_FROM_STRING -DQT_NO_CAST_FROM_BYTEARRAY -DQT_USE_QSTRINGBUILDER -DQT_NO_NARROWING_CONVERSIONS_IN_CONNECT ) if (NOT WIN32) # Strict iterators can't be used on Windows, they lead to a link error # when application code iterates over a QVector for instance, unless # Qt itself was also built with strict iterators. # See example at https://bugreports.qt.io/browse/AUTOSUITE-946 add_definitions(-DQT_STRICT_ITERATORS) endif() # Some non-KF projects make (ab)use of KDEFrameworkCompilerSettings currently, # let them only hit this as well when bumping their min. ECM requirement to a newer version. if (ECM_GLOBAL_FIND_VERSION VERSION_GREATER_EQUAL 5.79.0) add_definitions( -DQT_NO_KEYWORDS -DQT_NO_FOREACH ) else() add_definitions(-DQT_NO_SIGNALS_SLOTS_KEYWORDS) endif() add_definitions( -DQT_DEPRECATED_WARNINGS_SINCE=0x060000 -DKF_DEPRECATED_WARNINGS_SINCE=0x060000 ) if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic") endif() if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 5.0.0) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wzero-as-null-pointer-constant" ) endif() endif() if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 5.0.0) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wzero-as-null-pointer-constant" ) endif() endif() if (ECM_GLOBAL_FIND_VERSION VERSION_GREATER_EQUAL 5.80.0) include(KDEClangFormat) # add clang-format target file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h *.hpp *.c) kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES}) endif () # SPDX-FileCopyrightText: 2013 Albert Astals Cid # SPDX-FileCopyrightText: 2007 Matthias Kretz # SPDX-FileCopyrightText: 2006-2007 Laurent Montel # SPDX-FileCopyrightText: 2006-2013 Alex Neundorf # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: KDEFrameworkCompilerSettings ---------------------------- Set stricter compile and link flags for KDE Frameworks modules. .. warning:: Do not use this module for software which is not part of KDE-Frameworks. There is no guarantee for backward-compatibility in newer versions. The :kde-module:`KDECompilerSettings` module is included and, in addition, various defines that affect the Qt libraries are set to enforce certain conventions. For example, constructions like ``QString("foo")`` are prohibited, instead forcing the use of QLatin1String or QStringLiteral, and some Qt-defined keywords like signals and slots will not be defined. .. note:: It is recommended to include this module with the NO_POLICY_SCOPE flag, otherwise you may get spurious warnings with some versions of CMake. Since pre-1.0.0. #]=======================================================================] # No-one else should be using this module, at least by the time when requiring # ECM 5.85 as minimum, where also settings levels had been introduced for # KDECompilerSettings to satisfy the needs for stricter out-of-the-box # settings. # So making a clear cut here by that condition and providing backward-compat # support from a separate file with the old code, avoiding the need for # further if()-else() when changing the settings for current KDE Frameworks. if (ECM_GLOBAL_FIND_VERSION VERSION_LESS 5.85.0) include(KDEFrameworkCompilerLegacySettings NO_POLICY_SCOPE) return() endif() # set ENABLE_BSYMBOLICFUNCTIONS default to ON when possible # TODO: find a nice way to set an option default # we can only use symbolic functions when everything is built with that # otherwise we'll break function pointer based connects and method lookups include(${CMAKE_CURRENT_LIST_DIR}/../modules/QtVersionOption.cmake) if (QT_MAJOR_VERSION EQUAL "6") find_package(Qt6Core) set(ENABLE_BSYMBOLICFUNCTIONS ${QT_FEATURE_reduce_relocations}) set(CMAKE_CXX_STANDARD 20) set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_CXX_STANDARD_REQUIRED TRUE) else () set(ENABLE_BSYMBOLICFUNCTIONS ON) endif() # Current defaults include(KDECompilerSettings NO_POLICY_SCOPE) # add clang-format target include(KDEClangFormat) file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h *.hpp *.c) kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES}) # add the metainfo platform check include(KDEMetaInfoPlatformCheck) # SPDX-FileCopyrightText: 2020-2023 Alexander Lohnau # SPDX-FileCopyrightText: 2022 Ahmad Samir # SPDX-FileCopyrightText: 2023 Johannes Zarl-Zierl # # SPDX-License-Identifier: BSD-3-Clause #[=======================================================================[.rst: KDEGitCommitHooks -------------------- This module provides a functionality to enforce formatting or in the future other QS checks. This module provides the following function: :: kde_configure_git_pre_commit_hook( CHECKS [ [...] [CUSTOM_SCRIPTS [