| #============================================================================= |
| # Copyright 2005-2011 Kitware, Inc. |
| # Copyright (C) 2020 The Qt Company Ltd. |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # |
| # * Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # |
| # * Neither the name of Kitware, Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived |
| # from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| #============================================================================= |
| |
| ###################################### |
| # |
| # Macros for building Qt files |
| # |
| ###################################### |
| |
| include(CMakeParseArguments) |
| |
| function(_qt5_warn_deprecated command_name) |
| if(NOT DEFINED _QT5_INTERNAL_SCOPE) |
| message(AUTHOR_WARNING |
| "${command_name} is not part of the official API, and might be removed in Qt 6.") |
| endif() |
| endfunction() |
| |
| # macro used to create the names of output files preserving relative dirs |
| macro(qt5_make_output_file infile prefix ext outfile ) |
| _qt5_warn_deprecated("qt5_make_output_file") |
| |
| string(LENGTH ${CMAKE_CURRENT_BINARY_DIR} _binlength) |
| string(LENGTH ${infile} _infileLength) |
| set(_checkinfile ${CMAKE_CURRENT_SOURCE_DIR}) |
| if(_infileLength GREATER _binlength) |
| string(SUBSTRING "${infile}" 0 ${_binlength} _checkinfile) |
| if(_checkinfile STREQUAL "${CMAKE_CURRENT_BINARY_DIR}") |
| file(RELATIVE_PATH rel ${CMAKE_CURRENT_BINARY_DIR} ${infile}) |
| else() |
| file(RELATIVE_PATH rel ${CMAKE_CURRENT_SOURCE_DIR} ${infile}) |
| endif() |
| else() |
| file(RELATIVE_PATH rel ${CMAKE_CURRENT_SOURCE_DIR} ${infile}) |
| endif() |
| if(CMAKE_HOST_WIN32 AND rel MATCHES "^([a-zA-Z]):(.*)$") # absolute path |
| set(rel "${CMAKE_MATCH_1}_${CMAKE_MATCH_2}") |
| endif() |
| set(_outfile "${CMAKE_CURRENT_BINARY_DIR}/${rel}") |
| string(REPLACE ".." "__" _outfile ${_outfile}) |
| get_filename_component(outpath ${_outfile} PATH) |
| if(CMAKE_VERSION VERSION_LESS "3.14") |
| get_filename_component(_outfile_ext ${_outfile} EXT) |
| get_filename_component(_outfile_ext ${_outfile_ext} NAME_WE) |
| get_filename_component(_outfile ${_outfile} NAME_WE) |
| string(APPEND _outfile ${_outfile_ext}) |
| else() |
| get_filename_component(_outfile ${_outfile} NAME_WLE) |
| endif() |
| file(MAKE_DIRECTORY ${outpath}) |
| set(${outfile} ${outpath}/${prefix}${_outfile}.${ext}) |
| endmacro() |
| |
| |
| macro(qt5_get_moc_flags _moc_flags) |
| _qt5_warn_deprecated("qt5_get_moc_flags") |
| |
| set(${_moc_flags}) |
| get_directory_property(_inc_DIRS INCLUDE_DIRECTORIES) |
| |
| if(CMAKE_INCLUDE_CURRENT_DIR) |
| list(APPEND _inc_DIRS ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) |
| endif() |
| |
| foreach(_current ${_inc_DIRS}) |
| if("${_current}" MATCHES "\\.framework/?$") |
| string(REGEX REPLACE "/[^/]+\\.framework" "" framework_path "${_current}") |
| set(${_moc_flags} ${${_moc_flags}} "-F${framework_path}") |
| else() |
| set(${_moc_flags} ${${_moc_flags}} "-I${_current}") |
| endif() |
| endforeach() |
| |
| get_directory_property(_defines COMPILE_DEFINITIONS) |
| foreach(_current ${_defines}) |
| set(${_moc_flags} ${${_moc_flags}} "-D${_current}") |
| endforeach() |
| |
| if(WIN32) |
| set(${_moc_flags} ${${_moc_flags}} -DWIN32) |
| endif() |
| if (MSVC) |
| set(${_moc_flags} ${${_moc_flags}} --compiler-flavor=msvc) |
| endif() |
| endmacro() |
| |
| |
| # helper macro to set up a moc rule |
| function(qt5_create_moc_command infile outfile moc_flags moc_options moc_target moc_depends) |
| _qt5_warn_deprecated("qt5_create_moc_command") |
| |
| # Pass the parameters in a file. Set the working directory to |
| # be that containing the parameters file and reference it by |
| # just the file name. This is necessary because the moc tool on |
| # MinGW builds does not seem to handle spaces in the path to the |
| # file given with the @ syntax. |
| get_filename_component(_moc_outfile_name "${outfile}" NAME) |
| get_filename_component(_moc_outfile_dir "${outfile}" PATH) |
| if(_moc_outfile_dir) |
| set(_moc_working_dir WORKING_DIRECTORY ${_moc_outfile_dir}) |
| endif() |
| set (_moc_parameters_file ${outfile}_parameters) |
| set (_moc_parameters ${moc_flags} ${moc_options} -o "${outfile}" "${infile}") |
| string (REPLACE ";" "\n" _moc_parameters "${_moc_parameters}") |
| |
| if(moc_target) |
| set(_moc_parameters_file ${_moc_parameters_file}$<$<BOOL:$<CONFIGURATION>>:_$<CONFIGURATION>>) |
| set(targetincludes "$<TARGET_PROPERTY:${moc_target},INCLUDE_DIRECTORIES>") |
| set(targetdefines "$<TARGET_PROPERTY:${moc_target},COMPILE_DEFINITIONS>") |
| |
| set(targetincludes "$<$<BOOL:${targetincludes}>:-I$<JOIN:${targetincludes},\n-I>\n>") |
| set(targetdefines "$<$<BOOL:${targetdefines}>:-D$<JOIN:${targetdefines},\n-D>\n>") |
| |
| file (GENERATE |
| OUTPUT ${_moc_parameters_file} |
| CONTENT "${targetdefines}${targetincludes}${_moc_parameters}\n" |
| ) |
| |
| set(targetincludes) |
| set(targetdefines) |
| else() |
| file(WRITE ${_moc_parameters_file} "${_moc_parameters}\n") |
| endif() |
| |
| set(_moc_extra_parameters_file @${_moc_parameters_file}) |
| add_custom_command(OUTPUT ${outfile} |
| COMMAND ${Qt5Core_MOC_EXECUTABLE} ${_moc_extra_parameters_file} |
| DEPENDS ${infile} ${moc_depends} |
| ${_moc_working_dir} |
| VERBATIM) |
| set_source_files_properties(${infile} PROPERTIES SKIP_AUTOMOC ON) |
| set_source_files_properties(${outfile} PROPERTIES SKIP_AUTOMOC ON) |
| set_source_files_properties(${outfile} PROPERTIES SKIP_AUTOUIC ON) |
| endfunction() |
| |
| |
| function(qt5_generate_moc infile outfile ) |
| set(_QT5_INTERNAL_SCOPE ON) |
| |
| # get include dirs and flags |
| qt5_get_moc_flags(moc_flags) |
| get_filename_component(abs_infile ${infile} ABSOLUTE) |
| set(_outfile "${outfile}") |
| if(NOT IS_ABSOLUTE "${outfile}") |
| set(_outfile "${CMAKE_CURRENT_BINARY_DIR}/${outfile}") |
| endif() |
| if ("x${ARGV2}" STREQUAL "xTARGET") |
| set(moc_target ${ARGV3}) |
| endif() |
| qt5_create_moc_command(${abs_infile} ${_outfile} "${moc_flags}" "" "${moc_target}" "") |
| endfunction() |
| |
| if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) |
| function(qt_generate_moc) |
| if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) |
| qt5_generate_moc(${ARGV}) |
| elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) |
| qt6_generate_moc(${ARGV}) |
| endif() |
| endfunction() |
| endif() |
| |
| |
| # qt5_wrap_cpp(outfiles inputfile ... ) |
| |
| function(qt5_wrap_cpp outfiles) |
| set(_QT5_INTERNAL_SCOPE ON) |
| |
| # get include dirs |
| qt5_get_moc_flags(moc_flags) |
| |
| set(options) |
| set(oneValueArgs TARGET) |
| set(multiValueArgs OPTIONS DEPENDS) |
| |
| cmake_parse_arguments(_WRAP_CPP "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) |
| |
| set(moc_files ${_WRAP_CPP_UNPARSED_ARGUMENTS}) |
| set(moc_options ${_WRAP_CPP_OPTIONS}) |
| set(moc_target ${_WRAP_CPP_TARGET}) |
| set(moc_depends ${_WRAP_CPP_DEPENDS}) |
| |
| foreach(it ${moc_files}) |
| get_filename_component(it ${it} ABSOLUTE) |
| qt5_make_output_file(${it} moc_ cpp outfile) |
| qt5_create_moc_command(${it} ${outfile} "${moc_flags}" "${moc_options}" "${moc_target}" "${moc_depends}") |
| list(APPEND ${outfiles} ${outfile}) |
| endforeach() |
| set(${outfiles} ${${outfiles}} PARENT_SCOPE) |
| endfunction() |
| |
| # This will override the CMake upstream command, because that one is for Qt 3. |
| if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) |
| function(qt_wrap_cpp outfiles) |
| if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) |
| qt5_wrap_cpp("${outfiles}" ${ARGN}) |
| elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) |
| qt6_wrap_cpp("${outfiles}" ${ARGN}) |
| endif() |
| set("${outfiles}" "${${outfiles}}" PARENT_SCOPE) |
| endfunction() |
| endif() |
| |
| |
| # _qt5_parse_qrc_file(infile _out_depends _rc_depends) |
| # internal |
| |
| function(_qt5_parse_qrc_file infile _out_depends _rc_depends) |
| get_filename_component(rc_path ${infile} PATH) |
| |
| if(EXISTS "${infile}") |
| # parse file for dependencies |
| # all files are absolute paths or relative to the location of the qrc file |
| file(READ "${infile}" RC_FILE_CONTENTS) |
| string(REGEX MATCHALL "<file[^<]+" RC_FILES "${RC_FILE_CONTENTS}") |
| foreach(RC_FILE ${RC_FILES}) |
| string(REGEX REPLACE "^<file[^>]*>" "" RC_FILE "${RC_FILE}") |
| if(NOT IS_ABSOLUTE "${RC_FILE}") |
| set(RC_FILE "${rc_path}/${RC_FILE}") |
| endif() |
| set(RC_DEPENDS ${RC_DEPENDS} "${RC_FILE}") |
| endforeach() |
| # Since this cmake macro is doing the dependency scanning for these files, |
| # let's make a configured file and add it as a dependency so cmake is run |
| # again when dependencies need to be recomputed. |
| qt5_make_output_file("${infile}" "" "qrc.depends" out_depends) |
| configure_file("${infile}" "${out_depends}" COPYONLY) |
| else() |
| # The .qrc file does not exist (yet). Let's add a dependency and hope |
| # that it will be generated later |
| set(out_depends) |
| endif() |
| |
| set(${_out_depends} ${out_depends} PARENT_SCOPE) |
| set(${_rc_depends} ${RC_DEPENDS} PARENT_SCOPE) |
| endfunction() |
| |
| |
| # qt5_add_binary_resources(target inputfiles ... ) |
| |
| function(qt5_add_binary_resources target) |
| set(_QT5_INTERNAL_SCOPE ON) |
| |
| set(options) |
| set(oneValueArgs DESTINATION) |
| set(multiValueArgs OPTIONS) |
| |
| cmake_parse_arguments(_RCC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) |
| |
| set(rcc_files ${_RCC_UNPARSED_ARGUMENTS}) |
| set(rcc_options ${_RCC_OPTIONS}) |
| set(rcc_destination ${_RCC_DESTINATION}) |
| |
| if(NOT rcc_destination) |
| set(rcc_destination ${CMAKE_CURRENT_BINARY_DIR}/${target}.rcc) |
| endif() |
| |
| foreach(it ${rcc_files}) |
| get_filename_component(infile ${it} ABSOLUTE) |
| |
| _qt5_parse_qrc_file(${infile} _out_depends _rc_depends) |
| set_source_files_properties(${infile} PROPERTIES SKIP_AUTORCC ON) |
| set(infiles ${infiles} ${infile}) |
| set(out_depends ${out_depends} ${_out_depends}) |
| set(rc_depends ${rc_depends} ${_rc_depends}) |
| endforeach() |
| |
| add_custom_command(OUTPUT ${rcc_destination} |
| COMMAND ${Qt5Core_RCC_EXECUTABLE} |
| ARGS ${rcc_options} --binary --name ${target} --output ${rcc_destination} ${infiles} |
| DEPENDS ${rc_depends} ${out_depends} ${infiles} VERBATIM) |
| add_custom_target(${target} ALL DEPENDS ${rcc_destination}) |
| endfunction() |
| |
| if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) |
| function(qt_add_binary_resources) |
| if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) |
| qt5_add_binary_resources(${ARGV}) |
| elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) |
| qt6_add_binary_resources(${ARGV}) |
| endif() |
| endfunction() |
| endif() |
| |
| |
| # qt5_add_resources(outfiles inputfile ... ) |
| |
| function(qt5_add_resources outfiles) |
| set(_QT5_INTERNAL_SCOPE ON) |
| |
| set(options) |
| set(oneValueArgs) |
| set(multiValueArgs OPTIONS) |
| |
| cmake_parse_arguments(_RCC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) |
| |
| set(rcc_files ${_RCC_UNPARSED_ARGUMENTS}) |
| set(rcc_options ${_RCC_OPTIONS}) |
| |
| if("${rcc_options}" MATCHES "-binary") |
| message(WARNING "Use qt5_add_binary_resources for binary option") |
| endif() |
| |
| foreach(it ${rcc_files}) |
| get_filename_component(outfilename ${it} NAME_WE) |
| get_filename_component(infile ${it} ABSOLUTE) |
| set(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.cpp) |
| |
| _qt5_parse_qrc_file(${infile} _out_depends _rc_depends) |
| set_source_files_properties(${infile} PROPERTIES SKIP_AUTORCC ON) |
| |
| add_custom_command(OUTPUT ${outfile} |
| COMMAND ${Qt5Core_RCC_EXECUTABLE} |
| ARGS ${rcc_options} --name ${outfilename} --output ${outfile} ${infile} |
| MAIN_DEPENDENCY ${infile} |
| DEPENDS ${_rc_depends} "${_out_depends}" VERBATIM) |
| set_source_files_properties(${outfile} PROPERTIES SKIP_AUTOMOC ON) |
| set_source_files_properties(${outfile} PROPERTIES SKIP_AUTOUIC ON) |
| list(APPEND ${outfiles} ${outfile}) |
| endforeach() |
| set(${outfiles} ${${outfiles}} PARENT_SCOPE) |
| endfunction() |
| |
| if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) |
| function(qt_add_resources outfiles) |
| if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) |
| qt5_add_resources("${outfiles}" ${ARGN}) |
| elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) |
| qt6_add_resources("${outfiles}" ${ARGN}) |
| endif() |
| set("${outfiles}" "${${outfiles}}" PARENT_SCOPE) |
| endfunction() |
| endif() |
| |
| |
| # qt5_add_big_resources(outfiles inputfile ... ) |
| |
| function(qt5_add_big_resources outfiles) |
| set(_QT5_INTERNAL_SCOPE ON) |
| |
| if (CMAKE_VERSION VERSION_LESS 3.9) |
| message(FATAL_ERROR, "qt5_add_big_resources requires CMake 3.9 or newer") |
| endif() |
| |
| set(options) |
| set(oneValueArgs) |
| set(multiValueArgs OPTIONS) |
| |
| cmake_parse_arguments(_RCC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) |
| |
| set(rcc_files ${_RCC_UNPARSED_ARGUMENTS}) |
| set(rcc_options ${_RCC_OPTIONS}) |
| |
| if("${rcc_options}" MATCHES "-binary") |
| message(WARNING "Use qt5_add_binary_resources for binary option") |
| endif() |
| |
| foreach(it ${rcc_files}) |
| get_filename_component(outfilename ${it} NAME_WE) |
| get_filename_component(infile ${it} ABSOLUTE) |
| set(tmpoutfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}tmp.cpp) |
| set(outfile ${CMAKE_CURRENT_BINARY_DIR}/qrc_${outfilename}.o) |
| |
| _qt5_parse_qrc_file(${infile} _out_depends _rc_depends) |
| set_source_files_properties(${infile} PROPERTIES SKIP_AUTORCC ON) |
| add_custom_command(OUTPUT ${tmpoutfile} |
| COMMAND ${Qt5Core_RCC_EXECUTABLE} ${rcc_options} --name ${outfilename} --pass 1 --output ${tmpoutfile} ${infile} |
| DEPENDS ${infile} ${_rc_depends} "${out_depends}" VERBATIM) |
| add_custom_target(big_resources_${outfilename} ALL DEPENDS ${tmpoutfile}) |
| add_library(rcc_object_${outfilename} OBJECT ${tmpoutfile}) |
| set_target_properties(rcc_object_${outfilename} PROPERTIES AUTOMOC OFF) |
| set_target_properties(rcc_object_${outfilename} PROPERTIES AUTOUIC OFF) |
| add_dependencies(rcc_object_${outfilename} big_resources_${outfilename}) |
| # The modification of TARGET_OBJECTS needs the following change in cmake |
| # https://gitlab.kitware.com/cmake/cmake/commit/93c89bc75ceee599ba7c08b8fe1ac5104942054f |
| add_custom_command(OUTPUT ${outfile} |
| COMMAND ${Qt5Core_RCC_EXECUTABLE} |
| ARGS ${rcc_options} --name ${outfilename} --pass 2 --temp $<TARGET_OBJECTS:rcc_object_${outfilename}> --output ${outfile} ${infile} |
| DEPENDS rcc_object_${outfilename} $<TARGET_OBJECTS:rcc_object_${outfilename}> |
| VERBATIM) |
| list(APPEND ${outfiles} ${outfile}) |
| endforeach() |
| set(${outfiles} ${${outfiles}} PARENT_SCOPE) |
| endfunction() |
| |
| if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) |
| function(qt_add_big_resources outfiles) |
| if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) |
| qt5_add_big_resources(${outfiles} ${ARGN}) |
| elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) |
| qt6_add_big_resources(${outfiles} ${ARGN}) |
| endif() |
| set("${outfiles}" "${${outfiles}}" PARENT_SCOPE) |
| endfunction() |
| endif() |
| |
| |
| set(_Qt5_COMPONENT_PATH "${CMAKE_CURRENT_LIST_DIR}/..") |
| |
| macro(qt5_use_modules _target _link_type) |
| _qt5_warn_deprecated("qt5_use_modules") |
| |
| if (NOT TARGET ${_target}) |
| message(FATAL_ERROR "The first argument to qt5_use_modules must be an existing target.") |
| endif() |
| if ("${_link_type}" STREQUAL "LINK_PUBLIC" OR "${_link_type}" STREQUAL "LINK_PRIVATE" ) |
| set(_qt5_modules ${ARGN}) |
| set(_qt5_link_type ${_link_type}) |
| else() |
| set(_qt5_modules ${_link_type} ${ARGN}) |
| endif() |
| |
| if ("${_qt5_modules}" STREQUAL "") |
| message(FATAL_ERROR "qt5_use_modules requires at least one Qt module to use.") |
| endif() |
| |
| foreach(_module ${_qt5_modules}) |
| if (NOT Qt5${_module}_FOUND) |
| find_package(Qt5${_module} PATHS "${_Qt5_COMPONENT_PATH}" NO_DEFAULT_PATH) |
| if (NOT Qt5${_module}_FOUND) |
| message(FATAL_ERROR "Cannot use \"${_module}\" module which has not yet been found.") |
| endif() |
| endif() |
| target_link_libraries(${_target} ${_qt5_link_type} ${Qt5${_module}_LIBRARIES}) |
| set_property(TARGET ${_target} APPEND PROPERTY INCLUDE_DIRECTORIES ${Qt5${_module}_INCLUDE_DIRS}) |
| set_property(TARGET ${_target} APPEND PROPERTY COMPILE_DEFINITIONS ${Qt5${_module}_COMPILE_DEFINITIONS}) |
| set_property(TARGET ${_target} APPEND PROPERTY COMPILE_DEFINITIONS_RELEASE QT_NO_DEBUG) |
| set_property(TARGET ${_target} APPEND PROPERTY COMPILE_DEFINITIONS_RELWITHDEBINFO QT_NO_DEBUG) |
| set_property(TARGET ${_target} APPEND PROPERTY COMPILE_DEFINITIONS_MINSIZEREL QT_NO_DEBUG) |
| if (Qt5_POSITION_INDEPENDENT_CODE |
| AND (NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU" |
| OR CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)) |
| set_property(TARGET ${_target} PROPERTY POSITION_INDEPENDENT_CODE ${Qt5_POSITION_INDEPENDENT_CODE}) |
| endif() |
| endforeach() |
| endmacro() |
| |
| function(qt5_import_plugins TARGET_NAME) |
| set(_doing "") |
| foreach(_arg ${ARGN}) |
| if(_arg STREQUAL "INCLUDE") |
| set(_doing "INCLUDE") |
| elseif(_arg STREQUAL "EXCLUDE") |
| set(_doing "EXCLUDE") |
| elseif(_arg STREQUAL "INCLUDE_BY_TYPE") |
| set(_doing "INCLUDE_BY_TYPE") |
| elseif(_arg STREQUAL "EXCLUDE_BY_TYPE") |
| set(_doing "EXCLUDE_BY_TYPE") |
| else() |
| if(_doing STREQUAL "INCLUDE") |
| set_property(TARGET ${TARGET_NAME} APPEND PROPERTY QT_PLUGINS "${_arg}") |
| elseif(_doing STREQUAL "EXCLUDE") |
| set_property(TARGET ${TARGET_NAME} APPEND PROPERTY QT_NO_PLUGINS "${_arg}") |
| elseif(_doing STREQUAL "INCLUDE_BY_TYPE") |
| string(REGEX REPLACE "[-/]" "_" _plugin_type "${_arg}") |
| set(_doing "INCLUDE_BY_TYPE_PLUGINS") |
| elseif(_doing STREQUAL "INCLUDE_BY_TYPE_PLUGINS") |
| set_property(TARGET ${TARGET_NAME} APPEND PROPERTY "QT_PLUGINS_${_plugin_type}" "${_arg}") |
| elseif(_doing STREQUAL "EXCLUDE_BY_TYPE") |
| string(REGEX REPLACE "[-/]" "_" _plugin_type "${_arg}") |
| set_property(TARGET ${TARGET_NAME} PROPERTY "QT_PLUGINS_${_plugin_type}" -) |
| else() |
| message(FATAL_ERROR "Unexpected extra argument: \"${_arg}\"") |
| endif() |
| endif() |
| endforeach() |
| endfunction() |
| |
| if(NOT QT_NO_CREATE_VERSIONLESS_FUNCTIONS) |
| function(qt_import_plugins) |
| if(QT_DEFAULT_MAJOR_VERSION EQUAL 5) |
| qt5_import_plugins(${ARGV}) |
| elseif(QT_DEFAULT_MAJOR_VERSION EQUAL 6) |
| qt6_import_plugins(${ARGV}) |
| endif() |
| endfunction() |
| endif() |
