2 @defgroup module Module CMake APIs
3 @defgroup module-
internal Module Internal CMake APIs
4 @defgroup module-
impl Module Implementation CMake APIs
5 @defgroup module-support Module Support CMake APIs
10 @page module-api-overview Module API
12 This module includes functions to find and build VTK modules. A module is a set
13 of related functionality. These are then compiled together into libraries at
14 the
"kit" level. Each module may be
enabled or disabled individually and its
15 dependencies will be built as needed.
17 All functions strictly check their arguments. Any unrecognized or invalid
18 values
for a
function cause errors to be raised.
22 @ingroup module-
internal
23 @page module-
internal-api Internal API
25 The VTK module system provides some API functions
for use by other code which
26 consumes VTK modules (primarily
language wrappers). This file documents these
27 APIs. They may start with `_vtk_module`, but they are intended
for use in cases
28 of
language wrappers or dealing with trickier third party packages.
33 @page module-
impl-api Implementation API
35 These functions are purely
internal implementation details. No guarantees are
36 made
for them and they may change at any
time (including wrapping code calls).
37 Note that these functions are usually very lax in their argument parsing.
41 @ingroup module-
internal
42 @brief Conditionally output debug statements
45 controlled by the `_vtk_module_log` variable which contains a list of
"domains"
52 If the `domain` is
enabled for debugging, the `format` argument is configured
53 and printed. It should contain `@` variable expansions to replace rather than
54 it being done outside. This helps to avoid the cost of generating large strings
55 when debugging is disabled.
58 if (NOT _vtk_module_log STREQUAL
"ALL" AND
59 NOT domain IN_LIST _vtk_module_log)
63 string(CONFIGURE "${format}
" _vtk_module_debug_msg)
64 if (_vtk_module_debug_msg)
66 "VTK module debug ${domain}: ${_vtk_module_debug_msg}
")
70 # TODO: Support finding `vtk.module` and `vtk.kit` contents in the
71 # `CMakeLists.txt` files for the module via a comment header.
75 @brief Find `vtk.kit` files in a set of directories
78 vtk_module_find_kits(<output> [<directory>...])
81 This scans the given directories recursively for `vtk.kit` files and put the
82 paths into the output variable.
84 function (vtk_module_find_kits output)
85 set(_vtk_find_kits_all)
86 foreach (_vtk_find_kits_directory IN LISTS ARGN)
87 file(GLOB_RECURSE _vtk_find_kits_kits
88 "${_vtk_find_kits_directory}/
vtk.kit
")
89 list(APPEND _vtk_find_kits_all
90 ${_vtk_find_kits_kits})
92 set("${output}
" ${_vtk_find_kits_all} PARENT_SCOPE)
97 @brief Find `vtk.module` files in a set of directories
100 vtk_module_find_modules(<output> [<directory>...])
103 This scans the given directories recursively for `vtk.module` files and put the
104 paths into the output variable. Note that module files are assumed to live next
105 to the `CMakeLists.txt` file which will build the module.
107 function (vtk_module_find_modules output)
108 set(_vtk_find_modules_all)
109 foreach (_vtk_find_modules_directory IN LISTS ARGN)
110 file(GLOB_RECURSE _vtk_find_modules_modules
111 "${_vtk_find_modules_directory}/
vtk.module
")
112 list(APPEND _vtk_find_modules_all
113 ${_vtk_find_modules_modules})
115 set("${output}
" ${_vtk_find_modules_all} PARENT_SCOPE)
119 @ingroup module-internal
120 @brief Split a module name into a namespace and target component
122 Module names may include a namespace. This function splits the name into a
123 namespace and target name part.
126 _vtk_module_split_module_name(<name> <prefix>)
129 The `<prefix>_NAMESPACE` and `<prefix>_TARGET_NAME` variables will be set in
132 function (_vtk_module_split_module_name name prefix)
133 string(FIND "${
name}
" "::
" namespace_pos)
134 if (namespace_pos EQUAL -1)
136 set(target_name "${
name}
")
138 string(SUBSTRING "${
name}
" 0 "${namespace_pos}
" namespace)
139 math(EXPR name_pos "${namespace_pos} + 2
")
140 string(SUBSTRING "${
name}
" "${name_pos}
" -1 target_name)
143 set("${prefix}_NAMESPACE
"
146 set("${prefix}_TARGET_NAME
"
153 @page module-overview Module overview
155 @section module-parse-module vtk.module file contents
157 The `vtk.module` file is parsed and used as arguments to a CMake function which
158 stores information about the module for use when building it. Note that no
159 variable expansion is allowed and it is not CMake code, so no control flow is
160 allowed. Comments are supported and any content after a `#` on a line is
161 treated as a comment. Due to the breakdown of the content, quotes are not
162 meaningful within the files.
172 The base VTK library.
182 All values are optional unless otherwise noted. The following arguments are
185 * `NAME`: (Required) The name of the module.
186 * `LIBRARY_NAME`: The base name of the library file. It defaults to the
187 module name, but any namespaces are removed. For example, a `NS::Foo`
188 module will have a default `LIBRARY_NAME` of `Foo`.
189 * `DESCRIPTION`: (Recommended) Short text describing what the module is for.
190 * `KIT`: The name of the kit the module belongs to (see `Kits files` for more
192 * `IMPLEMENTABLE`: If present, the module contains logic which supports the
193 autoinit functionality.
194 * `GROUPS`: Modules may belong to "groups
" which is exposed as a build
195 option. This allows for enabling a set of modules with a single build
197 * `CONDITION`: Arguments to CMake's `if` command which may be used to hide
198 the module for certain platforms or other reasons. If the expression is
199 false, the module is completely ignored.
200 * `DEPENDS`: A list of modules which are required by this module and modules
202 * `PRIVATE_DEPENDS`: A list of modules which are required by this module, but
203 not by those using this module.
204 * `OPTIONAL_DEPENDS`: A list of modules which are used by this module if
205 enabled; these are treated as `PRIVATE_DEPENDS` if they exist.
206 * `ORDER_DEPENDS`: Dependencies which only matter for ordering. This does not
207 mean that the module will be enabled, just guaranteed to build before this
209 * `IMPLEMENTS`: A list of modules for which this module needs to register
211 * `TEST_DEPENDS`: Modules required by the test suite for this module.
212 * `TEST_OPTIONAL_DEPENDS`: Modules used by the test suite for this module if
214 * `TEST_LABELS`: Labels to apply to the tests of this module. By default, the
215 module name is applied as a label.
216 * `EXCLUDE_WRAP`: If present, this module should not be wrapped in any
218 * `THIRD_PARTY`: If present, this module is a third party module.
223 @brief Parse `vtk.module` file contents
225 This macro places all `vtk.module` keyword "arguments
" into the caller's scope
226 prefixed with the value of `name_output` which is set to the `NAME` of the
230 _vtk_module_parse_module_args(name_output <vtk.module args...>)
233 For example, this `vtk.module` file:
242 called with `_vtk_module_parse_module_args(name ...)` will set the following
243 variables in the calling scope:
245 - `name`: `Namespace::Target`
246 - `Namespace::Target_LIBRARY_NAME`: `nsTarget`
248 With namespace support for module names, the variable should instead be
249 referenced via `${${name}_LIBRARY_NAME}` instead.
251 macro (_vtk_module_parse_module_args name_output)
252 cmake_parse_arguments("_name
"
260 "A VTK module requires a
name (from ${_vtk_scan_module_file}).
")
262 set("${name_output}
" "${_name_NAME}
")
264 cmake_parse_arguments("${_name_NAME}
"
265 "IMPLEMENTABLE;EXCLUDE_WRAP;THIRD_PARTY
"
266 "LIBRARY_NAME;NAME;KIT
"
267 "GROUPS;DEPENDS;PRIVATE_DEPENDS;OPTIONAL_DEPENDS;ORDER_DEPENDS;TEST_DEPENDS;TEST_OPTIONAL_DEPENDS;TEST_LABELS;DESCRIPTION;CONDITION;IMPLEMENTS
"
270 if (${_name_NAME}_UNPARSED_ARGUMENTS)
272 "Unparsed arguments
for ${_name_NAME}:
"
273 "${${_name_NAME}_UNPARSED_ARGUMENTS}
")
276 if (NOT ${_name_NAME}_DESCRIPTION AND _vtk_module_warnings)
277 message(WARNING "The ${_name_NAME} module should have a
description")
279 string(REPLACE ";
" " " "${_name_NAME}_DESCRIPTION
" "${${_name_NAME}_DESCRIPTION}
")
281 _vtk_module_split_module_name("${_name_NAME}
" "${_name_NAME}
")
283 if (NOT DEFINED "${_name_NAME}_LIBRARY_NAME
")
284 set("${_name_NAME}_LIBRARY_NAME
" "${${_name_NAME}_TARGET_NAME}
")
287 if (NOT ${_name_NAME}_LIBRARY_NAME)
288 message(FATAL_ERROR "The ${_name_NAME} module must have a non-empty `LIBRARY_NAME`.
")
291 list(APPEND "${_name_NAME}_TEST_LABELS
"
292 "${${_name_NAME}_NAME}
"
293 "${${_name_NAME}_LIBRARY_NAME}
")
297 @page module-overview
299 @section module-parse-kit vtk.kit file contents
301 The `vtk.kit` file is parsed similarly to `vtk.module` files. Kits are intended
302 to bring together related modules into a single library in order to reduce the
303 number of objects that linkers need to deal with.
313 Core utilities for VTK.
316 All values are optional unless otherwise noted. The following arguments are
319 * `NAME`: (Required) The name of the kit.
320 * `LIBRARY_NAME`: The base name of the library file. It defaults to the
321 module name, but any namespaces are removed. For example, a `NS::Foo`
322 module will have a default `LIBRARY_NAME` of `Foo`.
323 * `DESCRIPTION`: (Recommended) Short text describing what the kit contains.
328 @brief Parse `vtk.kit` file contents
330 Just like @ref _vtk_module_parse_module_args, but for kits.
332 macro (_vtk_module_parse_kit_args name_output)
333 cmake_parse_arguments("_name
"
341 "A VTK kit requires a
name (from ${_vtk_scan_kit_file}).
")
343 set("${name_output}
" "${_name_NAME}
")
345 cmake_parse_arguments("${_name_NAME}
"
351 if (${_name_NAME}_UNPARSED_ARGUMENTS)
353 "Unparsed arguments
for ${_name_NAME}:
"
354 "${${_name_NAME}_UNPARSED_ARGUMENTS}
")
357 _vtk_module_split_module_name("${_name_NAME}
" "${_name_NAME}
")
359 if (NOT DEFINED "${_name_NAME}_LIBRARY_NAME
")
360 set("${_name_NAME}_LIBRARY_NAME
" "${${_name_NAME}_TARGET_NAME}
")
363 if (NOT ${_name_NAME}_LIBRARY_NAME)
364 message(FATAL_ERROR "The ${_name_NAME} module must have a non-empty `LIBRARY_NAME`.
")
367 if (NOT ${_name_NAME}_DESCRIPTION AND _vtk_module_warnings)
368 message(WARNING "The ${_name_NAME} kit should have a
description")
370 string(REPLACE ";
" " " "${_name_NAME}_DESCRIPTION
" "${${_name_NAME}_DESCRIPTION}
")
374 @page module-overview
377 @section module-enable-status Enable status values
379 Modules and groups are enable and disable preferences are specified using a
382 - `YES`: The module or group must be built.
383 - `NO`: The module or group must not be built.
384 - `WANT`: The module or group should be built if possible.
385 - `DONT_WANT`: The module or group should only be built if required (e.g.,
387 - `DEFAULT`: Acts as either `WANT` or `DONT_WANT` based on the group settings
388 for the module or `WANT_BY_DEFAULT` option to @ref vtk_module_scan if no
389 other preference is specified. This is usually handled via another setting
392 If a `YES` module preference requires a module with a `NO` preference, an error
395 A module with a setting of `DEFAULT` will look for its first non-`DEFAULT`
396 group setting and only if all of those are set to `DEFAULT` is the
397 `WANT_BY_DEFAULT` setting used.
402 @brief Verify enable values
404 Verifies that the variable named as the first parameter is a valid `enable
408 _vtk_module_verify_enable_value(var)
411 function (_vtk_module_verify_enable_value var)
412 if (NOT (${var} STREQUAL "YES
" OR
413 ${var} STREQUAL "WANT
" OR
414 ${var} STREQUAL "DONT_WANT
" OR
415 ${var} STREQUAL "NO
" OR
416 ${var} STREQUAL "DEFAULT
"))
418 "The `${var}` variable must be one of `YES`, `WANT`, `DONT_WANT`, `NO`,
"
419 "or `DEFAULT`. Found `${${var}}`.
")
423 include("${CMAKE_CURRENT_LIST_DIR}/vtkTopologicalSort.cmake
")
427 @brief Scan modules and kits
429 Once all of the modules and kits files have been found, they are "scanned
" to
430 determine what modules are enabled or required.
434 MODULE_FILES <file>...
435 [KIT_FILES <file>...]
436 PROVIDES_MODULES <variable>
437 [PROVIDES_KITS <variable>]
438 [REQUIRES_MODULES <variable>]
439 [REQUEST_MODULES <module>...]
440 [REJECT_MODULES <module>...]
441 [UNRECOGNIZED_MODULES <variable>]
442 [WANT_BY_DEFAULT <ON|OFF>]
443 [HIDE_MODULES_FROM_CACHE <ON|OFF>]
444 [ENABLE_TESTS <ON|OFF|WANT|DEFAULT>])
447 The `MODULE_FILES` and `PROVIDES_MODULES` arguments are required. Modules which
448 refer to kits must be scanned at the same time as their kits. This is so that
449 modules may not add themselves to kits declared prior. The arguments are as follows:
451 * `MODULE_FILES`: (Required) The list of module files to scan.
452 * `KIT_FILES`: The list of kit files to scan.
453 * `PROVIDES_MODULES`: (Required) This variable will contain the list of
454 modules which are enabled due to this scan.
455 * `PROVIDES_KITS`: (Required if `KIT_FILES` are provided) This variable will
456 contain the list of kits which are enabled due to this scan.
457 * `REQUIRES_MODULES`: This variable will contain the list of modules required
458 by the enabled modules that were not scanned.
459 * `REQUEST_MODULES`: The list of modules required by previous scans.
460 * `REJECT_MODULES`: The list of modules to exclude from the scan. If any of
461 these modules are required, an error will be raised.
462 * `UNRECOGNIZED_MODULES`: This variable will contain the list of requested
463 modules that were not scanned.
464 * `WANT_BY_DEFAULT`: (Defaults to `OFF`) Whether modules should default to
466 * `HIDE_MODULES_FROM_CACHE`: (Defaults to `OFF`) Whether or not to hide the
467 control variables from the cache or not. If enabled, modules will not be
468 built unless they are required elsewhere.
469 * `ENABLE_TESTS`: (Defaults to `WANT`) Whether or not modules required by
470 the tests for the scanned modules should be enabled or not.
471 - `ON`: Modules listed as `TEST_DEPENDS` will be required.
472 - `OFF`: Test modules will not be considered.
473 - `WANT`: Test dependencies will enable modules if possible.
474 - `DEFAULT`: Test modules will be enabled if their required dependencies
475 are satisfied and skipped otherwise.
477 @section module-scanning-multiple Scanning multiple groups of modules
479 When scanning complicated projects, multiple scans may be required to get
480 defaults set properly. The `REQUIRES_MODULES`, `REQUEST_MODULES`, and
481 `UNRECOGNIZED_MODULES` arguments are meant to deal with this case. As an
482 example, imagine a project with its source code, third party dependencies, as
483 well as some utility modules which should only be built as necessary. Here, the
484 project would perform three scans, one for each "grouping
" of modules:
487 # Scan our modules first because we need to know what of the other groups we
489 vtk_module_find_modules(our_modules "${CMAKE_CURRENT_SOURCE_DIR}/src
")
491 MODULE_FILES ${our_modules}
492 PROVIDES_MODULES our_enabled_modules
493 REQUIRES_MODULES required_modules)
495 # Scan the third party modules, requesting only those that are necessary, but
496 # allowing them to be toggled during the build.
497 vtk_module_find_modules(third_party_modules "${CMAKE_CURRENT_SOURCE_DIR}/third-party
")
499 MODULE_FILES ${third_party_modules}
500 PROVIDES_MODULES third_party_enabled_modules
501 # These modules were requested by an earlier scan.
502 REQUEST_MODULES ${required_modules}
503 REQUIRES_MODULES required_modules
504 UNRECOGNIZED_MODULES unrecognized_modules)
506 # These modules are internal and should only be built if necessary. There is no
507 # need to support them being enabled independently, so hide them from the
509 vtk_module_find_modules(utility_modules "${CMAKE_CURRENT_SOURCE_DIR}/utilities
")
511 MODULE_FILES ${utility_modules}
512 PROVIDES_MODULES utility_enabled_modules
513 # These modules were either requested or unrecognized by an earlier scan.
514 REQUEST_MODULES ${required_modules}
515 ${unrecognized_modules}
516 REQUIRES_MODULES required_modules
517 UNRECOGNIZED_MODULES unrecognized_modules
518 HIDE_MODULES_FROM_CACHE ON)
520 if (required_modules OR unrecognized_modules)
521 # Not all of the modules we required were found. This should probably error out.
525 function (vtk_module_scan)
526 cmake_parse_arguments(_vtk_scan
528 "WANT_BY_DEFAULT;HIDE_MODULES_FROM_CACHE;PROVIDES_MODULES;REQUIRES_MODULES;UNRECOGNIZED_MODULES;ENABLE_TESTS;PROVIDES_KITS
"
529 "MODULE_FILES;KIT_FILES;REQUEST_MODULES;REJECT_MODULES
"
532 if (_vtk_scan_UNPARSED_ARGUMENTS)
535 "${_vtk_scan_UNPARSED_ARGUMENTS}
")
538 if (NOT DEFINED _vtk_scan_WANT_BY_DEFAULT)
539 set(_vtk_scan_WANT_BY_DEFAULT OFF)
542 if (NOT DEFINED _vtk_scan_HIDE_MODULES_FROM_CACHE)
543 set(_vtk_scan_HIDE_MODULES_FROM_CACHE OFF)
546 if (NOT DEFINED _vtk_scan_PROVIDES_MODULES)
548 "The `PROVIDES_MODULES` argument is required.
")
551 if (NOT DEFINED _vtk_scan_PROVIDES_KITS AND _vtk_scan_KIT_FILES)
553 "The `PROVIDES_KITS` argument is required.
")
556 if (NOT DEFINED _vtk_scan_ENABLE_TESTS)
557 set(_vtk_scan_ENABLE_TESTS "WANT
")
560 if (NOT (_vtk_scan_ENABLE_TESTS STREQUAL "ON
" OR
561 _vtk_scan_ENABLE_TESTS STREQUAL "OFF
" OR
562 _vtk_scan_ENABLE_TESTS STREQUAL "WANT
" OR
563 _vtk_scan_ENABLE_TESTS STREQUAL "DEFAULT
"))
565 "The `ENABLE_TESTS` argument must be one of `ON`, `OFF`, `WANT`, or
"
566 "`DEFAULT`.
" "Received `${_vtk_scan_ENABLE_TESTS}`.
")
569 if (NOT _vtk_scan_MODULE_FILES)
571 "No module files given to scan.
")
574 set(_vtk_scan_option_default_type STRING)
575 if (_vtk_scan_HIDE_MODULES_FROM_CACHE)
576 set(_vtk_scan_option_default_type INTERNAL)
579 set(_vtk_scan_all_kits)
581 foreach (_vtk_scan_kit_file IN LISTS _vtk_scan_KIT_FILES)
582 if (NOT IS_ABSOLUTE "${_vtk_scan_kit_file}
")
583 set(_vtk_scan_kit_file "${CMAKE_CURRENT_SOURCE_DIR}/${_vtk_scan_kit_file}
")
585 set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}
" APPEND
587 CMAKE_CONFIGURE_DEPENDS "${_vtk_scan_kit_file}
")
589 file(READ "${_vtk_scan_kit_file}
" _vtk_scan_kit_args)
591 string(REGEX REPLACE "#[^\n]*\n
" "\n
" _vtk_scan_kit_args "${_vtk_scan_kit_args}
")
592 # Use argument splitting.
593 string(REGEX REPLACE "( |\n)+
" ";
" _vtk_scan_kit_args "${_vtk_scan_kit_args}
")
594 _vtk_module_parse_kit_args(_vtk_scan_kit_name ${_vtk_scan_kit_args})
595 _vtk_module_debug(kit "@_vtk_scan_kit_name@ declared by @_vtk_scan_kit_file
@")
597 list(APPEND _vtk_scan_all_kits
598 "${_vtk_scan_kit_name}
")
600 # Set properties for building.
603 "_vtk_kit_${_vtk_scan_kit_name}_namespace
" "${${_vtk_scan_kit_name}_NAMESPACE}
")
606 "_vtk_kit_${_vtk_scan_kit_name}_target_name
" "${${_vtk_scan_kit_name}_TARGET_NAME}
")
609 "_vtk_kit_${_vtk_scan_kit_name}_library_name
" "${${_vtk_scan_kit_name}_LIBRARY_NAME}
")
612 set(_vtk_scan_all_modules)
613 set(_vtk_scan_all_groups)
614 set(_vtk_scan_rejected_modules)
616 # Read all of the module files passed in.
617 foreach (_vtk_scan_module_file IN LISTS _vtk_scan_MODULE_FILES)
618 if (NOT IS_ABSOLUTE "${_vtk_scan_module_file}
")
619 set(_vtk_scan_module_file "${CMAKE_CURRENT_SOURCE_DIR}/${_vtk_scan_module_file}
")
621 set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}
" APPEND
623 CMAKE_CONFIGURE_DEPENDS "${_vtk_scan_module_file}
")
625 file(READ "${_vtk_scan_module_file}
" _vtk_scan_module_args)
627 string(REGEX REPLACE "#[^\n]*\n
" "\n
" _vtk_scan_module_args "${_vtk_scan_module_args}
")
628 # Use argument splitting.
629 string(REGEX REPLACE "( |\n)+
" ";
" _vtk_scan_module_args "${_vtk_scan_module_args}
")
630 _vtk_module_parse_module_args(_vtk_scan_module_name ${_vtk_scan_module_args})
631 _vtk_module_debug(module "@_vtk_scan_module_name@ declared by @_vtk_scan_module_file
@")
632 string(REPLACE "::
" "_
" _vtk_scan_module_name_safe "${_vtk_scan_module_name}
")
634 if (${_vtk_scan_module_name}_THIRD_PARTY)
635 if (_vtk_module_warnings)
636 if (${_vtk_scan_module_name}_EXCLUDE_WRAP)
638 "The third party ${_vtk_scan_module_name} module does not need to
"
639 "declare `EXCLUDE_WRAP` also.
")
642 if (${_vtk_scan_module_name}_IMPLEMENTABLE)
644 "The third party ${_vtk_scan_module_name} module may not be
"
647 if (${_vtk_scan_module_name}_IMPLEMENTS)
649 "The third party ${_vtk_scan_module_name} module may not
"
650 "`IMPLEMENTS` another module.
")
652 if (${_vtk_scan_module_name}_KIT)
654 "The third party ${_vtk_scan_module_name} module may not be part of
"
655 "a kit (${${_vtk_scan_module_name}_KIT}).
")
659 if (${_vtk_scan_module_name}_KIT)
660 if (NOT ${_vtk_scan_module_name}_KIT IN_LIST _vtk_scan_all_kits)
662 "The ${_vtk_scan_module_name} belongs to the
"
663 "${${_vtk_scan_module_name}_KIT} kit, but it has not been scanned.
")
667 # Check if the module is visible. Modules which have a failing condition
668 # are basically invisible.
669 if (DEFINED ${_vtk_scan_module_name}_CONDITION)
670 if (NOT (${${_vtk_scan_module_name}_CONDITION}))
671 if (DEFINED "VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe}
")
672 set_property(CACHE "VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe}
"
676 _vtk_module_debug(module "@_vtk_scan_module_name@ hidden by its `CONDITION`
")
681 # Determine whether we should provide a user-visible option for this
683 set(_vtk_build_use_option 1)
684 if (DEFINED _vtk_scan_REQUEST_MODULE)
685 if (_vtk_scan_module_name IN_LIST _vtk_scan_REQUEST_MODULE)
686 set("_vtk_scan_enable_${_vtk_scan_module_name}
" YES)
687 set(_vtk_build_use_option 0)
690 if (DEFINED _vtk_scan_REJECT_MODULES)
691 if (_vtk_scan_module_name IN_LIST _vtk_scan_REJECT_MODULES)
692 if (NOT _vtk_build_use_option)
694 "The ${_vtk_scan_module_name} module has been requested and rejected.
")
696 # Rejected modules should not have a build option.
697 set(_vtk_build_use_option 0)
698 list(APPEND _vtk_scan_rejected_modules
699 "${_vtk_scan_module_name}
")
703 # Handle cache entries and determine the enabled state of the module from
704 # the relevant cache variables.
705 if (_vtk_build_use_option)
706 set("VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe}
" "DEFAULT
"
707 CACHE STRING "Enable the ${_vtk_scan_module_name} module. ${${_vtk_scan_module_name}_DESCRIPTION}
")
708 mark_as_advanced("VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe}
")
709 set_property(CACHE "VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe}
"
711 STRINGS "YES;WANT;DONT_WANT;NO;DEFAULT
")
712 _vtk_module_verify_enable_value("VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe}
")
714 if (NOT VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe} STREQUAL "DEFAULT
")
715 set("_vtk_scan_enable_${_vtk_scan_module_name}
" "${VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe}}
")
716 _vtk_module_debug(enable "@_vtk_scan_module_name@ is `${_vtk_scan_enable_${_vtk_scan_module_name}}` by cache
value")
719 # Check the state of any groups the module belongs to.
720 foreach (_vtk_scan_group IN LISTS "${_vtk_scan_module_name}_GROUPS
")
721 if (NOT DEFINED "VTK_GROUP_ENABLE_${_vtk_scan_group}
")
722 set(_vtk_scan_group_default "DEFAULT
")
723 if (DEFINED "_vtk_module_group_default_${_vtk_scan_group}
")
724 set(_vtk_scan_group_default "${_vtk_module_group_default_${_vtk_scan_group}}
")
726 set("VTK_GROUP_ENABLE_${_vtk_scan_group}
" "${_vtk_scan_group_default}
"
727 CACHE STRING "Enable the ${_vtk_scan_group} group modules.
")
728 set_property(CACHE "VTK_GROUP_ENABLE_${_vtk_scan_group}
"
730 STRINGS "YES;WANT;DONT_WANT;NO;DEFAULT
")
731 set_property(CACHE "VTK_GROUP_ENABLE_${_vtk_scan_group}
"
733 TYPE "${_vtk_scan_option_default_type}
")
735 _vtk_module_verify_enable_value("VTK_GROUP_ENABLE_${_vtk_scan_group}
")
737 if (NOT VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe} STREQUAL "DEFAULT
")
741 # Determine the state of the group.
742 set(_vtk_scan_group_enable "${VTK_GROUP_ENABLE_${_vtk_scan_group}}
")
743 if (NOT _vtk_scan_group_enable STREQUAL "DEFAULT
")
744 set("_vtk_scan_enable_${_vtk_scan_module_name}
" "${_vtk_scan_group_enable}
")
745 _vtk_module_debug(enable "@_vtk_scan_module_name@ is DEFAULT,
using group `@_vtk_scan_group@` setting: @_vtk_scan_group_enable
@")
749 set_property(CACHE "VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe}
"
751 TYPE "${_vtk_scan_option_default_type}
")
754 if (NOT DEFINED "_vtk_scan_enable_${_vtk_scan_module_name}
" AND
755 VTK_MODULE_ENABLE_${_vtk_scan_module_name_safe} STREQUAL "DEFAULT
")
756 if (_vtk_scan_WANT_BY_DEFAULT)
757 set("_vtk_scan_enable_${_vtk_scan_module_name}
" "WANT
")
759 set("_vtk_scan_enable_${_vtk_scan_module_name}
" "DONT_WANT
")
761 _vtk_module_debug(enable "@_vtk_scan_module_name@ is DEFAULT,
using `WANT_BY_DEFAULT`: ${_vtk_scan_enable_${_vtk_scan_module_name}}
")
764 list(APPEND _vtk_scan_all_modules
765 "${_vtk_scan_module_name}
")
766 set("_vtk_scan_${_vtk_scan_module_name}_all_depends
"
767 ${${_vtk_scan_module_name}_DEPENDS}
768 ${${_vtk_scan_module_name}_PRIVATE_DEPENDS})
770 if (${_vtk_scan_module_name}_THIRD_PARTY)
771 set("${_vtk_scan_module_name}_EXCLUDE_WRAP
" TRUE)
772 set("${_vtk_scan_module_name}_IMPLEMENTABLE
" FALSE)
773 set("${_vtk_scan_module_name}_IMPLEMENTS
")
776 if (${_vtk_scan_module_name}_KIT)
777 _vtk_module_debug(kit "@_vtk_scan_module_name@ belongs to the ${${_vtk_scan_module_name}_KIT} kit
")
780 # Set properties for building.
783 "_vtk_module_${_vtk_scan_module_name}_file
" "${_vtk_scan_module_file}
")
786 "_vtk_module_${_vtk_scan_module_name}_namespace
" "${${_vtk_scan_module_name}_NAMESPACE}
")
789 "_vtk_module_${_vtk_scan_module_name}_target_name
" "${${_vtk_scan_module_name}_TARGET_NAME}
")
792 "_vtk_module_${_vtk_scan_module_name}_library_name
" "${${_vtk_scan_module_name}_LIBRARY_NAME}
")
795 "_vtk_module_${_vtk_scan_module_name}_third_party
" "${${_vtk_scan_module_name}_THIRD_PARTY}
")
798 "_vtk_module_${_vtk_scan_module_name}_exclude_wrap
" "${${_vtk_scan_module_name}_EXCLUDE_WRAP}
")
801 "_vtk_module_${_vtk_scan_module_name}_kit
" "${${_vtk_scan_module_name}_KIT}
")
804 "_vtk_module_${_vtk_scan_module_name}_depends
" "${${_vtk_scan_module_name}_DEPENDS}
")
807 "_vtk_module_${_vtk_scan_module_name}_order_depends
" "${${_vtk_scan_module_name}_ORDER_DEPENDS}
")
810 "_vtk_module_${_vtk_scan_module_name}_private_depends
" "${${_vtk_scan_module_name}_PRIVATE_DEPENDS}
")
813 "_vtk_module_${_vtk_scan_module_name}_optional_depends
" "${${_vtk_scan_module_name}_OPTIONAL_DEPENDS}
")
816 "_vtk_module_${_vtk_scan_module_name}_test_depends
" "${${_vtk_scan_module_name}_TEST_DEPENDS}
")
819 "_vtk_module_${_vtk_scan_module_name}_test_optional_depends
" "${${_vtk_scan_module_name}_TEST_OPTIONAL_DEPENDS}
")
822 "_vtk_module_${_vtk_scan_module_name}_test_labels
" "${${_vtk_scan_module_name}_TEST_LABELS}
")
825 "_vtk_module_${_vtk_scan_module_name}_implements
" "${${_vtk_scan_module_name}_IMPLEMENTS}
")
828 "_vtk_module_${_vtk_scan_module_name}_implementable
" "${${_vtk_scan_module_name}_IMPLEMENTABLE}
")
831 set(_vtk_scan_current_modules "${_vtk_scan_all_modules}
")
832 vtk_topological_sort(_vtk_scan_all_modules "_vtk_scan_
" "_all_depends
")
834 set(_vtk_scan_provided_modules)
835 set(_vtk_scan_required_modules)
836 set(_vtk_scan_disabled_modules)
838 # Seed the `_vtk_scan_provide_` variables with modules requested and rejected
840 foreach (_vtk_scan_request_module IN LISTS _vtk_scan_REQUEST_MODULES)
841 set("_vtk_scan_provide_${_vtk_scan_request_module}
" ON)
842 _vtk_module_debug(provide "@_vtk_scan_request_module@ is provided via `REQUEST_MODULES`
")
844 foreach (_vtk_scan_reject_module IN LISTS _vtk_scan_REJECT_MODULES)
845 set("_vtk_scan_provide_${_vtk_scan_reject_module}
" OFF)
846 _vtk_module_debug(provide "@_vtk_scan_reject_module@ is not provided via `REJECT_MODULES`
")
849 # Traverse the graph classifying the quad-state for enabling modules into a
850 # boolean stored in the `_vtk_scan_provide_` variables.
851 foreach (_vtk_scan_module IN LISTS _vtk_scan_all_modules)
852 if (NOT _vtk_scan_module IN_LIST _vtk_scan_current_modules)
853 _vtk_module_debug(provide "@_vtk_scan_module@ is ignored because it is not in the current scan set
")
857 if (DEFINED "_vtk_scan_provide_${_vtk_scan_module}
")
859 elseif (_vtk_scan_enable_${_vtk_scan_module} STREQUAL "YES
")
860 # Mark enabled modules as to-be-provided. Any errors with requiring a
861 # disabled module will be dealt with later.
862 set("_vtk_scan_provide_${_vtk_scan_module}
" ON)
863 _vtk_module_debug(provide "@_vtk_scan_module@ is provided due to `YES` setting
")
864 elseif (_vtk_scan_enable_${_vtk_scan_module} STREQUAL "WANT
")
865 # Check to see if we can provide this module by checking of any of its
866 # dependencies have been disabled.
867 set(_vtk_scan_test_depends)
868 if (NOT ${_vtk_scan_module}_THIRD_PARTY AND _vtk_scan_ENABLE_TESTS STREQUAL "ON
")
869 # If the tests have to be on, we also need the test dependencies.
870 set(_vtk_scan_test_depends "${${_vtk_scan_module}_TEST_DEPENDS}
")
873 set("_vtk_scan_provide_${_vtk_scan_module}
" ON)
874 _vtk_module_debug(provide "@_vtk_scan_module@ is provided due to `WANT` setting
")
875 foreach (_vtk_scan_module_depend IN LISTS "${_vtk_scan_module}_DEPENDS
" "${_vtk_scan_module}_PRIVATE_DEPENDS
" _vtk_scan_test_depends)
876 if (DEFINED "_vtk_scan_provide_${_vtk_scan_module_depend}
" AND NOT _vtk_scan_provide_${_vtk_scan_module_depend})
877 set("_vtk_scan_provide_${_vtk_scan_module}
" OFF)
878 _vtk_module_debug(provide "@_vtk_scan_module@ is not provided due to not provided dependency @_vtk_scan_module_depend
@")
882 elseif (_vtk_scan_enable_${_vtk_scan_module} STREQUAL "DONT_WANT
")
883 # Check for disabled dependencies and disable if so.
884 foreach (_vtk_scan_module_depend IN LISTS "${_vtk_scan_module}_DEPENDS
" "${_vtk_scan_module}_PRIVATE_DEPENDS
" _vtk_scan_test_depends)
885 if (DEFINED "_vtk_scan_provide_${_vtk_scan_module_depend}
" AND NOT _vtk_scan_provide_${_vtk_scan_module_depend})
886 set("_vtk_scan_provide_${_vtk_scan_module}
" OFF)
887 _vtk_module_debug(provide "@_vtk_scan_module@ is not provided due to not provided dependency @_vtk_scan_module_depend
@")
891 elseif (_vtk_scan_enable_${_vtk_scan_module} STREQUAL "NO
")
892 # Disable the module.
893 set("_vtk_scan_provide_${_vtk_scan_module}
" OFF)
894 _vtk_module_debug(provide "@_vtk_scan_module@ is not provided due to `NO` setting
")
897 # Collect disabled modules into a list.
898 if (DEFINED "_vtk_scan_provide_${_vtk_scan_module}
" AND NOT _vtk_scan_provide_${_vtk_scan_module})
899 list(APPEND _vtk_scan_disabled_modules
900 "${_vtk_scan_module}
")
903 if (NOT DEFINED "_vtk_scan_provide_${_vtk_scan_module}
")
904 _vtk_module_debug(provide "@_vtk_scan_module@ is indeterminite (${_vtk_scan_enable_${_vtk_scan_module}})
")
908 # Scan all modules from the top of tree to the bottom.
909 list(REVERSE _vtk_scan_all_modules)
910 foreach (_vtk_scan_module IN LISTS _vtk_scan_all_modules)
911 if (NOT _vtk_scan_module IN_LIST _vtk_scan_current_modules)
915 # If we're providing this module...
916 if (_vtk_scan_provide_${_vtk_scan_module})
917 list(APPEND _vtk_scan_provided_modules
918 "${_vtk_scan_module}
")
920 # Grab any test dependencies that are required.
921 set(_vtk_scan_test_depends)
922 set(_vtk_scan_test_wants)
923 if (NOT ${_vtk_scan_module}_THIRD_PARTY)
924 if (_vtk_scan_ENABLE_TESTS STREQUAL "ON
")
925 set_property(GLOBAL APPEND
927 "_vtk_module_test_modules
" "${_vtk_scan_module}
")
928 set(_vtk_scan_test_depends "${${_vtk_scan_module}_TEST_DEPENDS}
")
929 elseif (_vtk_scan_ENABLE_TESTS STREQUAL "WANT
")
930 set_property(GLOBAL APPEND
932 "_vtk_module_test_modules
" "${_vtk_scan_module}
")
933 set(_vtk_scan_test_wants _vtk_scan_wants_marker ${${_vtk_scan_module}_TEST_DEPENDS})
934 elseif (_vtk_scan_ENABLE_TESTS STREQUAL "DEFAULT
")
935 set_property(GLOBAL APPEND
937 "_vtk_module_test_modules
" "${_vtk_scan_module}
")
938 elseif (_vtk_scan_ENABLE_TESTS STREQUAL "OFF
")
942 "Unrecognized option
for ENABLE_TESTS: ${_vtk_module_ENABLE_TESTS}.
")
946 # Add all dependent modules to the list of required or provided modules.
947 set(_vtk_scan_is_wanting 0)
948 foreach (_vtk_scan_module_depend IN LISTS "${_vtk_scan_module}_DEPENDS
" "${_vtk_scan_module}_PRIVATE_DEPENDS
" _vtk_scan_test_depends _vtk_scan_test_wants)
949 if (_vtk_scan_module_depend STREQUAL "_vtk_scan_wants_marker
")
950 set(_vtk_scan_is_wanting 1)
953 # Though we need to error if this would cause a disabled module to be
955 if (_vtk_scan_module_depend IN_LIST _vtk_scan_disabled_modules)
956 if (_vtk_scan_is_wanting)
960 "The ${_vtk_scan_module} module requires the disabled module ${_vtk_scan_module_depend}.
")
964 if (DEFINED "_vtk_scan_provide_${_vtk_scan_module_depend}
")
965 if (NOT _vtk_scan_provide_${_vtk_scan_module_depend})
967 "The `${_vtk_scan_module_depend} should be provided, but is disabled.
")
971 set("_vtk_scan_provide_${_vtk_scan_module_depend}
" ON)
973 if (NOT _vtk_scan_module_depend IN_LIST _vtk_scan_current_modules)
974 if (NOT TARGET "${_vtk_scan_module_depend}
")
975 _vtk_module_debug(provide "@_vtk_scan_module_depend@ is external and required due to dependency from @_vtk_scan_module
@")
977 list(APPEND _vtk_scan_required_modules
978 "${_vtk_scan_module_depend}
")
980 _vtk_module_debug(provide "@_vtk_scan_module_depend@ is provided due to dependency from @_vtk_scan_module
@")
981 list(APPEND _vtk_scan_provided_modules
982 "${_vtk_scan_module_depend}
")
988 if (_vtk_scan_provided_modules)
989 list(REMOVE_DUPLICATES _vtk_scan_provided_modules)
992 set(_vtk_scan_provided_kits)
994 # Build a list of kits which contain the provided modules.
995 foreach (_vtk_scan_provided_module IN LISTS _vtk_scan_provided_modules)
996 if (${_vtk_scan_provided_module}_KIT)
997 list(APPEND _vtk_scan_provided_kits
998 "${${_vtk_scan_provided_module}_KIT}
")
999 set_property(GLOBAL APPEND
1001 "_vtk_kit_${${_vtk_scan_provided_module}_KIT}_kit_modules
" "${_vtk_scan_provided_module}
")
1005 if (_vtk_scan_provided_kits)
1006 list(REMOVE_DUPLICATES _vtk_scan_provided_kits)
1009 if (_vtk_scan_required_modules)
1010 list(REMOVE_DUPLICATES _vtk_scan_required_modules)
1013 set(_vtk_scan_unrecognized_modules
1014 ${_vtk_scan_REQUEST_MODULES}
1015 ${_vtk_scan_REJECT_MODULES})
1017 if (_vtk_scan_unrecognized_modules AND (_vtk_scan_provided_modules OR _vtk_scan_rejected_modules))
1018 list(REMOVE_ITEM _vtk_scan_unrecognized_modules
1019 ${_vtk_scan_provided_modules}
1020 ${_vtk_scan_rejected_modules})
1023 set("${_vtk_scan_PROVIDES_MODULES}
"
1024 ${_vtk_scan_provided_modules}
1027 if (DEFINED _vtk_scan_REQUIRES_MODULES)
1028 set("${_vtk_scan_REQUIRES_MODULES}
"
1029 ${_vtk_scan_required_modules}
1033 if (DEFINED _vtk_scan_UNRECOGNIZED_MODULES)
1034 set("${_vtk_scan_UNRECOGNIZED_MODULES}
"
1035 ${_vtk_scan_unrecognized_modules}
1039 if (DEFINED _vtk_scan_PROVIDES_KITS)
1040 set("${_vtk_scan_PROVIDES_KITS}
"
1041 ${_vtk_scan_provided_kits}
1047 @page module-overview
1049 @section module-target-functions Module-as-target functions
1051 Due to the nature of VTK modules supporting being built as kits, the module
1052 name might not be usable as a target to CMake's `target_` family of commands.
1053 Instead, there are various wrappers around them which take the module name as
1054 an argument. These handle the forwarding of relevant information to the kit
1055 library as well where necessary.
1057 - @ref vtk_module_set_properties
1058 - @ref vtk_module_set_property
1059 - @ref vtk_module_get_property
1060 - @ref vtk_module_depend
1061 - @ref vtk_module_include
1062 - @ref vtk_module_definitions
1063 - @ref vtk_module_compile_options
1064 - @ref vtk_module_compile_features
1065 - @ref vtk_module_link
1066 - @ref vtk_module_link_options
1070 @page module-internal-api
1072 @section module-target-internals Module target internals
1074 When manipulating modules as targets, there are a few functions provided for
1075 use in wrapping code to more easily access them.
1077 - @ref _vtk_module_real_target
1078 - @ref _vtk_module_real_target_kit
1082 @ingroup module-internal
1083 @brief The real target for a module
1086 _vtk_module_real_target(<var> <module>)
1089 Sometimes the actual, core target for a module is required (e.g., setting
1090 CMake-level target properties or install rules). This function returns the real
1091 target for a module.
1093 function (_vtk_module_real_target var module)
1099 set(_vtk_real_target_res "")
1100 if (TARGET "${module}
")
1101 get_property(_vtk_real_target_imported
1104 if (_vtk_real_target_imported)
1105 set(_vtk_real_target_res "${module}
")
1109 if (NOT _vtk_real_target_res)
1110 get_property(_vtk_real_target_res GLOBAL
1111 PROPERTY "_vtk_module_${module}_target_name
")
1112 # Querying during the build.
1113 if (DEFINED _vtk_build_BUILD_WITH_KITS AND _vtk_build_BUILD_WITH_KITS)
1114 get_property(_vtk_real_target_kit GLOBAL
1115 PROPERTY "_vtk_module_${module}_kit
")
1116 if (_vtk_real_target_kit)
1117 set(_vtk_real_target_res "${_vtk_real_target_res}-objects
")
1119 # A query for after the module is built.
1120 elseif (TARGET "${_vtk_real_target_res}-objects
")
1121 set(_vtk_real_target_res "${_vtk_real_target_res}-objects
")
1125 if (NOT _vtk_real_target_res)
1126 set(_vtk_real_target_msg "")
1127 if (NOT TARGET "${module}
")
1128 if (DEFINED _vtk_build_module)
1129 set(_vtk_real_target_msg
1130 " Is a module dependency missing?
")
1132 set(_vtk_real_target_msg
1133 " Is a `find_package` missing a required
component?
")
1137 "Failed to determine the real
target for the `${module}`
"
1138 "module.${_vtk_real_target_msg}
")
1142 "${_vtk_real_target_res}
"
1147 @ingroup module-internal
1148 @brief The real target for a kit
1151 _vtk_module_real_target_kit(<var> <kit>)
1154 Sometimes the actual, core target for a module is required (e.g., setting
1155 CMake-level target properties or install rules). This function returns the real
1158 function (_vtk_module_real_target_kit var kit)
1164 set(_vtk_real_target_res "")
1165 if (TARGET "${kit}
")
1166 get_property(_vtk_real_target_imported
1169 if (_vtk_real_target_imported)
1170 set(_vtk_real_target_res "${kit}
")
1174 if (NOT _vtk_real_target_res)
1175 get_property(_vtk_real_target_res GLOBAL
1176 PROPERTY "_vtk_kit_${kit}_target_name
")
1179 if (NOT _vtk_real_target_res)
1181 "Failed to determine the real
target for the `${kit}` kit.
")
1185 "${_vtk_real_target_res}
"
1191 @brief Set multiple properties on a module
1193 A wrapper around `set_target_properties` that works for modules.
1196 vtk_module_set_properties(<module>
1197 [<property> <value>]...)
1200 function (vtk_module_set_properties module)
1201 _vtk_module_real_target(_vtk_set_properties_target "${module}
")
1203 set_target_properties("${_vtk_set_properties_target}
"
1210 @brief Set a property on a module
1212 A wrapper around `set_property(TARGET)` that works for modules.
1215 vtk_module_set_property(<module>
1216 [APPEND] [APPEND_STRING]
1221 function (vtk_module_set_property module)
1222 cmake_parse_arguments(_vtk_property
1223 "APPEND;APPEND_STRING
"
1228 if (_vtk_property_UNPARSED_ARGUMENTS)
1231 "${_vtk_property_UNPARSED_ARGUMENTS}.
")
1234 if (NOT DEFINED _vtk_property_PROPERTY)
1236 "The `PROPERTY` argument is required.
")
1239 if (NOT DEFINED _vtk_property_VALUE)
1241 "The `VALUE` argument is required.
")
1244 if (_vtk_property_APPEND AND _vtk_property_APPEND_STRING)
1246 "`APPEND` and `APPEND_STRING` may not be used at the same
time.
")
1249 set(_vtk_property_args)
1250 if (_vtk_property_APPEND)
1251 list(APPEND _vtk_property_args
1254 if (_vtk_property_APPEND_STRING)
1255 list(APPEND _vtk_property_args
1259 _vtk_module_real_target(_vtk_property_target "${module}
")
1261 set_property(TARGET "${_vtk_property_target}
"
1262 ${_vtk_property_args}
1264 "${_vtk_property_PROPERTY}
" "${_vtk_property_VALUE}
")
1269 @brief Get a property from a module
1271 A wrapper around `get_property(TARGET)` that works for modules.
1274 vtk_module_get_property(<module>
1276 VARIABLE <variable>)
1279 The variable name passed to the `VARIABLE` argument will be unset if the
1280 property is not set (rather than the empty string).
1282 function (vtk_module_get_property module)
1283 cmake_parse_arguments(_vtk_property
1289 if (_vtk_property_UNPARSED_ARGUMENTS)
1292 "${_vtk_property_UNPARSED_ARGUMENTS}.
")
1295 if (NOT DEFINED _vtk_property_PROPERTY)
1297 "The `PROPERTY` argument is required.
")
1300 if (NOT DEFINED _vtk_property_VARIABLE)
1302 "The `VARIABLE` argument is required.
")
1305 _vtk_module_real_target(_vtk_property_target "${module}
")
1307 get_property(_vtk_property_is_set
1308 TARGET "${_vtk_property_target}
"
1309 PROPERTY "${_vtk_property_PROPERTY}
"
1311 if (_vtk_property_is_set)
1312 get_property(_vtk_property_value
1313 TARGET "${_vtk_property_target}
"
1314 PROPERTY "${_vtk_property_PROPERTY}
")
1316 set("${_vtk_property_VARIABLE}
"
1317 "${_vtk_property_value}
"
1320 unset("${_vtk_property_VARIABLE}
"
1326 @ingroup module-impl
1327 @brief Generate arguments for target function wrappers
1329 Create the `INTERFACE`, `PUBLIC`, and `PRIVATE` arguments for a function
1330 wrapping CMake's `target_` functions to call the wrapped function.
1332 This is necessary because not all of the functions support empty lists given a
1335 function (_vtk_module_target_function prefix)
1336 foreach (visibility IN ITEMS INTERFACE PUBLIC PRIVATE)
1337 if (${prefix}_${visibility})
1338 set("${prefix}_${visibility}_args
"
1340 ${${prefix}_${visibility}}
1348 @brief Add dependencies to a module
1350 A wrapper around `add_dependencies` that works for modules.
1353 vtk_module_depend(<module> <depend>...)
1356 function (vtk_module_depend module)
1357 _vtk_module_real_target(_vtk_depend_target "${module}
")
1359 add_dependencies("${_vtk_depend_target}
"
1365 @brief Add include directories to a module
1367 A wrapper around `add_dependencies` that works for modules.
1370 vtk_module_include(<module>
1372 [PUBLIC <directory>...]
1373 [PRIVATE <directory>...]
1374 [INTERFACE <directory>...])
1377 function (vtk_module_include module)
1378 cmake_parse_arguments(_vtk_include
1381 "INTERFACE;PUBLIC;PRIVATE
"
1384 if (_vtk_include_UNPARSED_ARGUMENTS)
1387 "${_vtk_include_UNPARSED_ARGUMENTS}.
")
1390 _vtk_module_real_target(_vtk_include_target "${module}
")
1391 _vtk_module_target_function(_vtk_include)
1393 set(_vtk_include_system_arg)
1394 if (_vtk_include_SYSTEM)
1395 set(_vtk_include_system_arg SYSTEM)
1398 target_include_directories("${_vtk_include_target}
"
1399 ${_vtk_include_system_arg}
1400 ${_vtk_include_INTERFACE_args}
1401 ${_vtk_include_PUBLIC_args}
1402 ${_vtk_include_PRIVATE_args})
1407 @brief Add compile definitions to a module
1409 A wrapper around `target_compile_definitions` that works for modules.
1412 vtk_module_definitions(<module>
1413 [PUBLIC <directory>...]
1414 [PRIVATE <directory>...]
1415 [INTERFACE <directory>...])
1418 function (vtk_module_definitions module)
1419 cmake_parse_arguments(_vtk_definitions
1422 "INTERFACE;PUBLIC;PRIVATE
"
1425 if (_vtk_definitions_UNPARSED_ARGUMENTS)
1428 "${_vtk_definitions_UNPARSED_ARGUMENTS}.
")
1431 _vtk_module_real_target(_vtk_definitions_target "${module}
")
1432 _vtk_module_target_function(_vtk_definitions)
1434 target_compile_definitions("${_vtk_definitions_target}
"
1435 ${_vtk_definitions_INTERFACE_args}
1436 ${_vtk_definitions_PUBLIC_args}
1437 ${_vtk_definitions_PRIVATE_args})
1442 @brief Add compile options to a module
1444 A wrapper around `target_compile_options` that works for modules.
1447 vtk_module_compile_options(<module>
1448 [PUBLIC <directory>...]
1449 [PRIVATE <directory>...]
1450 [INTERFACE <directory>...])
1453 function (vtk_module_compile_options module)
1454 cmake_parse_arguments(_vtk_compile_options
1457 "INTERFACE;PUBLIC;PRIVATE
"
1460 if (_vtk_compile_options_UNPARSED_ARGUMENTS)
1463 "${_vtk_compile_options_UNPARSED_ARGUMENTS}.
")
1466 _vtk_module_real_target(_vtk_compile_options_target "${module}
")
1467 _vtk_module_target_function(_vtk_compile_options)
1469 target_compile_options("${_vtk_compile_options_target}
"
1470 ${_vtk_compile_options_INTERFACE_args}
1471 ${_vtk_compile_options_PUBLIC_args}
1472 ${_vtk_compile_options_PRIVATE_args})
1477 @brief Add compile features to a module
1479 A wrapper around `target_compile_features` that works for modules.
1482 vtk_module_compile_features(<module>
1483 [PUBLIC <directory>...]
1484 [PRIVATE <directory>...]
1485 [INTERFACE <directory>...])
1488 function (vtk_module_compile_features module)
1489 cmake_parse_arguments(_vtk_compile_features
1492 "INTERFACE;PUBLIC;PRIVATE
"
1495 if (_vtk_compile_features_UNPARSED_ARGUMENTS)
1498 "${_vtk_compile_features_UNPARSED_ARGUMENTS}.
")
1501 _vtk_module_real_target(_vtk_compile_features_target "${module}
")
1502 _vtk_module_target_function(_vtk_compile_features)
1504 target_compile_features("${_vtk_compile_features_target}
"
1505 ${_vtk_compile_features_INTERFACE_args}
1506 ${_vtk_compile_features_PUBLIC_args}
1507 ${_vtk_compile_features_PRIVATE_args})
1512 @brief Add link libraries to a module
1514 A wrapper around `target_link_libraries` that works for modules. Note that this
1515 function does extra work in kit builds, so circumventing it may break in kit
1519 vtk_module_link(<module>
1520 [PUBLIC <directory>...]
1521 [PRIVATE <directory>...]
1522 [INTERFACE <directory>...])
1525 function (vtk_module_link module)
1526 cmake_parse_arguments(_vtk_link
1529 "INTERFACE;PUBLIC;PRIVATE
"
1532 if (_vtk_link_UNPARSED_ARGUMENTS)
1535 "${_vtk_link_UNPARSED_ARGUMENTS}.
")
1538 _vtk_module_real_target(_vtk_link_target "${module}
")
1539 _vtk_module_target_function(_vtk_link)
1541 get_property(_vtk_link_kit GLOBAL
1542 PROPERTY "_vtk_module_${module}_kit
")
1543 if (_vtk_link_kit AND NOT CMAKE_VERSION VERSION_LESS "3.12
")
1544 foreach (_vtk_link_private IN LISTS _vtk_link_PRIVATE)
1545 if (NOT TARGET "${_vtk_link_private}
")
1549 get_property(_vtk_link_private_imported
1550 TARGET "${_vtk_link_private}
"
1552 if (_vtk_link_private_imported)
1553 get_property(_vtk_link_private_imported_global
1554 TARGET "${_vtk_link_private}
"
1555 PROPERTY IMPORTED_GLOBAL)
1556 if (NOT _vtk_link_private_imported_global)
1557 set_property(TARGET "${_vtk_link_private}
"
1559 IMPORTED_GLOBAL TRUE)
1563 set_property(GLOBAL APPEND
1565 "_vtk_kit_${_vtk_link_kit}_private_links
" ${_vtk_link_PRIVATE})
1568 target_link_libraries("${_vtk_link_target}
"
1569 ${_vtk_link_INTERFACE_args}
1570 ${_vtk_link_PUBLIC_args}
1571 ${_vtk_link_PRIVATE_args})
1576 @brief Add link options to a module
1578 A wrapper around `target_link_options` that works for modules.
1581 vtk_module_link_options(<module>
1582 [PUBLIC <directory>...]
1583 [PRIVATE <directory>...]
1584 [INTERFACE <directory>...])
1587 function (vtk_module_link_options module)
1588 cmake_parse_arguments(_vtk_link_options
1591 "INTERFACE;PUBLIC;PRIVATE
"
1594 if (_vtk_link_options_UNPARSED_ARGUMENTS)
1597 "${_vtk_link_options_UNPARSED_ARGUMENTS}.
")
1600 _vtk_module_real_target(_vtk_link_options_target "${module}
")
1601 _vtk_module_target_function(_vtk_link_options)
1603 target_link_options("${_vtk_link_options_target}
"
1604 ${_vtk_link_options_INTERFACE_args}
1605 ${_vtk_link_options_PUBLIC_args}
1606 ${_vtk_link_options_PRIVATE_args})
1610 @page module-internal-api
1612 @ingroup module-internal
1613 @section module-properties Module properties
1615 The VTK module system leverages CMake's target propagation and storage. As
1616 such, there are a number of properties added to the targets representing
1617 modules. These properties are intended for use by the module system and
1618 associated functionality. In particular, more properties may be available by
1621 @subsection module-properties-naming Naming properties
1623 When creating properties for use with the module system, they should be
1624 prefixed with `INTERFACE_vtk_module_`. The `INTERFACE_` portion is required in
1625 order to work with interface libraries. The `vtk_module_` portion is to avoid
1626 colliding with any other properties. This function assumes this naming scheme
1627 for some of its convenience features as well.
1629 Properties should be the same in the local build as well as when imported to
1632 @subsection module-properties-system VTK module system properties
1634 There are a number of properties that are used and expected by the core of the
1635 module system. These are generally module metadata (module dependencies,
1636 whether to wrap or not, etc.). The properties all have the
1637 `INTERFACE_vtk_module_` prefix mentioned in the previous section.
1639 * `third_party`: If set, the module represents a third party
1640 dependency and should be treated specially. Third party modules are very
1641 restricted and generally do not have any other properties set on them.
1642 * `exclude_wrap`: If set, the module should not be wrapped by an external
1644 * `depends`: The list of dependent modules. Language wrappers will generally
1645 require this to satisfy references to parent classes of the classes in the
1647 * `private_depends`: The list of privately dependent modules. Language
1648 wrappers may require this to satisfy references to parent classes of the
1649 classes in the module.
1650 * `optional_depends`: The list of optionally dependent modules. Language
1651 wrappers may require this to satisfy references to parent classes of the
1652 classes in the module.
1653 * `kit`: The kit the module is a member of. Only set if the module is
1654 actually a member of the kit (i.e., the module was built with
1655 `BUILD_WITH_KITS ON`).
1656 * `implements`: The list of modules for which this module registers to. This
1657 is used by the autoinit subsystem and generally is not required.
1658 * `implementable`: If set, this module provides registries which may be
1659 populated by dependent modules. It is used to check the `implements`
1660 property to help minimize unnecessary work from the autoinit subsystem.
1661 * `needs_autoinit`: If set, linking to this module requires the autoinit
1662 subsystem to ensure that registries in modules are fully populated.
1663 * `headers`: Paths to the public headers from the module. These are the
1664 headers which should be handled by language wrappers.
1665 * `hierarchy`: The path to the hierarchy file describing inheritance of the
1666 classes for use in language wrappers.
1667 * `forward_link`: Usage requirements that must be forwarded even though the
1668 module is linked to privately.
1670 Kits have the following properties available (but only if kits are enabled):
1672 * `kit_modules`: Modules which are compiled into the kit.
1676 @ingroup module-internal
1677 @brief Set a module property
1679 This function sets a [module property](@ref module-properties) on a module. The
1680 required prefix will automatically be added to the passed name.
1683 _vtk_module_set_module_property(<module>
1684 [APPEND] [APPEND_STRING]
1689 function (_vtk_module_set_module_property module)
1690 cmake_parse_arguments(_vtk_property
1691 "APPEND;APPEND_STRING
"
1696 if (_vtk_property_UNPARSED_ARGUMENTS)
1698 "Unparsed arguments
for vtk_module_set_module_property:
"
1699 "${_vtk_property_UNPARSED_ARGUMENTS}.
")
1702 if (NOT DEFINED _vtk_property_PROPERTY)
1704 "The `PROPERTY` argument is required.
")
1707 if (NOT DEFINED _vtk_property_VALUE)
1709 "The `VALUE` argument is required.
")
1712 if (_vtk_property_APPEND AND _vtk_property_APPEND_STRING)
1714 "`APPEND` and `APPEND_STRING` may not be used at the same
time.
")
1717 set(_vtk_property_args)
1718 if (_vtk_property_APPEND)
1719 list(APPEND _vtk_property_args
1722 if (_vtk_property_APPEND_STRING)
1723 list(APPEND _vtk_property_args
1727 get_property(_vtk_property_is_alias
1729 PROPERTY ALIASED_TARGET
1731 if (_vtk_property_is_alias)
1732 _vtk_module_real_target(_vtk_property_target "${module}
")
1734 set(_vtk_property_target "${module}
")
1737 set_property(TARGET "${_vtk_property_target}
"
1738 ${_vtk_property_args}
1740 "INTERFACE_vtk_module_${_vtk_property_PROPERTY}
" "${_vtk_property_VALUE}
")
1744 @ingroup module-internal
1745 @brief Get a module property
1747 Get a [module property](@ref module-properties) from a module.
1750 _vtk_module_get_module_property(<module>
1752 VARIABLE <variable>)
1755 As with @ref vtk_module_get_property, the output variable will be unset if the
1756 property is not set. The property name is automatically prepended with the
1759 function (_vtk_module_get_module_property module)
1760 cmake_parse_arguments(_vtk_property
1766 if (_vtk_property_UNPARSED_ARGUMENTS)
1768 "Unparsed arguments
for vtk_module_get_module_property:
"
1769 "${_vtk_property_UNPARSED_ARGUMENTS}.
")
1772 if (NOT DEFINED _vtk_property_PROPERTY)
1774 "The `PROPERTY` argument is required.
")
1777 if (NOT DEFINED _vtk_property_VARIABLE)
1779 "The `VARIABLE` argument is required.
")
1782 get_property(_vtk_property_is_alias
1784 PROPERTY ALIASED_TARGET
1786 if (_vtk_property_is_alias)
1787 _vtk_module_real_target(_vtk_property_target "${module}
")
1789 set(_vtk_property_target "${module}
")
1792 get_property(_vtk_property_is_set
1793 TARGET "${_vtk_property_target}
"
1794 PROPERTY "INTERFACE_vtk_module_${_vtk_property_PROPERTY}
"
1796 if (_vtk_property_is_set)
1797 get_property(_vtk_property_value
1798 TARGET "${_vtk_property_target}
"
1799 PROPERTY "INTERFACE_vtk_module_${_vtk_property_PROPERTY}
")
1801 set("${_vtk_property_VARIABLE}
"
1802 "${_vtk_property_value}
"
1805 unset("${_vtk_property_VARIABLE}
"
1811 @ingroup module-internal
1812 @brief Check that destinations are valid
1814 All installation destinations are expected to be relative so that
1815 `CMAKE_INSTALL_PREFIX` can be relied upon in all code paths. This function may
1816 be used to verify that destinations are relative.
1819 _vtk_module_check_destinations(<prefix> [<suffix>...])
1822 For each `suffix`, `prefix` is prefixed to it and the resulting variable name
1823 is checked for validity as an install prefix. Raises an error if any is
1826 function (_vtk_module_check_destinations prefix)
1827 foreach (suffix IN LISTS ARGN)
1828 if (IS_ABSOLUTE "${${prefix}${suffix}}
")
1830 "The `${suffix}` must not be an absolute path. Use
"
1831 "`CMAKE_INSTALL_PREFIX` to keep everything in a single installation
"
1838 @ingroup module-internal
1839 @brief Write an import prefix statement
1841 CMake files, once installed, may need to construct paths to other locations
1842 within the install prefix. This function writes a prefix computation for file
1843 given its install destination.
1846 _vtk_module_write_import_prefix(<file> <destination>)
1849 The passed file is cleared so that it occurs at the top of the file. The prefix
1850 is available in the file as the `_vtk_module_import_prefix` variable. It is
1851 recommended to unset the variable at the end of the file.
1853 function (_vtk_module_write_import_prefix file destination)
1854 if (IS_ABSOLUTE "${destination}
")
1856 "An
import prefix cannot be determined from an absolute installation
"
1857 "destination. Use `CMAKE_INSTALL_PREFIX` to keep everything in a single
"
1858 "installation prefix.
")
1861 file(WRITE "${file}
"
1862 "set(_vtk_module_import_prefix \
"\${CMAKE_CURRENT_LIST_DIR}\")\n")
1864 get_filename_component(destination
"${destination}" DIRECTORY)
1865 file(APPEND
"${file}"
1866 "get_filename_component(_vtk_module_import_prefix \"\${_vtk_module_import_prefix}\" DIRECTORY)\n")
1871 @ingroup module-
internal
1872 @brief Export properties
on modules and targets
1874 This
function is intended
for use in support functions which leverage the
1875 module system, not by general system users. This
function supports exporting
1876 properties from the build into dependencies via
target properties which are
1877 loaded from a project
's config file which is loaded via CMake's `find_package`
1886 [PROPERTIES <property>...]
1887 [FROM_GLOBAL_PROPERTIES <property fragment>...]
1888 [SPLIT_INSTALL_PROPERTIES <property fragment>...])
1891 The `BUILD_FILE` and `INSTALL_FILE` arguments are required. Exactly one of
1892 `MODULE` and `KIT` is also required. The `MODULE` or `KIT` argument holds the
1893 name of the module or kit that will have properties exported. The `BUILD_FILE`
1894 and `INSTALL_FILE` paths are *appended to*. As such, when setting up these
1895 files, it should be preceded with:
1898 file(WRITE
"${build_file}")
1899 file(WRITE
"${install_file}")
1902 To avoid accidental usage of the install file from the build tree, it is
1903 recommended to store it under a `CMakeFiles/` directory in the build tree with
1904 an additional `.install` suffix and use `install(RENAME)` to rename it at
1907 The set of properties exported is computed as follows:
1909 * `PROPERTIES` queries the module
target for the given
property and exports
1910 its
value as-is to both the build and install files. In addition, these
1911 properties are set
on the
target directly as the same
name.
1912 * `FROM_GLOBAL_PROPERTIES` queries the
global
1913 `_vtk_module_<MODULE>_<fragment>`
property and exports it to both the build
1914 and install files as `INTERFACE_vtk_module_<fragment>`.
1915 * `SPLIT_INSTALL_PROPERTIES` queries the
target for
1916 `INTERFACE_vtk_module_<fragment>` and exports its
value to the build file
1917 and `INTERFACE_vtk_module_<fragment>_install` to the install file as the
1918 non-install
property name. This is generally useful
for properties which
1919 change between the build and installation.
1922 cmake_parse_arguments(_vtk_export_properties
1924 "BUILD_FILE;INSTALL_FILE;MODULE;KIT"
1925 "FROM_GLOBAL_PROPERTIES;PROPERTIES;SPLIT_INSTALL_PROPERTIES"
1928 if (_vtk_export_properties_UNPARSED_ARGUMENTS)
1930 "Unparsed arguments for _vtk_export_properties: "
1931 "${_vtk_export_properties_UNPARSED_ARGUMENTS}.")
1934 if (DEFINED _vtk_export_properties_MODULE)
1935 if (DEFINED _vtk_export_properties_KIT)
1937 "Only one of `MODULE` or `KIT` is required to export properties.")
1939 set(_vtk_export_properties_type "module")
1940 set(_vtk_export_properties_name "${_vtk_export_properties_MODULE}
")
1941 elseif (_vtk_export_properties_KIT)
1942 set(_vtk_export_properties_type "kit
")
1943 set(_vtk_export_properties_name "${_vtk_export_properties_KIT}
")
1946 "A module or kit is required to export properties.
")
1949 if (NOT _vtk_export_properties_BUILD_FILE)
1951 "Exporting properties requires a build file to write to.
")
1954 if (NOT _vtk_export_properties_INSTALL_FILE)
1956 "Exporting properties requires an install file to write to.
")
1959 if (_vtk_export_properties_type STREQUAL "module
")
1960 _vtk_module_real_target(_vtk_export_properties_target_name "${_vtk_export_properties_name}
")
1961 elseif (_vtk_export_properties_type STREQUAL "kit
")
1962 _vtk_module_real_target_kit(_vtk_export_properties_target_name "${_vtk_export_properties_name}
")
1965 foreach (_vtk_export_properties_global IN LISTS _vtk_export_properties_FROM_GLOBAL_PROPERTIES)
1966 get_property(_vtk_export_properties_is_set GLOBAL
1967 PROPERTY "_vtk_${_vtk_export_properties_type}_${_vtk_export_properties_name}_${_vtk_export_properties_global}
"
1969 if (NOT _vtk_export_properties_is_set)
1973 get_property(_vtk_export_properties_value GLOBAL
1974 PROPERTY "_vtk_${_vtk_export_properties_type}_${_vtk_export_properties_name}_${_vtk_export_properties_global}
")
1975 set(_vtk_export_properties_set_property
1976 "set_property(TARGET \
"${_vtk_export_properties_name}\" PROPERTY \"INTERFACE_vtk_${_vtk_export_properties_type}_${_vtk_export_properties_global}\" \"${_vtk_export_properties_value}\")\n")
1978 set_property(TARGET
"${_vtk_export_properties_target_name}"
1980 "INTERFACE_vtk_${_vtk_export_properties_type}_${_vtk_export_properties_global}" "${_vtk_export_properties_value}")
1981 file(APPEND
"${_vtk_export_properties_BUILD_FILE}"
1982 "${_vtk_export_properties_set_property}")
1983 file(APPEND
"${_vtk_export_properties_INSTALL_FILE}"
1984 "${_vtk_export_properties_set_property}")
1987 foreach (_vtk_export_properties_target IN LISTS _vtk_export_properties_PROPERTIES)
1988 get_property(_vtk_export_properties_is_set
1989 TARGET "${_vtk_export_properties_target_name}
"
1990 PROPERTY "${_vtk_export_properties_target}
"
1992 if (NOT _vtk_export_properties_is_set)
1996 get_property(_vtk_export_properties_value
1997 TARGET "${_vtk_export_properties_target_name}
"
1998 PROPERTY "${_vtk_export_properties_target}
")
1999 set(_vtk_export_properties_set_property
2000 "set_property(TARGET \
"${_vtk_export_properties_name}\" PROPERTY \"${_vtk_export_properties_target}\" \"${_vtk_export_properties_value}\")\n")
2002 file(APPEND
"${_vtk_export_properties_BUILD_FILE}"
2003 "${_vtk_export_properties_set_property}")
2004 file(APPEND
"${_vtk_export_properties_INSTALL_FILE}"
2005 "${_vtk_export_properties_set_property}")
2008 foreach (_vtk_export_properties_split IN LISTS _vtk_export_properties_SPLIT_INSTALL_PROPERTIES)
2009 get_property(_vtk_export_properties_is_set
2010 TARGET "${_vtk_export_properties_target_name}
"
2011 PROPERTY "INTERFACE_vtk_${_vtk_export_properties_type}_${_vtk_export_properties_split}
"
2013 if (NOT _vtk_export_properties_is_set)
2017 get_property(_vtk_export_properties_value
2018 TARGET "${_vtk_export_properties_target_name}
"
2019 PROPERTY "INTERFACE_vtk_${_vtk_export_properties_type}_${_vtk_export_properties_split}
")
2020 set(_vtk_export_properties_set_property
2021 "set_property(TARGET \
"${_vtk_export_properties_name}\" PROPERTY \"INTERFACE_vtk_module_${_vtk_export_properties_split}\" \"${_vtk_export_properties_value}\")\n")
2022 file(APPEND
"${_vtk_export_properties_BUILD_FILE}"
2023 "${_vtk_export_properties_set_property}")
2025 get_property(_vtk_export_properties_value
2026 TARGET
"${_vtk_export_properties_target_name}"
2027 PROPERTY
"INTERFACE_vtk_${_vtk_export_properties_type}_${_vtk_export_properties_split}_install")
2028 set(_vtk_export_properties_set_property
2029 "set_property(TARGET \"${_vtk_export_properties_name}\" PROPERTY \"INTERFACE_vtk_module_${_vtk_export_properties_split}\" \"${_vtk_export_properties_value}\")\n")
2030 file(APPEND
"${_vtk_export_properties_INSTALL_FILE}"
2031 "${_vtk_export_properties_set_property}")
2035 include("${CMAKE_CURRENT_LIST_DIR}/vtkModuleTesting.cmake
")
2039 @brief Build modules and kits
2041 Once all of the modules have been scanned, they need to be built. Generally,
2042 there will be just one build necessary for a set of scans, though they may be
2043 built distinctly as well. If there are multiple calls to this function, they
2044 should generally in reverse order of their scans.
2051 [LIBRARY_NAME_SUFFIX <suffix>]
2053 [SOVERSION <soversion>]
2057 [BUILD_WITH_KITS <ON|OFF>]
2059 [ENABLE_WRAPPING <ON|OFF>]
2061 [USE_EXTERNAL <ON|OFF>]
2063 [INSTALL_HEADERS <ON|OFF>]
2064 [HEADERS_COMPONENT <component>]
2066 [TARGETS_COMPONENT <component>]
2067 [INSTALL_EXPORT <export>]
2069 [TEST_DIRECTORY_NAME <name>]
2070 [TEST_DATA_TARGET <target>]
2071 [TEST_INPUT_DATA_DIRECTORY <directory>]
2072 [TEST_OUTPUT_DATA_DIRECTORY <directory>]
2073 [TEST_OUTPUT_DIRECTORY <directory>]
2075 [ARCHIVE_DESTINATION <destination>]
2076 [HEADERS_DESTINATION <destination>]
2077 [LIBRARY_DESTINATION <destination>]
2078 [RUNTIME_DESTINATION <destination>]
2079 [CMAKE_DESTINATION <destination>]
2080 [LICENSE_DESTINATION <destination>]
2081 [HIERARCHY_DESTINATION <destination>])
2084 The only requirement of the function is the list of modules to build, the rest
2085 have reasonable defaults if not specified.
2087 * `MODULES`: (Required) The list of modules to build.
2088 * `KITS`: (Required if `BUILD_WITH_KITS` is `ON`) The list of kits to build.
2089 * `LIBRARY_NAME_SUFFIX`: (Defaults to `""`) A suffix to add to library names.
2090 If it is not empty, it is prefixed with `-` to separate it from the kit
2092 * `VERSION`: If specified, the `VERSION` property on built libraries will be
2094 * `SOVERSION`: If specified, the `SOVERSION` property on built libraries will
2095 be set to this value.
2096 * `PACKAGE`: (Defaults to `${CMAKE_PROJECT_NAME}`) The name the build is
2097 meant to be found as when using `find_package`. Note that separate builds
2098 will require distinct `PACKAGE` values.
2099 * `BUILD_WITH_KITS`: (Defaults to `OFF`) If enabled, kit libraries will be
2101 * `ENABLE_WRAPPING`: (Default depends on the existence of
2102 `VTK::WrapHierarchy` or `VTKCompileTools::WrapHierarchy` targets) If
2103 enabled, wrapping will be available to the modules built in this call.
2104 * `USE_EXTERNAL`: (Defaults to `OFF`) Whether third party modules should find
2105 external copies rather than building their own copy.
2106 * `INSTALL_HEADERS`: (Defaults to `ON`) Whether or not to install public headers.
2107 * `HEADERS_COMPONENT`: (Defaults to `development`) The install component to
2108 use for header installation. Note that other SDK-related bits use the same
2109 component (e.g., CMake module files).
2110 * `TARGETS_COMPONENT`: `Defaults to `runtime`) The install component to use
2111 for the libraries built.
2112 * `TARGET_NAMESPACE`: `Defaults to `<AUTO>`) The namespace for installed
2113 targets. All targets must have the same namespace. If set to `<AUTO>`,
2114 the namespace will be detected automatically.
2115 * `INSTALL_EXPORT`: (Defaults to `""`) If non-empty, targets will be added to
2116 the given export. The export will also be installed as part of this build
2118 * `TEST_DIRECTORY_NAME`: (Defaults to `Testing`) The name of the testing
2119 directory to look for in each module. Set to `NONE` to disable automatic
2121 * `TEST_DATA_TARGET`: (Defaults to `<PACKAGE>-data`) The target to add
2122 testing data download commands to.
2123 * `TEST_INPUT_DATA_DIRECTORY`: (Defaults to
2124 `${CMAKE_CURRENT_SOURCE_DIR}/Data`) The directory which will contain data
2126 * `TEST_OUTPUT_DATA_DIRECTORY`: (Defaults to
2127 `${CMAKE_CURRENT_BINARY_DIR}/Data`) The directory which will contain data
2129 * `TEST_OUTPUT_DIRECTORY`: (Defaults to
2130 `${CMAKE_BINARY_DIR}/<TEST_DIRECTORY_NAME>/Temporary`) The directory which
2131 tests may write any output files to.
2133 The remaining arguments control where to install files related to the build.
2134 See CMake documentation for the difference between `ARCHIVE`, `LIBRARY`, and
2137 * `ARCHIVE_DESTINATION`: (Defaults to `${CMAKE_INSTALL_LIBDIR}`) The install
2138 destination for archive files.
2139 * `HEADERS_DESTINATION`: (Defaults to `${CMAKE_INSTALL_INCLUDEDIR}`) The
2140 install destination for header files.
2141 * `LIBRARY_DESTINATION`: (Defaults to `${CMAKE_INSTALL_LIBDIR}`) The install
2142 destination for library files.
2143 * `RUNTIME_DESTINATION`: (Defaults to `${CMAKE_INSTALL_BINDIR}`) The install
2144 destination for runtime files.
2145 * `CMAKE_DESTINATION`: (Defaults to `<library destination>/cmake/<package>`)
2146 The install destination for CMake files.
2147 * `LICENSE_DESTINATION`: (Defaults to `${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}`)
2148 The install destination for license files (relevant for third party
2150 * `HIERARCHY_DESTINATION`: (Defaults to `<library
2151 destination>/vtk/hierarchy/<PACKAGE>`) The install destination
2152 for hierarchy files (used for language wrapping).
2154 function (vtk_module_build)
2155 set(_vtk_build_install_arguments
2172 HIERARCHY_DESTINATION)
2173 set(_vtk_build_test_arguments
2177 TEST_INPUT_DATA_DIRECTORY
2178 TEST_OUTPUT_DATA_DIRECTORY
2179 TEST_OUTPUT_DIRECTORY)
2181 # TODO: Add an option to build statically? Currently, `BUILD_SHARED_LIBS` is
2184 cmake_parse_arguments(_vtk_build
2186 "BUILD_WITH_KITS;USE_EXTERNAL;LIBRARY_NAME_SUFFIX;VERSION;SOVERSION;PACKAGE;ENABLE_WRAPPING;${_vtk_build_install_arguments};${_vtk_build_test_arguments}
"
2190 if (_vtk_build_UNPARSED_ARGUMENTS)
2193 "${_vtk_build_UNPARSED_ARGUMENTS}
")
2196 if (NOT DEFINED _vtk_build_USE_EXTERNAL)
2197 set(_vtk_build_USE_EXTERNAL OFF)
2200 if (NOT DEFINED _vtk_build_PACKAGE)
2201 set(_vtk_build_PACKAGE "${CMAKE_PROJECT_NAME}
")
2203 get_property(_vtk_build_package_exists GLOBAL
2204 PROPERTY "_vtk_module_package_${_vtk_build_PACKAGE}
"
2206 if (_vtk_build_package_exists)
2208 "A set of modules have already been built
using the
"
2209 "`${_vtk_build_PACKAGE}` package.
")
2213 "_vtk_module_package_${_vtk_build_PACKAGE}
" "ON
")
2216 if (NOT DEFINED _vtk_build_INSTALL_HEADERS)
2217 set(_vtk_build_INSTALL_HEADERS ON)
2220 if (NOT DEFINED _vtk_build_ENABLE_WRAPPING)
2221 if (TARGET "VTKCompileTools::WrapHierarchy
" OR
2222 TARGET "VTK::WrapHierarchy
")
2223 set(_vtk_build_ENABLE_WRAPPING ON)
2225 set(_vtk_build_ENABLE_WRAPPING OFF)
2229 if (NOT DEFINED _vtk_build_TARGET_NAMESPACE)
2230 set(_vtk_build_TARGET_NAMESPACE "<AUTO>
")
2233 if (NOT DEFINED _vtk_build_BUILD_WITH_KITS)
2234 set(_vtk_build_BUILD_WITH_KITS OFF)
2237 if (_vtk_build_BUILD_WITH_KITS AND CMAKE_VERSION VERSION_LESS "3.12
")
2239 "Building with kits
enabled requires CMake 3.12 which introduced
"
2240 "support
for OBJECT libraries to have and utilize usage requirements.
")
2243 if (_vtk_build_BUILD_WITH_KITS AND NOT DEFINED _vtk_build_KITS)
2245 "Building with kits was requested, but no kits were specified.
")
2248 if (NOT DEFINED _vtk_build_TEST_DIRECTORY_NAME)
2249 set(_vtk_build_TEST_DIRECTORY_NAME "Testing
")
2252 if (NOT DEFINED _vtk_build_TEST_DATA_TARGET)
2253 set(_vtk_build_TEST_DATA_TARGET "${_vtk_build_PACKAGE}-
data")
2256 if (NOT DEFINED _vtk_build_TEST_INPUT_DATA_DIRECTORY)
2257 set(_vtk_build_TEST_INPUT_DATA_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Data
")
2260 if (NOT DEFINED _vtk_build_TEST_OUTPUT_DATA_DIRECTORY)
2261 set(_vtk_build_TEST_OUTPUT_DATA_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/Data
")
2264 if (NOT DEFINED _vtk_build_TEST_OUTPUT_DIRECTORY)
2265 set(_vtk_build_TEST_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${_vtk_build_TEST_DIRECTORY_NAME}/Temporary
")
2268 if (NOT DEFINED _vtk_build_HEADERS_COMPONENT)
2269 set(_vtk_build_HEADERS_COMPONENT "development
")
2272 if (NOT DEFINED _vtk_build_ARCHIVE_DESTINATION)
2273 set(_vtk_build_ARCHIVE_DESTINATION "${CMAKE_INSTALL_LIBDIR}
")
2276 if (NOT DEFINED _vtk_build_HEADERS_DESTINATION)
2277 set(_vtk_build_HEADERS_DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}
")
2280 if (NOT DEFINED _vtk_build_LIBRARY_DESTINATION)
2281 set(_vtk_build_LIBRARY_DESTINATION "${CMAKE_INSTALL_LIBDIR}
")
2284 if (NOT DEFINED _vtk_build_RUNTIME_DESTINATION)
2285 set(_vtk_build_RUNTIME_DESTINATION "${CMAKE_INSTALL_BINDIR}
")
2288 if (NOT DEFINED _vtk_build_CMAKE_DESTINATION)
2289 set(_vtk_build_CMAKE_DESTINATION "${_vtk_build_LIBRARY_DESTINATION}/cmake/${_vtk_build_PACKAGE}
")
2292 if (NOT DEFINED _vtk_build_LICENSE_DESTINATION)
2293 set(_vtk_build_LICENSE_DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/licenses/${CMAKE_PROJECT_NAME}
")
2296 if (NOT DEFINED _vtk_build_HIERARCHY_DESTINATION)
2297 set(_vtk_build_HIERARCHY_DESTINATION "${_vtk_build_LIBRARY_DESTINATION}/
vtk/hierarchy/${_vtk_build_PACKAGE}
")
2300 if (NOT DEFINED _vtk_build_TARGETS_COMPONENT)
2301 set(_vtk_build_TARGETS_COMPONENT "runtime
")
2304 if (NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
2305 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${_vtk_build_ARCHIVE_DESTINATION}
")
2307 if (NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
2308 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${_vtk_build_LIBRARY_DESTINATION}
")
2310 if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
2311 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${_vtk_build_RUNTIME_DESTINATION}
")
2314 if (NOT _vtk_build_MODULES)
2316 "No modules given to build.
")
2319 _vtk_module_check_destinations(_vtk_build_
2325 HIERARCHY_DESTINATION)
2327 foreach (_vtk_build_module IN LISTS _vtk_build_MODULES)
2328 get_property("_vtk_build_${_vtk_build_module}_depends
" GLOBAL
2329 PROPERTY "_vtk_module_${_vtk_build_module}_depends
")
2330 get_property("_vtk_build_${_vtk_build_module}_private_depends
" GLOBAL
2331 PROPERTY "_vtk_module_${_vtk_build_module}_private_depends
")
2332 get_property("_vtk_build_${_vtk_build_module}_optional_depends
" GLOBAL
2333 PROPERTY "_vtk_module_${_vtk_build_module}_optional_depends
")
2334 get_property("_vtk_build_${_vtk_build_module}_order_depends
" GLOBAL
2335 PROPERTY "_vtk_module_${_vtk_build_module}_order_depends
")
2336 set("_vtk_build_${_vtk_build_module}_all_depends
"
2337 ${_vtk_build_${_vtk_build_module}_depends}
2338 ${_vtk_build_${_vtk_build_module}_private_depends}
2339 ${_vtk_build_${_vtk_build_module}_optional_depends}
2340 ${_vtk_build_${_vtk_build_module}_order_depends})
2343 set(_vtk_build_sorted_modules "${_vtk_build_MODULES}
")
2344 vtk_topological_sort(_vtk_build_sorted_modules "_vtk_build_
" "_all_depends
")
2346 foreach (_vtk_build_module IN LISTS _vtk_build_sorted_modules)
2347 if (NOT _vtk_build_module IN_LIST _vtk_build_MODULES)
2351 if (TARGET "${_vtk_build_module}
")
2352 get_property(_vtk_build_is_imported
2353 TARGET "${_vtk_build_module}
"
2356 # TODO: Is this right?
2357 if (NOT _vtk_build_is_imported)
2359 "The ${_vtk_build_module} module has been requested to be built, but
"
2360 "it is already built by
this project.
")
2366 foreach (_vtk_build_depend IN LISTS "_vtk_build_${_vtk_build_module}_depends
" "_vtk_build_${_vtk_build_module}_private_depends
")
2367 if (NOT TARGET "${_vtk_build_depend}
")
2369 "The ${_vtk_build_depend} dependency is missing
for ${_vtk_build_module}.
")
2373 get_property(_vtk_build_module_file GLOBAL
2374 PROPERTY "_vtk_module_${_vtk_build_module}_file
")
2375 if (NOT _vtk_build_module_file)
2377 "The requested ${_vtk_build_module} module is not a VTK module.
")
2380 _vtk_module_debug(building "@_vtk_build_module@ is being built
")
2382 get_filename_component(_vtk_build_module_dir "${_vtk_build_module_file}
" DIRECTORY)
2383 file(RELATIVE_PATH _vtk_build_module_subdir "${CMAKE_SOURCE_DIR}
" "${_vtk_build_module_dir}
")
2385 "${CMAKE_SOURCE_DIR}/${_vtk_build_module_subdir}
"
2386 "${CMAKE_BINARY_DIR}/${_vtk_build_module_subdir}
")
2388 if (NOT TARGET "${_vtk_build_module}
")
2390 "The ${_vtk_build_module} is being built, but a matching
target was
"
2395 if (_vtk_build_BUILD_WITH_KITS)
2396 foreach (_vtk_build_kit IN LISTS _vtk_build_KITS)
2397 get_property(_vtk_build_target_name GLOBAL
2398 PROPERTY "_vtk_kit_${_vtk_build_kit}_target_name
")
2399 set(_vtk_kit_source_file
2400 "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/vtk_module_kit_${_vtk_build_target_name}.c
")
2402 OUTPUT "${_vtk_kit_source_file}
"
2403 CONTENT "void vtk_module_kit_${_vtk_build_target_name}() {}\n
")
2404 add_library("${_vtk_build_target_name}
"
2405 "${_vtk_kit_source_file}
")
2406 get_property(_vtk_build_namespace GLOBAL
2407 PROPERTY "_vtk_kit_${_vtk_build_kit}_namespace
")
2408 if (_vtk_build_TARGET_NAMESPACE STREQUAL "<AUTO>
")
2409 set(_vtk_build_TARGET_NAMESPACE "${_vtk_build_namespace}
")
2411 if (NOT _vtk_build_namespace STREQUAL _vtk_build_TARGET_NAMESPACE)
2413 "The `TARGET_NAMESPACE` (${_vtk_build_TARGET_NAMESPACE}) is not the
"
2414 "same as the ${_vtk_build_kit} kit
namespace "
2415 "(${_vtk_build_namespace}).
")
2417 if (NOT _vtk_build_kit STREQUAL _vtk_build_target_name)
2418 add_library("${_vtk_build_kit}
" ALIAS
2419 "${_vtk_build_target_name}
")
2421 _vtk_module_apply_properties("${_vtk_build_target_name}
")
2422 _vtk_module_install("${_vtk_build_target_name}
")
2424 set(_vtk_build_kit_modules_object_libraries)
2425 set(_vtk_build_kit_modules_private_depends)
2427 get_property(_vtk_build_kit_modules GLOBAL
2428 PROPERTY "_vtk_kit_${_vtk_build_kit}_kit_modules
")
2429 foreach (_vtk_build_kit_module IN LISTS _vtk_build_kit_modules)
2430 get_property(_vtk_build_kit_module_target_name GLOBAL
2431 PROPERTY "_vtk_module_${_vtk_build_kit_module}_target_name
")
2432 list(APPEND _vtk_build_kit_modules_object_libraries
2433 "${_vtk_build_kit_module_target_name}-objects
")
2435 # Since there is no link step for modules, we need to copy the private
2436 # dependencies of the constituent modules into the kit so that their
2437 # private dependencies are actually linked.
2438 get_property(_vtk_build_kit_module_private_depends GLOBAL
2439 PROPERTY "_vtk_module_${_vtk_build_kit_module}_private_depends
")
2440 # Also grab optional dependencies since they end up being private
2442 get_property(_vtk_build_kit_module_optional_depends GLOBAL
2443 PROPERTY "_vtk_module_${_vtk_build_kit_module}_optional_depends
")
2444 foreach (_vtk_build_kit_module_private_depend IN LISTS _vtk_build_kit_module_private_depends _vtk_build_kit_module_optional_depends)
2445 if (NOT TARGET "${_vtk_build_kit_module_private_depend}
")
2449 # But we don't need to link to modules that are part of the kit we are
2451 if (NOT _vtk_build_kit_module_private_depend IN_LIST _vtk_build_kit_modules)
2452 list(APPEND _vtk_build_kit_modules_private_depends
2453 "$<LINK_ONLY:${_vtk_build_kit_module_private_depend}>
")
2458 get_property(_vtk_build_kit_private_links GLOBAL
2459 PROPERTY "_vtk_kit_${_vtk_build_kit}_private_links
")
2461 if (_vtk_build_kit_modules_private_depends)
2462 list(REMOVE_DUPLICATES _vtk_build_kit_modules_private_depends)
2464 if (_vtk_build_kit_modules_private_links)
2465 list(REMOVE_DUPLICATES _vtk_build_kit_modules_private_links)
2468 target_link_libraries("${_vtk_build_target_name}
"
2470 ${_vtk_build_kit_modules_object_libraries}
2471 ${_vtk_build_kit_modules_private_depends}
2472 ${_vtk_build_kit_private_links})
2473 get_property(_vtk_build_kit_library_name GLOBAL
2474 PROPERTY "_vtk_kit_${_vtk_build_kit}_library_name
")
2475 if (_vtk_build_LIBRARY_NAME_SUFFIX)
2476 string(APPEND _vtk_build_kit_library_name "-${_vtk_build_LIBRARY_NAME_SUFFIX}
")
2478 set_target_properties("${_vtk_build_target_name}
"
2480 OUTPUT_NAME "${_vtk_build_kit_library_name}
")
2484 set(_vtk_build_properties_filename "${_vtk_build_PACKAGE}-
vtk-module-properties.cmake
")
2485 set(_vtk_build_properties_install_file "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_build_properties_filename}.install
")
2486 set(_vtk_build_properties_build_file "${CMAKE_BINARY_DIR}/${_vtk_build_CMAKE_DESTINATION}/${_vtk_build_properties_filename}
")
2488 file(WRITE "${_vtk_build_properties_build_file}
")
2490 _vtk_module_write_import_prefix(
2491 "${_vtk_build_properties_install_file}
"
2492 "${_vtk_build_CMAKE_DESTINATION}
")
2494 foreach (_vtk_build_module IN LISTS _vtk_build_MODULES)
2495 get_property(_vtk_build_namespace GLOBAL
2496 PROPERTY "_vtk_module_${_vtk_build_module}_namespace
")
2497 if (_vtk_build_TARGET_NAMESPACE STREQUAL "<AUTO>
")
2498 set(_vtk_build_TARGET_NAMESPACE "${_vtk_build_namespace}
")
2500 if (NOT _vtk_build_namespace STREQUAL _vtk_build_TARGET_NAMESPACE)
2502 "The `TARGET_NAMESPACE` (${_vtk_build_TARGET_NAMESPACE}) is not the
"
2503 "same as the ${_vtk_build_module} module
namespace "
2504 "(${_vtk_build_namespace}).
")
2507 get_property(_vtk_build_is_third_party
2508 TARGET "${_vtk_build_module}
"
2509 PROPERTY "INTERFACE_vtk_module_third_party
")
2510 if (_vtk_build_is_third_party)
2511 _vtk_module_export_properties(
2512 BUILD_FILE "${_vtk_build_properties_build_file}
"
2513 INSTALL_FILE "${_vtk_build_properties_install_file}
"
2514 MODULE "${_vtk_build_module}
"
2515 FROM_GLOBAL_PROPERTIES
2516 # Export the dependencies of a module.
2520 # The library name of the module.
2523 # Export whether a module is third party or not.
2524 INTERFACE_vtk_module_third_party
2525 INTERFACE_vtk_module_exclude_wrap)
2529 set(_vtk_build_split_properties)
2530 get_property(_vtk_build_exclude_wrap
2531 TARGET "${_vtk_build_module}
"
2532 PROPERTY "INTERFACE_vtk_module_${_vtk_build_module}_exclude_wrap
")
2533 if (NOT _vtk_build_exclude_wrap)
2534 list(APPEND _vtk_build_split_properties
2536 if (_vtk_build_ENABLE_WRAPPING)
2537 list(APPEND _vtk_build_split_properties
2542 set(_vtk_build_properties_kit_properties)
2543 if (_vtk_build_BUILD_WITH_KITS)
2544 list(APPEND _vtk_build_properties_kit_properties
2545 # Export the kit membership of a module.
2549 _vtk_module_export_properties(
2550 BUILD_FILE "${_vtk_build_properties_build_file}
"
2551 INSTALL_FILE "${_vtk_build_properties_install_file}
"
2552 MODULE "${_vtk_build_module}
"
2553 FROM_GLOBAL_PROPERTIES
2554 # Export whether the module should be excluded from wrapping or not.
2556 # Export the dependencies of a module.
2560 # Export what modules are implemented by the module.
2562 # Export whether the module contains autoinit logic.
2564 # The library name of the module.
2566 ${_vtk_build_properties_kit_properties}
2568 # Export whether the module needs autoinit logic handled.
2569 INTERFACE_vtk_module_needs_autoinit
2570 # Forward private usage requirements with global effects.
2571 INTERFACE_vtk_module_forward_link
2572 SPLIT_INSTALL_PROPERTIES
2573 # Set the properties which differ between build and install trees.
2574 ${_vtk_build_split_properties})
2577 if (_vtk_build_BUILD_WITH_KITS)
2578 foreach (_vtk_build_kit IN LISTS _vtk_build_KITS)
2579 _vtk_module_export_properties(
2580 BUILD_FILE "${_vtk_build_properties_build_file}
"
2581 INSTALL_FILE "${_vtk_build_properties_install_file}
"
2582 KIT "${_vtk_build_kit}
"
2583 FROM_GLOBAL_PROPERTIES
2584 # Export the list of modules in the kit.
2589 if (_vtk_build_INSTALL_EXPORT AND _vtk_build_INSTALL_HEADERS)
2590 set(_vtk_build_namespace)
2591 if (_vtk_build_TARGET_NAMESPACE)
2592 set(_vtk_build_namespace
2593 NAMESPACE "${_vtk_build_TARGET_NAMESPACE}::
")
2597 EXPORT "${_vtk_build_INSTALL_EXPORT}
"
2598 ${_vtk_build_namespace}
2599 FILE "${CMAKE_BINARY_DIR}/${_vtk_build_CMAKE_DESTINATION}/${_vtk_build_PACKAGE}-targets.cmake
")
2601 EXPORT "${_vtk_build_INSTALL_EXPORT}
"
2602 DESTINATION "${_vtk_build_CMAKE_DESTINATION}
"
2603 ${_vtk_build_namespace}
2604 FILE "${_vtk_build_PACKAGE}-targets.cmake
"
2605 COMPONENT "${_vtk_build_HEADERS_COMPONENT}
")
2607 if (_vtk_build_INSTALL_HEADERS)
2608 file(APPEND "${_vtk_build_properties_install_file}
"
2609 "unset(_vtk_module_import_prefix)\n
")
2612 FILES "${_vtk_build_properties_install_file}
"
2613 DESTINATION "${_vtk_build_CMAKE_DESTINATION}
"
2614 RENAME "${_vtk_build_properties_filename}
"
2615 COMPONENT "${_vtk_build_HEADERS_COMPONENT}
")
2619 get_property(_vtk_build_test_modules GLOBAL
2620 PROPERTY "_vtk_module_test_modules
")
2621 set(_vtk_build_tests_handled)
2622 foreach (_vtk_build_test IN LISTS _vtk_build_test_modules)
2623 if (NOT _vtk_build_test IN_LIST _vtk_build_MODULES)
2626 list(APPEND _vtk_build_tests_handled
2627 "${_vtk_build_test}
")
2629 get_property(_vtk_build_test_depends GLOBAL
2630 PROPERTY "_vtk_module_${_vtk_build_test}_test_depends
")
2632 set(_vtk_build_test_has_depends TRUE)
2633 foreach (_vtk_build_test_depend IN LISTS _vtk_build_test_depends)
2634 if (NOT TARGET "${_vtk_build_test_depend}
")
2635 set(_vtk_build_test_has_depends FALSE)
2636 _vtk_module_debug(testing "@_vtk_build_test@ testing disabled due to missing @_vtk_build_test_depend
@")
2639 if (NOT _vtk_build_test_has_depends)
2643 get_property(_vtk_build_module_file GLOBAL
2644 PROPERTY "_vtk_module_${_vtk_build_test}_file
")
2646 if (NOT _vtk_build_TEST_DIRECTORY_NAME STREQUAL "NONE
")
2647 get_filename_component(_vtk_build_module_dir "${_vtk_build_module_file}
" DIRECTORY)
2648 file(RELATIVE_PATH _vtk_build_module_subdir "${CMAKE_SOURCE_DIR}
" "${_vtk_build_module_dir}
")
2649 if (EXISTS "${CMAKE_SOURCE_DIR}/${_vtk_build_module_subdir}/${_vtk_build_TEST_DIRECTORY_NAME}
")
2650 get_property(_vtk_build_test_labels GLOBAL
2651 PROPERTY "_vtk_module_${_vtk_build_test}_test_labels
")
2653 "${CMAKE_SOURCE_DIR}/${_vtk_build_module_subdir}/${_vtk_build_TEST_DIRECTORY_NAME}
"
2654 "${CMAKE_BINARY_DIR}/${_vtk_build_module_subdir}/${_vtk_build_TEST_DIRECTORY_NAME}
")
2659 if (_vtk_build_test_modules AND _vtk_build_tests_handled)
2660 list(REMOVE_ITEM _vtk_build_test_modules
2661 ${_vtk_build_tests_handled})
2664 _vtk_module_test_modules "${_vtk_build_test_modules}
")
2669 @ingroup module-impl
2670 @brief Add "standard
" include directories to a module
2672 Add the "standard
" includes for a module to its interface. These are the source
2673 and build directories for the module itself. They are always either `PUBLIC` or
2674 `INTERFACE` (depending on the module's target type).
2677 _vtk_module_standard_includes(
2681 [HEADERS_DESTINATION <destination>])
2684 function (_vtk_module_standard_includes)
2685 cmake_parse_arguments(_vtk_standard_includes
2687 "TARGET;HEADERS_DESTINATION
"
2691 if (NOT _vtk_standard_includes_TARGET)
2693 "The `TARGET` argument is required.
")
2695 if (NOT TARGET "${_vtk_standard_includes_TARGET}
")
2697 "The `TARGET` argument is not a
target.
")
2700 if (_vtk_standard_includes_UNPARSED_ARGUMENTS)
2702 "Unparsed arguments
for vtk_module_standard_includes:
"
2703 "${_vtk_standard_includes_UNPARSED_ARGUMENTS}
")
2706 set(_vtk_standard_includes_system)
2707 if (_vtk_standard_includes_SYSTEM)
2708 set(_vtk_standard_includes_system SYSTEM)
2711 set(_vtk_standard_includes_visibility PUBLIC)
2712 if (_vtk_standard_includes_INTERFACE)
2713 set(_vtk_standard_includes_visibility INTERFACE)
2716 target_include_directories("${_vtk_standard_includes_TARGET}
"
2717 ${_vtk_standard_includes_system}
2718 "${_vtk_standard_includes_visibility}
"
2719 $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
2720 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
2722 if (_vtk_build_INSTALL_HEADERS AND _vtk_standard_includes_HEADERS_DESTINATION)
2723 target_include_directories("${_vtk_standard_includes_TARGET}
"
2724 ${_vtk_standard_includes_system}
2725 "${_vtk_standard_includes_visibility}
"
2726 $<INSTALL_INTERFACE:${_vtk_standard_includes_HEADERS_DESTINATION}>)
2731 @ingroup module-impl
2732 @brief Determine the default export macro for a module
2734 Determines the export macro to be used for a module from its metadata. Assumes
2735 it is called from within a @ref vtk_module_build call.
2738 _vtk_module_default_library_name(<varname>)
2741 function (_vtk_module_default_export_macro_prefix varname)
2742 get_property(_vtk_module_default_library_name GLOBAL
2743 PROPERTY "_vtk_module_${_vtk_build_module}_library_name
")
2744 string(TOUPPER "${_vtk_module_default_library_name}
" _vtk_default_export_macro_upper)
2746 "${_vtk_default_export_macro_upper}
"
2750 # TODO: It would be nice to support `USE_LINK_PROPERTIES` instead of listing
2751 # the modules again here. However, the format of the `LINK_LIBRARIES` property
2752 # value may not be easy to handle.
2755 @page module-overview
2758 @section module-autoinit Autoinit
2760 When a module contains a factory which may be populated by other modules, these
2761 factories need to be populated when the modules are loaded by the dynamic linker
2762 (for shared builds) or program load time (for static builds). To provide for
2763 this, the module system contains an autoinit "subsystem
".
2765 @subsection module-autoinit-leverage Leveraging the autoinit subsystem
2767 The subsystem provides the following hooks for use by projects:
2769 * In modules which `IMPLEMENTS` other modules, in the generated
2770 `<module>Module.h` header (which provides export symbols as well) will
2771 include the modules which are implemented.
2772 * In modules which are `IMPLEMENTABLE` or `IMPLEMENTS` another module, the
2773 generated `<module>Module.h` file will include the following block:
2776 #ifdef <module>_AUTOINIT_INCLUDE
2777 #include <module>_AUTOINIT_INCLUDE
2779 #ifdef <module>_AUTOINIT
2781 VTK_MODULE_AUTOINIT(<module>)
2785 The @ref vtk_module_autoinit function will generate an include file and provide
2786 its path via the `<module>_AUTOINIT_INCLUDE` define. once it has been included,
2787 if the `<module>_AUTOINIT` symbol is defined, a header is included which is
2788 intended to provide the `VTK_MODULE_AUTOINIT` macro. This macro is given the
2789 module name and should use `<module>_AUTOINIT` to fill in the factories in the
2790 module with those from the `IMPLEMENTS` modules listed in that symbol.
2792 The `<module>_AUTOINIT` symbol's value is:
2795 <count>(<module1>,<module2>,<module3>)
2798 where `<count>` is the number of modules in the parentheses and each module
2799 listed need to register something to `<module>`.
2801 If not provided via the `AUTOINIT_INCLUDE` argument to the
2802 @ref vtk_module_add_module function, the header to use is fetched from the
2803 `_vtk_module_autoinit_include` global property. This only needs to be managed
2804 in modules that `IMPLEMENTS` or are `IMPLEMENTABLE`. This should be provided by
2805 projects using the module system at its lowest level. Projects not implementing
2806 the `VTK_MODULE_AUTOINIT` macro should have its value provided by
2807 `find_package` dependencies in some way.
2812 @brief Linking to autoinit-using modules
2814 When linking to modules, in order for the autoinit system to work, modules need
2815 to declare their registration. In order to do this, defines may need to be
2816 provided to targets in order to trigger registration. These defines may be
2817 added to targets by using this function.
2820 vtk_module_autoinit(
2822 MODULES <module>...)
2825 After this call, the targets given to the `TARGETS` argument will gain the
2826 preprocessor definitions to trigger registrations properly.
2828 function (vtk_module_autoinit)
2829 cmake_parse_arguments(_vtk_autoinit
2835 if (_vtk_autoinit_UNRECOGNIZED_ARGUMENTS)
2838 "${_vtk_autoinit_UNRECOGNIZED_ARGUMENTS}.
")
2841 if (NOT _vtk_autoinit_TARGETS)
2843 "The `TARGETS` argument is required.
")
2846 if (NOT _vtk_autoinit_MODULES)
2847 message(AUTHOR_WARNING
2848 "No `MODULES` passed to `vtk_modules_autoinit`.
")
2851 set(_vtk_autoinit_module_stack
2852 ${_vtk_autoinit_MODULES})
2854 set(_vtk_autoinit_needs_implements)
2855 set(_vtk_autoinit_seen)
2856 while (_vtk_autoinit_module_stack)
2857 list(GET _vtk_autoinit_module_stack 0 _vtk_autoinit_current_module)
2858 list(REMOVE_AT _vtk_autoinit_module_stack 0)
2859 if (_vtk_autoinit_current_module IN_LIST _vtk_autoinit_seen)
2862 list(APPEND _vtk_autoinit_seen
2863 "${_vtk_autoinit_current_module}
")
2865 _vtk_module_real_target(_vtk_autoinit_current_target "${_vtk_autoinit_current_module}
")
2866 get_property(_vtk_autoinit_implements
2867 TARGET "${_vtk_autoinit_current_target}
"
2868 PROPERTY "INTERFACE_vtk_module_implements
")
2870 list(APPEND _vtk_autoinit_needs_implements
2871 ${_vtk_autoinit_implements})
2872 foreach (_vtk_autoinit_implement IN LISTS _vtk_autoinit_implements)
2873 _vtk_module_real_target(_vtk_autoinit_implements_target "${_vtk_autoinit_implement}
")
2874 get_property(_vtk_autoinit_implementable
2875 TARGET "${_vtk_autoinit_implements_target}
"
2876 PROPERTY "INTERFACE_vtk_module_implementable
")
2878 if (NOT _vtk_autoinit_implementable)
2880 "The `${_vtk_autoinit_current_module}` module says that it
"
2881 "implements the `${_vtk_autoinit_implement}` module, but it is not
"
2885 list(APPEND "_vtk_autoinit_implements_${_vtk_autoinit_implement}
"
2886 "${_vtk_autoinit_current_module}
")
2890 if (NOT _vtk_autoinit_needs_implements)
2893 list(REMOVE_DUPLICATES _vtk_autoinit_needs_implements)
2894 list(SORT _vtk_autoinit_needs_implements)
2896 set(_vtk_autoinit_hash_content)
2897 foreach (_vtk_autoinit_need_implements IN LISTS _vtk_autoinit_needs_implements)
2898 if (NOT _vtk_autoinit_implements_${_vtk_autoinit_need_implements})
2901 list(SORT "_vtk_autoinit_implements_${_vtk_autoinit_need_implements}
")
2903 string(APPEND _vtk_autoinit_hash_content
2904 "${_vtk_autoinit_need_implements}: ${_vtk_autoinit_implements_${_vtk_autoinit_need_implements}}\n
")
2906 string(MD5 _vtk_autoinit_header_tag "${_vtk_autoinit_hash_content}
")
2907 set(_vtk_autoinit_header
2908 "${CMAKE_BINARY_DIR}/CMakeFiles/vtkModuleAutoInit_${_vtk_autoinit_header_tag}.h
")
2910 get_property(_vtk_autoinit_header_generated GLOBAL
2911 PROPERTY "_vtk_autoinit_generated_${_vtk_autoinit_header_tag}
")
2913 set(_vtk_autoinit_defines)
2914 set(_vtk_autoinit_header_content)
2915 foreach (_vtk_autoinit_need_implements IN LISTS _vtk_autoinit_needs_implements)
2916 if (NOT _vtk_autoinit_implements_${_vtk_autoinit_need_implements})
2920 get_property(_vtk_autoinit_implements_library_name
2921 TARGET "${_vtk_autoinit_need_implements}
"
2922 PROPERTY "INTERFACE_vtk_module_library_name
")
2924 if (NOT _vtk_autoinit_header_generated)
2925 list(LENGTH "_vtk_autoinit_implements_${_vtk_autoinit_need_implements}
"
2926 _vtk_autoinit_length)
2927 set(_vtk_autoinit_args)
2928 foreach (_vtk_autoinit_arg IN LISTS "_vtk_autoinit_implements_${_vtk_autoinit_need_implements}
")
2929 get_property(_vtk_autoinit_arg_library_name
2930 TARGET "${_vtk_autoinit_arg}
"
2931 PROPERTY "INTERFACE_vtk_module_library_name
")
2932 list(APPEND _vtk_autoinit_args
2933 "${_vtk_autoinit_arg_library_name}
")
2935 string(REPLACE ";
" ",
" _vtk_autoinit_args "${_vtk_autoinit_args}
")
2936 string(APPEND _vtk_autoinit_header_content
2937 "#define ${_vtk_autoinit_implements_library_name}_AUTOINIT ${_vtk_autoinit_length}(${_vtk_autoinit_args})\n
")
2940 list(APPEND _vtk_autoinit_defines
2941 "${_vtk_autoinit_implements_library_name}_AUTOINIT_INCLUDE=\
"${_vtk_autoinit_header}\"")
2944 if (NOT _vtk_autoinit_header_generated)
2946 OUTPUT "${_vtk_autoinit_header}
"
2947 CONTENT "${_vtk_autoinit_header_content}
")
2951 "_vtk_autoinit_generated_${_vtk_autoinit_header_tag}
" TRUE)
2954 foreach (_vtk_autoinit_target IN LISTS _vtk_autoinit_TARGETS)
2955 get_property(_vtk_autoinit_target_type
2956 TARGET "${_vtk_autoinit_target}
"
2958 if (_vtk_autoinit_target_type STREQUAL "INTERFACE_LIBRARY
")
2962 target_compile_definitions("${_vtk_autoinit_target}
"
2964 ${_vtk_autoinit_defines})
2969 @ingroup module-impl
2970 @brief Generate the hierarchy for a module
2972 Write wrap hierarchy files for the module currently being built. This also
2973 installs the hierarchy file for use by dependent projects if `INSTALL_HEADERS`
2977 _vtk_module_write_wrap_hierarchy()
2980 function (_vtk_module_write_wrap_hierarchy)
2981 file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/${_vtk_build_HIERARCHY_DESTINATION}
")
2983 get_property(_vtk_hierarchy_library_name GLOBAL
2984 PROPERTY "_vtk_module_${_vtk_build_module}_library_name
")
2985 set(_vtk_hierarchy_filename "${_vtk_hierarchy_library_name}-hierarchy.txt
")
2986 set(_vtk_hierarchy_file "${CMAKE_BINARY_DIR}/${_vtk_build_HIERARCHY_DESTINATION}/${_vtk_hierarchy_filename}
")
2987 set(_vtk_hierarchy_args_file "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_hierarchy_library_name}-hierarchy.$<CONFIGURATION>.args
")
2988 set(_vtk_hierarchy_data_file "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_hierarchy_library_name}-hierarchy.data
")
2989 set(_vtk_hierarchy_depends_args_file "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_hierarchy_library_name}-hierarchy.depends.args
")
2991 set_property(TARGET "${_vtk_add_module_real_target}
"
2993 "INTERFACE_vtk_module_hierarchy
" "${_vtk_hierarchy_file}
")
2995 set(_vtk_add_module_target_name_iface "${_vtk_add_module_target_name}
")
2996 if (_vtk_add_module_build_with_kit)
2997 set(_vtk_add_module_target_name_iface "${_vtk_add_module_target_name}-objects
")
2999 set(_vtk_hierarchy_genex_compile_definitions
3000 "$<TARGET_PROPERTY:${_vtk_add_module_target_name_iface},COMPILE_DEFINITIONS>
")
3001 set(_vtk_hierarchy_genex_include_directories
3002 "$<TARGET_PROPERTY:${_vtk_add_module_target_name_iface},INCLUDE_DIRECTORIES>
")
3004 OUTPUT "${_vtk_hierarchy_args_file}
"
3005 CONTENT "$<$<BOOL:${_vtk_hierarchy_genex_compile_definitions}>:\n-D\
'$<JOIN:${_vtk_hierarchy_genex_compile_definitions},\'\n-D\'>\'>\n
3006 $<$<BOOL:${_vtk_hierarchy_genex_include_directories}>:\n-I\'$<JOIN:${_vtk_hierarchy_genex_include_directories},\'\n-I\'>\'>\n")
3008 get_property(_vtk_hierarchy_depends_is_global GLOBAL
3009 PROPERTY "_vtk_module_${_vtk_build_module}_depends"
3011 if (_vtk_hierarchy_depends_is_global)
3012 get_property(_vtk_hierarchy_depends GLOBAL
3013 PROPERTY "_vtk_module_${_vtk_build_module}_depends")
3015 get_property(_vtk_hierarchy_depends GLOBAL
3016 TARGET "${_vtk_add_module_real_target}"
3017 PROPERTY "INTERFACE_vtk_module_depends")
3020 set(_vtk_hierarchy_depends_files)
3021 set(_vtk_hierarchy_depends_targets)
3022 foreach (_vtk_hierarchy_depend IN LISTS _vtk_hierarchy_depends)
3023 _vtk_module_get_module_property("${_vtk_hierarchy_depend}"
3024 PROPERTY "hierarchy"
3025 VARIABLE _vtk_hierarchy_depend_hierarchy)
3026 if (NOT DEFINED _vtk_hierarchy_depend_hierarchy)
3030 list(APPEND _vtk_hierarchy_depends_files
3031 "${_vtk_hierarchy_depend_hierarchy}")
3033 # Find the hierarchy target of the module.
3034 get_property(_vtk_hierarchy_module_is_imported
3035 TARGET "${_vtk_hierarchy_depend}"
3037 # Imported target modules are external and should already have their file
3039 if (_vtk_hierarchy_module_is_imported)
3043 get_property(_vtk_hierarchy_depend_library_name GLOBAL
3044 PROPERTY "_vtk_module_${_vtk_hierarchy_depend}_library_name")
3045 if (TARGET "${_vtk_hierarchy_depend_library_name}-hierarchy")
3046 list(APPEND _vtk_hierarchy_depends_targets
3047 "${_vtk_hierarchy_depend_library_name}-hierarchy")
3051 set(_vtk_hierarchy_depends_files_arg)
3052 if (_vtk_hierarchy_depends_files)
3054 OUTPUT "${_vtk_hierarchy_depends_args_file}"
3055 CONTENT "\"$<JOIN:${_vtk_hierarchy_depends_files},\"\n\">\"\n")
3058 OUTPUT "${_vtk_hierarchy_depends_args_file}"
3062 _vtk_module_get_module_property("${_vtk_build_module}"
3064 VARIABLE _vtk_hierarchy_headers)
3065 set(_vtk_hierarchy_data_content "")
3066 foreach (_vtk_hierarchy_header IN LISTS _vtk_hierarchy_headers)
3067 string(APPEND _vtk_hierarchy_data_content
3068 "${_vtk_hierarchy_header};${_vtk_hierarchy_library_name}\n")
3071 OUTPUT "${_vtk_hierarchy_data_file}"
3072 CONTENT "${_vtk_hierarchy_data_content}")
3074 if (CMAKE_GENERATOR MATCHES "Ninja")
3075 set(_vtk_hierarchy_command_depends ${_vtk_hierarchy_depends_files})
3077 set(_vtk_hierarchy_command_depends ${_vtk_hierarchy_depends_targets})
3080 set(_vtk_hierarchy_tool_target "VTK::WrapHierarchy")
3081 set(_vtk_hierarchy_macros_args)
3082 if (TARGET VTKCompileTools::WrapHierarchy)
3083 set(_vtk_hierarchy_tool_target "VTKCompileTools::WrapHierarchy")
3084 if (TARGET VTKCompileTools_macros)
3085 list(APPEND _vtk_hierarchy_command_depends
3086 "VTKCompileTools_macros")
3087 list(APPEND _vtk_hierarchy_macros_args
3089 -imacros "${_VTKCompileTools_macros_file}")
3094 OUTPUT "${_vtk_hierarchy_file}"
3095 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR}
3096 "$<TARGET_FILE:${_vtk_hierarchy_tool_target}>"
3097 "@${_vtk_hierarchy_args_file}"
3098 -o "${_vtk_hierarchy_file}"
3099 "${_vtk_hierarchy_data_file}"
3100 "@${_vtk_hierarchy_depends_args_file}"
3101 ${_vtk_hierarchy_macros_args}
3102 COMMENT "Generating the wrap hierarchy for ${_vtk_build_module}"
3104 ${_vtk_hierarchy_headers}
3105 "${_vtk_hierarchy_args_file}"
3106 "${_vtk_hierarchy_data_file}"
3107 "${_vtk_hierarchy_depends_args_file}"
3108 ${_vtk_hierarchy_command_depends})
3109 add_custom_target("${_vtk_add_module_library_name}-hierarchy" ALL
3111 "${_vtk_hierarchy_file}"
3112 "$<TARGET_FILE:${_vtk_hierarchy_tool_target}>")
3113 set_property(TARGET "${_vtk_add_module_real_target}"
3115 "INTERFACE_vtk_module_hierarchy" "${_vtk_hierarchy_file}")
3117 if (_vtk_build_INSTALL_HEADERS)
3118 set_property(TARGET "${_vtk_add_module_real_target}"
3120 "INTERFACE_vtk_module_hierarchy_install" "\${_vtk_module_import_prefix}/${_vtk_build_HIERARCHY_DESTINATION}/${_vtk_hierarchy_filename}")
3122 FILES "${_vtk_hierarchy_file}"
3123 DESTINATION "${_vtk_build_HIERARCHY_DESTINATION}"
3124 RENAME "${_vtk_hierarchy_filename}"
3125 COMPONENT "${_vtk_build_HEADERS_COMPONENT}")
3129 include(GenerateExportHeader)
3133 @brief Create a module library
3136 vtk_module_add_module(<name>
3137 [FORCE_STATIC] [HEADER_ONLY]
3138 [EXPORT_MACRO_PREFIX <prefix>]
3139 [HEADERS_SUBDIR <subdir>]
3140 [LIBRARY_NAME_SUFFIX <suffix>]
3141 [CLASSES <class>...]
3142 [TEMPLATE_CLASSES <template class>...]
3143 [SOURCES <source>...]
3144 [HEADERS <header>...]
3145 [TEMPLATES <template>...]
3146 [PRIVATE_CLASSES <class>...]
3147 [PRIVATE_TEMPLATE_CLASSES <template class>...]
3148 [PRIVATE_HEADERS <header>...]
3149 [PRIVATE_TEMPLATES <template>...])
3152 The `PRIVATE_` arguments are analogous to their non-`PRIVATE_` arguments, but
3153 the associated files are not installed or available for wrapping (`SOURCES` are
3154 always private, so there is no `PRIVATE_` variant for that argument).
3156 * `FORCE_STATIC`: For a static library to be created. If not provided,
3157 `BUILD_SHARED_LIBS` will control the library type.
3158 * `HEADER_ONLY`: The module only contains headers (or templates) and contains
3159 no compilation steps. Mutually exclusive with `FORCE_STATIC`.
3160 * `EXPORT_MACRO_PREFIX`: The prefix for the export macro definitions.
3161 Defaults to the library name of the module in all uppercase.
3162 * `HEADERS_SUBDIR`: The subdirectory to install headers into in the install
3164 * `LIBRARY_NAME_SUFFIX`: The suffix to the module's library
name if
3165 additional information is required.
3166 * `CLASSES`: A list of classes in the module. This is a shortcut
for adding
3167 `<
class>.cxx` to `SOURCES` and `<
class>.h` to `HEADERS`.
3168 * `TEMPLATE_CLASSES`: A list of
template classes in the module. This is a
3169 shortcut
for adding `<
class>.txx` to `TEMPLATES` and `<
class>.h` to
3171 * `SOURCES`: A list of
source files which require compilation.
3172 * `HEADERS`: A list of header files which will be available
for wrapping and
3174 * `TEMPLATES`: A list of
template files which will be installed.
3177 if (NOT
name STREQUAL _vtk_build_module)
3179 "The ${_vtk_build_module}'s CMakeLists.txt may not add the ${name} module.")
3182 set(_vtk_add_module_source_keywords)
3183 foreach (_vtk_add_module_kind IN ITEMS CLASSES TEMPLATE_CLASSES HEADERS TEMPLATES)
3184 list(APPEND _vtk_add_module_source_keywords
3185 "${_vtk_add_module_kind}
"
3186 "PRIVATE_${_vtk_add_module_kind}
")
3189 cmake_parse_arguments(_vtk_add_module
3190 "FORCE_STATIC;HEADER_ONLY
"
3191 "EXPORT_MACRO_PREFIX;HEADERS_SUBDIR;LIBRARY_NAME_SUFFIX
"
3192 "${_vtk_add_module_source_keywords};SOURCES
"
3195 if (_vtk_add_module_UNPARSED_ARGUMENTS)
3198 "${_vtk_add_module_UNPARSED_ARGUMENTS}
")
3201 if (NOT DEFINED _vtk_add_module_EXPORT_MACRO_PREFIX)
3202 _vtk_module_default_export_macro_prefix(_vtk_add_module_EXPORT_MACRO_PREFIX)
3205 if (_vtk_add_module_HEADER_ONLY AND _vtk_add_module_FORCE_STATIC)
3207 "The ${_vtk_build_module} module cannot be header only yet forced
"
3211 foreach (_vtk_add_module_class IN LISTS _vtk_add_module_CLASSES)
3212 list(APPEND _vtk_add_module_SOURCES
3213 "${_vtk_add_module_class}.cxx
")
3214 list(APPEND _vtk_add_module_HEADERS
3215 "${_vtk_add_module_class}.h
")
3218 foreach (_vtk_add_module_template_class IN LISTS _vtk_add_module_TEMPLATE_CLASSES)
3219 list(APPEND _vtk_add_module_TEMPLATES
3220 "${_vtk_add_module_template_class}.txx
")
3221 list(APPEND _vtk_add_module_HEADERS
3222 "${_vtk_add_module_template_class}.h
")
3225 foreach (_vtk_add_module_class IN LISTS _vtk_add_module_PRIVATE_CLASSES)
3226 list(APPEND _vtk_add_module_SOURCES
3227 "${_vtk_add_module_class}.cxx
")
3228 list(APPEND _vtk_add_module_PRIVATE_HEADERS
3229 "${_vtk_add_module_class}.h
")
3232 foreach (_vtk_add_module_template_class IN LISTS _vtk_add_module_PRIVATE_TEMPLATE_CLASSES)
3233 list(APPEND _vtk_add_module_PRIVATE_TEMPLATES
3234 "${_vtk_add_module_template_class}.txx
")
3235 list(APPEND _vtk_add_module_PRIVATE_HEADERS
3236 "${_vtk_add_module_template_class}.h
")
3239 if (NOT _vtk_add_module_SOURCES AND NOT _vtk_add_module_HEADER_ONLY)
3241 "The ${_vtk_build_module} module has no
source files.
")
3244 get_property(_vtk_add_module_third_party GLOBAL
3245 PROPERTY "_vtk_module_${_vtk_build_module}_third_party
")
3247 get_property(_vtk_add_module_library_name GLOBAL
3248 PROPERTY "_vtk_module_${_vtk_build_module}_library_name
")
3249 set(_vtk_add_module_module_header_name
3250 "${_vtk_add_module_library_name}Module.h
")
3251 if (NOT _vtk_add_module_HEADER_ONLY AND NOT _vtk_add_module_third_party)
3252 set(_vtk_add_module_generated_header
3253 "${CMAKE_CURRENT_BINARY_DIR}/${_vtk_add_module_module_header_name}
")
3254 list(APPEND _vtk_add_module_HEADERS
3255 "${_vtk_add_module_generated_header}
")
3258 vtk_module_install_headers(
3259 FILES ${_vtk_add_module_HEADERS}
3260 ${_vtk_add_module_TEMPLATES}
3261 SUBDIR "${_vtk_add_module_HEADERS_SUBDIR}
")
3263 set(_vtk_add_module_type)
3264 if (_vtk_add_module_FORCE_STATIC)
3265 set(_vtk_add_module_type STATIC)
3268 set(_vtk_add_module_build_with_kit)
3269 if (_vtk_build_BUILD_WITH_KITS)
3270 get_property(_vtk_add_module_build_with_kit GLOBAL
3271 PROPERTY "_vtk_module_${_vtk_build_module}_kit
")
3274 get_property(_vtk_add_module_namespace GLOBAL
3275 PROPERTY "_vtk_module_${_vtk_build_module}_namespace
")
3276 get_property(_vtk_add_module_target_name GLOBAL
3277 PROPERTY "_vtk_module_${_vtk_build_module}_target_name
")
3278 set(_vtk_add_module_real_target "${_vtk_add_module_target_name}
")
3279 if (_vtk_add_module_HEADER_ONLY)
3280 if (_vtk_add_module_build_with_kit)
3282 "The module ${_vtk_build_module} is header-only, but is part of the
"
3283 "${_vtk_add_module_build_with_kit} kit. Header-only modules
do not
"
3287 # XXX(cmake-3.12.0): This unset is no longer necessary when 3.12.0 is required.
3288 unset("${_vtk_build_module}_LIB_DEPENDS
" CACHE)
3289 add_library("${_vtk_add_module_real_target}
" INTERFACE)
3291 if (NOT _vtk_build_module STREQUAL _vtk_add_module_real_target)
3292 add_library("${_vtk_build_module}
" ALIAS
3293 "${_vtk_add_module_real_target}
")
3296 if (_vtk_add_module_build_with_kit)
3297 add_library("${_vtk_add_module_real_target}
" INTERFACE)
3298 target_link_libraries("${_vtk_add_module_real_target}
"
3300 # For usage requirements.
3301 "${_vtk_add_module_real_target}-objects
"
3302 # For the implementation.
3303 "$<LINK_ONLY:${_vtk_add_module_build_with_kit}>
")
3305 if (NOT _vtk_build_module STREQUAL _vtk_add_module_real_target)
3306 add_library("${_vtk_build_module}
" ALIAS
3307 "${_vtk_add_module_real_target}
")
3310 # Set up properties necessary for other infrastructure.
3311 set_property(TARGET "${_vtk_add_module_real_target}
"
3313 "INTERFACE_vtk_module_library_name
" "${_vtk_add_module_library_name}
")
3315 # XXX(cmake-3.12.0): This unset is no longer necessary when 3.12.0 is required.
3316 unset("${_vtk_build_module}_LIB_DEPENDS
" CACHE)
3317 add_library("${_vtk_add_module_real_target}-objects
" OBJECT
3318 ${_vtk_add_module_SOURCES}
3319 ${_vtk_add_module_TEMPLATES}
3320 ${_vtk_add_module_PRIVATE_TEMPLATES}
3321 ${_vtk_add_module_HEADERS}
3322 ${_vtk_add_module_PRIVATE_HEADERS})
3323 set_target_properties("${_vtk_add_module_real_target}-objects
"
3325 # Emulate the regular library as much as possible.
3326 DEFINE_SYMBOL "${_vtk_add_module_real_target}_EXPORT
"
3327 POSITION_INDEPENDENT_CODE ON)
3328 target_compile_definitions("${_vtk_add_module_real_target}-objects
"
3330 "${_vtk_add_module_real_target}_EXPORT
")
3331 set(_vtk_add_module_real_target "${_vtk_add_module_real_target}-objects
")
3333 add_library("${_vtk_add_module_real_target}
" ${_vtk_add_module_type}
3334 ${_vtk_add_module_SOURCES}
3335 ${_vtk_add_module_TEMPLATES}
3336 ${_vtk_add_module_HEADERS}
3337 ${_vtk_add_module_PRIVATE_HEADERS})
3339 set_property(TARGET "${_vtk_add_module_real_target}
"
3341 POSITION_INDEPENDENT_CODE ON)
3343 if (NOT _vtk_build_module STREQUAL _vtk_add_module_real_target)
3344 add_library("${_vtk_build_module}
" ALIAS
3345 "${_vtk_add_module_real_target}
")
3350 set_property(TARGET "${_vtk_add_module_real_target}
"
3352 "INTERFACE_vtk_module_library_name
" "${_vtk_add_module_library_name}
")
3354 get_property(_vtk_add_module_depends GLOBAL
3355 PROPERTY "_vtk_module_${_vtk_build_module}_depends
")
3356 set_property(TARGET "${_vtk_add_module_real_target}
"
3358 "INTERFACE_vtk_module_depends
" "${_vtk_add_module_depends}
")
3359 set(_vtk_add_module_includes_interface)
3360 if (_vtk_add_module_HEADER_ONLY)
3361 target_link_libraries("${_vtk_add_module_real_target}
"
3363 ${_vtk_add_module_depends})
3364 set(_vtk_add_module_includes_interface INTERFACE)
3366 get_property(_vtk_add_module_private_depends GLOBAL
3367 PROPERTY "_vtk_module_${_vtk_build_module}_private_depends
")
3369 # XXX(cmake#18484): Linking dependencies directly currently creates
3370 # circular dependencies. This logic should be removed once the minimum for
3371 # kits contains a fix for the mentioned issue.
3373 # When two modules are part of the same kit, we can get this problem:
3375 # A - iface -> A-objects <- tll - K
3378 # B - iface -> B-objects <- tll -/
3380 # If B depends on A, it ends up with a circular dependency since A has a
3381 # `$<LINK_ONLY:K>` link. instead, munge up dependencies of intra-kit
3382 # dependencies to link to the `-objects` target instead.
3383 if (_vtk_add_module_build_with_kit)
3384 set(_vtk_add_module_depends_link)
3385 set(_vtk_add_module_private_depends_link)
3386 foreach (_vtk_add_module_depend IN LISTS _vtk_add_module_depends)
3387 get_property(_vtk_add_module_depend_kit GLOBAL
3388 PROPERTY "_vtk_module_${_vtk_add_module_depend}_kit
")
3389 if (_vtk_add_module_depend_kit STREQUAL _vtk_add_module_build_with_kit)
3390 # We're in the same kit; depend on the `-objects` library of the
3392 get_property(_vtk_add_module_depend_target_name GLOBAL
3393 PROPERTY "_vtk_module_${_vtk_add_module_depend}_target_name
")
3394 list(APPEND _vtk_add_module_depends_link
3395 "${_vtk_add_module_depend_target_name}-objects
")
3397 # Different kit, just use as normal.
3398 list(APPEND _vtk_add_module_depends_link
3399 "${_vtk_add_module_depend}
")
3402 foreach (_vtk_add_module_private_depend IN LISTS _vtk_add_module_private_depends)
3403 get_property(_vtk_add_module_private_depend_kit GLOBAL
3404 PROPERTY "_vtk_module_${_vtk_add_module_private_depend}_kit
")
3405 if (_vtk_add_module_private_depend_kit STREQUAL _vtk_add_module_build_with_kit)
3406 # We're in the same kit; depend on the `-objects` library of the
3408 get_property(_vtk_add_module_private_depend_target_name GLOBAL
3409 PROPERTY "_vtk_module_${_vtk_add_module_private_depend}_target_name
")
3410 list(APPEND _vtk_add_module_private_depends_link
3411 "${_vtk_add_module_private_depend_target_name}-objects
")
3413 # Different kit, just use as normal.
3414 list(APPEND _vtk_add_module_private_depends_link
3415 "${_vtk_add_module_private_depend}
")
3419 # Add the `DEFINE_SYMBOL` for all other modules within the same kit which
3420 # have already been processed because the direct dependencies are not
3421 # sufficient: export symbols from any included header needs to be
3422 # correct. Since modules are built in topological order, a module can
3423 # only possibly include modules in the kit which have already been built.
3424 get_property(_vtk_add_module_kit_modules GLOBAL
3425 PROPERTY "_vtk_kit_${_vtk_add_module_build_with_kit}_kit_modules
")
3426 list(REMOVE_ITEM _vtk_add_module_kit_modules "${_vtk_build_module}
")
3427 foreach (_vtk_add_module_kit_module IN LISTS _vtk_add_module_kit_modules)
3428 get_property(_vtk_add_module_kit_module_target_name GLOBAL
3429 PROPERTY "_vtk_module_${_vtk_add_module_kit_module}_target_name
")
3430 if (TARGET "${_vtk_add_module_kit_module_target_name}-objects
")
3431 get_property(_vtk_add_module_kit_module_define_symbol
3432 TARGET "${_vtk_add_module_kit_module_target_name}-objects
"
3433 PROPERTY DEFINE_SYMBOL)
3434 target_compile_definitions("${_vtk_add_module_real_target}
"
3436 "${_vtk_add_module_kit_module_define_symbol}
")
3440 set(_vtk_add_module_depends_link ${_vtk_add_module_depends})
3441 set(_vtk_add_module_private_depends_link ${_vtk_add_module_private_depends})
3443 target_link_libraries("${_vtk_add_module_real_target}
"
3445 ${_vtk_add_module_depends_link}
3447 ${_vtk_add_module_private_depends_link})
3449 set(_vtk_add_module_private_depends_forward_link)
3450 foreach (_vtk_add_module_private_depend IN LISTS _vtk_add_module_depends_link _vtk_add_module_private_depends)
3451 _vtk_module_get_module_property("${_vtk_add_module_private_depend}
"
3452 PROPERTY "forward_link
"
3453 VARIABLE _vtk_add_module_forward_link)
3454 list(APPEND _vtk_add_module_private_depends_forward_link
3455 ${_vtk_add_module_forward_link})
3458 get_property(_vtk_add_module_optional_depends GLOBAL
3459 PROPERTY "_vtk_module_${_vtk_build_module}_optional_depends
")
3460 foreach (_vtk_add_module_optional_depend IN LISTS _vtk_add_module_optional_depends)
3461 if (TARGET "${_vtk_add_module_optional_depend}
")
3462 set(_vtk_add_module_have_optional_depend 1)
3463 set(_vtk_add_module_optional_depend_link "${_vtk_add_module_optional_depend}
")
3464 if (_vtk_add_module_build_with_kit)
3465 get_property(_vtk_add_module_optional_depend_kit GLOBAL
3466 PROPERTY "_vtk_module_${_vtk_add_module_optional_depend}_kit
")
3467 if (_vtk_add_module_optional_depend_kit STREQUAL _vtk_add_module_build_with_kit)
3468 # We're in the same kit; depend on the `-objects` library of the
3469 # module to avoid circular dependency (see explanation earlier)
3470 get_property(_vtk_add_module_optional_depend_target_name GLOBAL
3471 PROPERTY "_vtk_module_${_vtk_add_module_optional_depend}_target_name
")
3472 set(_vtk_add_module_optional_depend_link "${_vtk_add_module_optional_depend_target_name}-objects
")
3475 _vtk_module_get_module_property("${_vtk_add_module_optional_depend_link}
"
3476 PROPERTY "forward_link
"
3477 VARIABLE _vtk_add_module_forward_link)
3478 list(APPEND _vtk_add_module_private_depends_forward_link
3479 ${_vtk_add_module_forward_link})
3480 target_link_libraries("${_vtk_add_module_real_target}
"
3482 "${_vtk_add_module_optional_depend_link}
")
3484 set(_vtk_add_module_have_optional_depend 0)
3486 string(REPLACE "::
" "_
" _vtk_add_module_optional_depend_safe "${_vtk_add_module_optional_depend}
")
3487 target_compile_definitions("${_vtk_add_module_real_target}
"
3489 "VTK_MODULE_ENABLE_${_vtk_add_module_optional_depend_safe}=${_vtk_add_module_have_optional_depend}
")
3492 if (_vtk_add_module_private_depends_forward_link)
3493 list(REMOVE_DUPLICATES _vtk_add_module_private_depends_forward_link)
3494 _vtk_module_set_module_property("${_vtk_build_module}
" APPEND
3495 PROPERTY "forward_link
"
3496 VALUE "${_vtk_add_module_private_depends_forward_link}
")
3497 target_link_libraries("${_vtk_add_module_real_target}
"
3499 "${_vtk_add_module_private_depends_forward_link}
")
3502 _vtk_module_standard_includes(
3503 TARGET "${_vtk_add_module_real_target}
"
3504 ${_vtk_add_module_includes_interface}
3505 HEADERS_DESTINATION "${_vtk_build_HEADERS_DESTINATION}
")
3507 vtk_module_autoinit(
3508 MODULES ${_vtk_add_module_depends}
3509 ${_vtk_add_module_private_depends}
3510 "${_vtk_build_module}
"
3511 TARGETS "${_vtk_add_module_real_target}
")
3513 set(_vtk_add_module_headers_build)
3514 set(_vtk_add_module_headers_install)
3515 # TODO: Perform this in `vtk_module_install_headers` so that manually
3516 # installed headers may participate in wrapping as well.
3517 foreach (_vtk_add_module_header IN LISTS _vtk_add_module_HEADERS)
3518 if (IS_ABSOLUTE "${_vtk_add_module_header}
")
3519 list(APPEND _vtk_add_module_headers_build
3520 "${_vtk_add_module_header}
")
3522 list(APPEND _vtk_add_module_headers_build
3523 "${CMAKE_CURRENT_SOURCE_DIR}/${_vtk_add_module_header}
")
3526 get_filename_component(_vtk_add_module_header_name "${_vtk_add_module_header}
" NAME)
3527 list(APPEND _vtk_add_module_headers_install
3528 "\${_vtk_module_import_prefix}/${_vtk_build_HEADERS_DESTINATION}/${_vtk_add_module_header_name}
")
3531 set_property(TARGET "${_vtk_add_module_real_target}
"
3533 "INTERFACE_vtk_module_headers
" "${_vtk_add_module_headers_build}
")
3534 if (_vtk_build_INSTALL_HEADERS)
3535 set_property(TARGET "${_vtk_add_module_real_target}
"
3537 "INTERFACE_vtk_module_headers_install
" "${_vtk_add_module_headers_install}
")
3540 get_property(_vtk_add_module_exclude_wrap GLOBAL
3541 PROPERTY "_vtk_module_${_vtk_build_module}_exclude_wrap
")
3542 set_property(TARGET "${_vtk_add_module_real_target}
"
3544 "INTERFACE_vtk_module_exclude_wrap
" "${_vtk_add_module_exclude_wrap}
")
3545 if (NOT _vtk_add_module_exclude_wrap AND _vtk_build_ENABLE_WRAPPING)
3546 _vtk_module_write_wrap_hierarchy()
3549 set(_vtk_add_module_module_content)
3551 if (NOT _vtk_add_module_AUTOINIT_INCLUDE)
3552 get_property(_vtk_add_module_AUTOINIT_INCLUDE GLOBAL
3553 PROPERTY "_vtk_module_autoinit_include
")
3556 set(_vtk_add_module_autoinit_include_header)
3557 if (_vtk_add_module_AUTOINIT_INCLUDE)
3558 set(_vtk_add_module_autoinit_include_header
3559 "#include ${_vtk_add_module_AUTOINIT_INCLUDE}
")
3562 set(_vtk_add_module_autoinit_depends_includes)
3563 foreach (_vtk_add_module_autoinit_dependency IN LISTS _vtk_add_module_depends)
3564 get_property(_vtk_add_module_autoinit_dependency_target_name GLOBAL
3565 PROPERTY "_vtk_module_${_vtk_add_module_autoinit_dependency}_target_name
")
3566 if (_vtk_add_module_autoinit_dependency_target_name)
3567 get_property(_vtk_add_module_depends_needs_autoinit
3568 TARGET "${_vtk_add_module_autoinit_dependency_target_name}
"
3569 PROPERTY "INTERFACE_vtk_module_needs_autoinit
")
3571 set(_vtk_add_module_autoinit_dependency_target_name
3572 "${_vtk_add_module_autoinit_dependency}
")
3573 get_property(_vtk_add_module_depends_needs_autoinit
3574 TARGET "${_vtk_add_module_autoinit_dependency}
"
3575 PROPERTY "INTERFACE_vtk_module_needs_autoinit
")
3577 if (NOT _vtk_add_module_depends_needs_autoinit)
3580 get_property(_vtk_add_module_depends_library_name
3581 TARGET "${_vtk_add_module_autoinit_dependency_target_name}
"
3582 PROPERTY "INTERFACE_vtk_module_library_name
")
3584 string(APPEND _vtk_add_module_autoinit_depends_includes
3585 "#include \
"${_vtk_add_module_depends_library_name}Module.h\"\n")
3588 set(_vtk_add_module_autoinit_content)
3589 if (_vtk_add_module_autoinit_depends_includes)
3590 set(_vtk_add_module_autoinit_content
3591 "${_vtk_add_module_autoinit_content}\n${_vtk_add_module_autoinit_depends_includes}\n
")
3594 get_property(_vtk_add_module_implementable GLOBAL
3595 PROPERTY "_vtk_module_${_vtk_build_module}_implementable
")
3596 get_property(_vtk_add_module_implements GLOBAL
3597 PROPERTY "_vtk_module_${_vtk_build_module}_implements
")
3598 if (_vtk_add_module_implementable)
3599 set_property(TARGET "${_vtk_add_module_real_target}
"
3601 "INTERFACE_vtk_module_implementable
" 1)
3604 if (_vtk_add_module_implementable OR _vtk_add_module_implements)
3605 set_property(TARGET "${_vtk_add_module_real_target}
"
3607 "INTERFACE_vtk_module_implements
" "${_vtk_add_module_implements}
")
3608 set_property(TARGET "${_vtk_add_module_real_target}
"
3610 "INTERFACE_vtk_module_needs_autoinit
" 1)
3612 set(_vtk_add_module_autoinit_content
3613 "${_vtk_add_module_autoinit_content}
3615 #ifdef ${_vtk_add_module_library_name}_AUTOINIT_INCLUDE
3616 #include ${_vtk_add_module_library_name}_AUTOINIT_INCLUDE
3618 #ifdef ${_vtk_add_module_library_name}_AUTOINIT
3619 ${_vtk_add_module_autoinit_include_header}
3624 set(_vtk_add_module_module_content
3625 "${_vtk_add_module_module_content}${_vtk_add_module_autoinit_content}
")
3628 if (NOT _vtk_add_module_HEADER_ONLY AND NOT _vtk_add_module_third_party)
3629 generate_export_header("${_vtk_add_module_real_target}
"
3630 EXPORT_MACRO_NAME "${_vtk_add_module_EXPORT_MACRO_PREFIX}_EXPORT
"
3631 NO_EXPORT_MACRO_NAME "${_vtk_add_module_EXPORT_MACRO_PREFIX}_NO_EXPORT
"
3632 DEPRECATED_MACRO_NAME "${_vtk_add_module_EXPORT_MACRO_PREFIX}_DEPRECATED
"
3633 NO_DEPRECATED_MACRO_NAME "${_vtk_add_module_EXPORT_MACRO_PREFIX}_NO_DEPRECATED
"
3634 STATIC_DEFINE "${_vtk_add_module_EXPORT_MACRO_PREFIX}_STATIC_DEFINE
"
3635 EXPORT_FILE_NAME "${_vtk_add_module_module_header_name}
"
3636 CUSTOM_CONTENT_FROM_VARIABLE _vtk_add_module_module_content)
3639 _vtk_module_apply_properties("${_vtk_add_module_target_name}
")
3640 _vtk_module_install("${_vtk_add_module_target_name}
")
3641 _vtk_module_add_header_tests()
3643 if (_vtk_add_module_build_with_kit)
3644 _vtk_module_install("${_vtk_add_module_target_name}-objects
")
3649 @ingroup module-impl
3650 @brief Add header tests for a module
3652 @todo Move this function out to be VTK-specific, probably into
3653 `vtkModuleTesting.cmake`. Each module would then need to manually call this
3654 function. It currently assumes it is in VTK itself.
3657 _vtk_module_add_header_tests()
3660 function (_vtk_module_add_header_tests)
3661 if (NOT BUILD_TESTING)
3665 get_property(_vtk_add_header_tests_is_third_party GLOBAL
3666 PROPERTY "_vtk_module_${_vtk_build_module}_third_party
")
3667 if (_vtk_add_header_tests_is_third_party)
3671 # TODO: Add test compiles which include each header file to ensure that
3672 # public headers have their includes satisfied by a public dependency.
3675 if (NOT "Python${VTK_PYTHON_VERSION}_EXECUTABLE
")
3680 if (NOT VTK_SOURCE_DIR)
3685 NAME "${_vtk_build_module}-HeaderTest
"
3686 COMMAND "${Python${VTK_PYTHON_VERSION}_EXECUTABLE}
"
3687 # TODO: What to do when using this from a VTK install?
3688 "${VTK_SOURCE_DIR}/Testing/Core/HeaderTesting.py
"
3689 "${CMAKE_CURRENT_SOURCE_DIR}
"
3690 "${_vtk_add_module_EXPORT_MACRO}
")
3695 @brief Install headers
3697 Installing headers is done for normal modules by the @ref vtk_module_add_module
3698 function already. However, sometimes header structures are more complicated and
3699 need to be installed manually. This is common for third party modules or
3700 projects which use more than a single directory of headers for a module.
3702 To facilitate the installation of headers in various ways, the this function is
3703 available. This function honors the `INSTALL_HEADERS`, `HEADERS_DESTINATION`,
3704 and `HEADERS_COMPONENT` arguments to @ref vtk_module_build.
3707 vtk_module_install_headers(
3708 [DIRECTORIES <directory>...]
3713 Installation of header directories follows CMake's `install` function semantics
3714 with respect to trailing slashes.
3716 function (vtk_module_install_headers)
3717 cmake_parse_arguments(_vtk_install_headers
3723 if (_vtk_install_headers_UNPARSED_ARGUMENTS)
3726 "${_vtk_install_headers_UNPARSED_ARGUMENTS}
")
3729 if (NOT _vtk_build_INSTALL_HEADERS)
3733 if (NOT _vtk_install_headers_FILES AND NOT _vtk_install_headers_DIRECTORIES)
3737 set(_vtk_install_headers_destination
3738 "${_vtk_build_HEADERS_DESTINATION}/${_vtk_install_headers_SUBDIR}
")
3739 if (_vtk_install_headers_FILES)
3741 FILES ${_vtk_install_headers_FILES}
3742 DESTINATION "${_vtk_install_headers_destination}
"
3743 COMPONENT "${_vtk_build_HEADERS_COMPONENT}
")
3745 foreach (_vtk_install_headers_directory IN LISTS _vtk_install_headers_DIRECTORIES)
3747 DIRECTORY "${_vtk_install_headers_directory}
"
3748 DESTINATION "${_vtk_install_headers_destination}
"
3749 COMPONENT "${_vtk_build_HEADERS_COMPONENT}
")
3754 @ingroup module-internal
3755 @brief Apply properties to a module
3757 Apply build properties to a target. Generally only useful to wrapping code or
3758 other modules that cannot use @ref vtk_module_add_module for some reason.
3761 _vtk_module_apply_properties(<target>
3762 [BASENAME <basename>])
3765 If `BASENAME` is given, it will be used instead of the target name as the basis
3766 for `OUTPUT_NAME`. Full modules (as opposed to third party or other non-module
3767 libraries) always use the module's `LIBRARY_NAME` setting.
3769 The following target properties are set based on the arguments to the calling
3770 @ref vtk_module_build call:
3772 - `OUTPUT_NAME` (based on the module's `LIBRARY_NAME` and
3773 `vtk_module_build(LIBRARY_NAME_SUFFIX)`)
3774 - `VERSION` (based on `vtk_module_build(VERSION)`)
3775 - `SOVERSION` (based on `vtk_module_build(SOVERSION)`)
3776 - `DEBUG_POSTFIX` (on Windows)
3778 function (_vtk_module_apply_properties target)
3779 cmake_parse_arguments(_vtk_apply_properties
3785 if (_vtk_apply_properties_UNPARSED_ARGUMENTS)
3788 "${_vtk_apply_properties_UNPARSED_ARGUMENTS}.
")
3791 if (NOT DEFINED _vtk_apply_properties_BASENAME)
3792 set(_vtk_apply_properties_BASENAME "${
target}
")
3795 get_property(_vtk_add_module_type
3798 if (_vtk_add_module_type STREQUAL "OBJECT_LIBRARY
" OR
3799 _vtk_add_module_type STREQUAL "INTERFACE_LIBRARY
")
3803 set(_vtk_add_module_library_name "${_vtk_apply_properties_BASENAME}
")
3804 get_property(_vtk_add_module_target_name GLOBAL
3805 PROPERTY "_vtk_module_${_vtk_build_module}_target_name
")
3806 if (_vtk_add_module_target_name STREQUAL "${
target}
")
3807 get_property(_vtk_add_module_library_name GLOBAL
3808 PROPERTY "_vtk_module_${_vtk_build_module}_library_name
")
3810 set(_vtk_add_module_output_name "${_vtk_add_module_library_name}${_vtk_add_module_LIBRARY_NAME_SUFFIX}
")
3811 if (_vtk_build_LIBRARY_NAME_SUFFIX)
3812 string(APPEND _vtk_add_module_output_name "-${_vtk_build_LIBRARY_NAME_SUFFIX}
")
3815 set_target_properties("${
target}
"
3817 OUTPUT_NAME "${_vtk_add_module_output_name}
")
3819 if (_vtk_build_VERSION AND NOT _vtk_add_module_type STREQUAL "EXECUTABLE
")
3820 set_target_properties("${
target}
"
3822 VERSION "${_vtk_build_VERSION}
")
3825 if (_vtk_build_SOVERSION)
3826 set_target_properties("${
target}
"
3828 SOVERSION "${_vtk_build_SOVERSION}
")
3832 set_target_properties("${
target}
"
3839 @ingroup module-internal
3840 @brief Install a module target
3842 Install a target within the module context. Generally only useful to wrapping
3843 code, modules that cannot use @ref vtk_module_add_module for some reason, or
3844 modules which create utility targets that need installed.
3847 _vtk_module_install(<target>)
3850 This function uses the various installation options to @ref vtk_module_build
3851 function to keep the install uniform.
3853 function (_vtk_module_install target)
3854 set(_vtk_install_export)
3855 if (_vtk_build_INSTALL_EXPORT)
3856 set(_vtk_install_export
3857 EXPORT "${_vtk_build_INSTALL_EXPORT}
")
3860 set(_vtk_install_namelink_args)
3861 if(NOT CMAKE_VERSION VERSION_LESS 3.12)
3862 list(APPEND _vtk_install_namelink_args
3863 NAMELINK_COMPONENT "${_vtk_build_HEADERS_COMPONENT}
")
3867 ${_vtk_install_export}
3870 DESTINATION "${_vtk_build_ARCHIVE_DESTINATION}
"
3871 COMPONENT "${_vtk_build_HEADERS_COMPONENT}
"
3873 DESTINATION "${_vtk_build_LIBRARY_DESTINATION}
"
3874 COMPONENT "${_vtk_build_TARGETS_COMPONENT}
"
3875 ${_vtk_install_namelink_args}
3877 DESTINATION "${_vtk_build_RUNTIME_DESTINATION}
"
3878 COMPONENT "${_vtk_build_TARGETS_COMPONENT}
")
3883 @brief Create a module executable
3885 Some modules may have associated executables with them. By using this function,
3886 the target will be installed following the options given to the associated
3887 @ref vtk_module_build command. Its name will also be changed according to the
3888 `LIBRARY_NAME_SUFFIX` option.
3891 vtk_module_add_executable(<name>
3894 [BASENAME <basename>]
3898 If `NO_INSTALL` is specified, the executable will not be installed. If
3899 `BASENAME` is given, it will be used as the name of the executable rather than
3902 If `DEVELOPMENT` is given, it marks the executable as a development tool and
3903 will not be installed if `INSTALL_HEADERS` is not set for the associated
3904 @ref vtk_module_build command.
3906 If the executable being built is the module, its module properties are used
3907 rather than `BASENAME`. In addition, the dependencies of the module will be
3910 function (vtk_module_add_executable name)
3911 cmake_parse_arguments(_vtk_add_executable
3912 "NO_INSTALL;DEVELOPMENT
"
3917 if (NOT _vtk_add_executable_UNPARSED_ARGUMENTS)
3919 "The ${
name} executable must have at least one
source file.
")
3922 if (_vtk_add_executable_NO_INSTALL AND _vtk_add_executable_DEVELOPMENT)
3924 "Both `NO_INSTALL` and `DEVELOPMENT` may not be specified.
")
3927 set(_vtk_add_executable_target_name "${
name}
")
3928 set(_vtk_add_executable_library_name "${
name}
")
3929 if (name STREQUAL _vtk_build_module)
3930 if (_vtk_add_executable_NO_INSTALL)
3932 "The executable ${_vtk_build_module} module may not use `NO_INSTALL`.
")
3934 if (DEFINED _vtk_add_executable_BASENAME)
3936 "The executable ${_vtk_build_module} module may not pass `BASENAME`
"
3937 "when adding the executable; it is controlled via `LIBRARY_NAME` in
"
3938 "the associated `
vtk.module` file.
")
3940 get_property(_vtk_add_executable_target_name GLOBAL
3941 PROPERTY "_vtk_module_${_vtk_build_module}_target_name
")
3942 get_property(_vtk_add_executable_library_name GLOBAL
3943 PROPERTY "_vtk_module_${_vtk_build_module}_library_name
")
3946 if (_vtk_add_executable_DEVELOPMENT AND NOT _vtk_build_INSTALL_HEADERS)
3947 set(_vtk_add_executable_NO_INSTALL ON)
3951 set(CMAKE_BUILD_RPATH_USE_ORIGIN 1)
3953 file(RELATIVE_PATH _vtk_add_executable_relpath
3954 "/prefix/${_vtk_build_RUNTIME_DESTINATION}
"
3955 "/prefix/${_vtk_build_LIBRARY_DESTINATION}
")
3957 set(_vtk_add_executable_origin_rpath_prefix
3960 set(_vtk_add_executable_origin_rpath_prefix
3964 list(APPEND CMAKE_INSTALL_RPATH
3965 "${_vtk_add_executable_origin_rpath_prefix}/${_vtk_add_executable_relpath}
")
3968 add_executable("${_vtk_add_executable_target_name}
"
3969 ${_vtk_add_executable_UNPARSED_ARGUMENTS})
3971 if (name STREQUAL _vtk_build_module AND NOT _vtk_add_executable_target_name STREQUAL _vtk_build_module)
3972 add_executable("${_vtk_build_module}
" ALIAS
3973 "${_vtk_add_executable_target_name}
")
3976 if (name STREQUAL _vtk_build_module)
3977 get_property(_vtk_real_target_kit GLOBAL
3978 PROPERTY "_vtk_module_${_vtk_build_module}_kit
")
3979 if (_vtk_real_target_kit)
3981 "Executable module ${_vtk_build_module} is declared to be part of a
"
3982 "kit;
this is not possible.
")
3985 get_property(_vtk_add_executable_depends GLOBAL
3986 PROPERTY "_vtk_module_${_vtk_build_module}_depends
")
3987 get_property(_vtk_add_executable_private_depends GLOBAL
3988 PROPERTY "_vtk_module_${_vtk_build_module}_private_depends
")
3989 target_link_libraries("${_vtk_add_executable_target_name}
"
3991 ${_vtk_add_executable_depends}
3993 ${_vtk_add_executable_private_depends})
3994 get_property(_vtk_add_executable_optional_depends GLOBAL
3995 PROPERTY "_vtk_module_${_vtk_build_module}_optional_depends
")
3996 foreach (_vtk_add_executable_optional_depend IN LISTS _vtk_add_executable_optional_depends)
3997 string(REPLACE "::
" "_
" _vtk_add_executable_optional_depend_safe "${_vtk_add_executable_optional_depend}
")
3998 if (TARGET "${_vtk_add_executable_optional_depend}
")
3999 set(_vtk_add_executable_have_optional_depend 1)
4001 set(_vtk_add_executable_have_optional_depend 0)
4003 target_compile_definitions("${_vtk_add_executable_target_name}
"
4005 "VTK_MODULE_ENABLE_${_vtk_add_executable_optional_depend_safe}=${_vtk_add_executable_have_optional_depend}
")
4008 if (_vtk_module_warnings)
4009 if (_vtk_add_executable_depends)
4011 "Executable module ${_vtk_build_module} has
public dependencies;
this "
4012 "shouldn
't be necessary.")
4017 set(_vtk_add_executable_property_args)
4018 if (DEFINED _vtk_add_executable_BASENAME)
4019 list(APPEND _vtk_add_executable_property_args
4020 BASENAME "${_vtk_add_executable_BASENAME}")
4023 _vtk_module_apply_properties("${_vtk_add_executable_target_name}"
4024 ${_vtk_add_executable_property_args})
4025 _vtk_module_standard_includes(TARGET "${_vtk_add_executable_target_name}")
4027 if (NOT _vtk_add_executable_NO_INSTALL)
4028 _vtk_module_install("${_vtk_add_executable_target_name}")
4034 @brief Find a package
4036 A wrapper around `find_package` that records information for use so that the
4037 same targets may be found when finding this package.
4039 Modules may need to find external dependencies. CMake often provides modules to
4040 find these dependencies, but when imported targets are involved, these.need to
4041 also be found from dependencies of the current project. Since the benefits of
4042 imported targets greatly outweighs not using them, it is preferred to use them.
4044 The module system provides the @ref vtk_module_find_package function in order
4045 to extend `find_package` support to include finding the dependencies from an
4046 install of the project.
4049 vtk_module_find_package(
4050 [PRIVATE] [CONFIG_MODE]
4053 [COMPONENTS <component>...]
4054 [OPTIONAL_COMPONENTS <component>...]
4055 [FORWARD_VERSION_REQ <MAJOR|MINOR|PATCH|EXACT>]
4056 [VERSION_VAR <variable>])
4059 * `PACKAGE`: The name of the package to find.
4060 * `VERSION`: The minimum version of the package that is required.
4061 * `COMPONENTS`: Components of the package which are required.
4062 * `OPTIONAL_COMPONENTS`: Components of the package which may be missing.
4063 * `FORWARD_VERSION_REQ`: If provided, the found version will be promoted to
4064 the minimum version required matching the given version scheme.
4065 * `VERSION_VAR`: The variable to use as the provided version (defaults to
4066 `<PACKAGE>_VERSION`). It may contain `@` in which case it will be
4067 configured. This is useful for modules which only provide components of the
4068 actual version number.
4069 * `CONFIG_MODE`: If present, pass `CONFIG` to the underlying `find_package`
4071 * `PRIVATE`: The dependency should not be exported to the install.
4073 The `PACKAGE` argument is the only required argument. The rest are optional.
4075 Note that `PRIVATE` is *only* applicable for private dependencies on interface
4076 targets (basically, header libraries) because some platforms require private
4077 shared libraries dependencies to be present when linking dependent libraries
4078 and executables as well.
4080 macro (vtk_module_find_package)
4081 # This needs to be a macro because find modules typically set variables which
4082 # may need to be available in the calling scope. If we declare that it only
4083 # works with imported targets (which is the primary motivating factor behind
4084 # this function), we can instead make it a function at the cost of any
4085 # non-target variables a module might want to set being available. It is
4086 # unlikely that this will be the case for all callers.
4087 if (NOT _vtk_build_module)
4089 "`vtk_module_find_package` may only be called when building a VTK "
4093 # Note: when adding arguments here, add them to the `unset` block at the end
4095 cmake_parse_arguments(_vtk_find_package
4096 "PRIVATE;CONFIG_MODE"
4097 "PACKAGE;VERSION;FORWARD_VERSION_REQ;VERSION_VAR"
4098 "COMPONENTS;OPTIONAL_COMPONENTS"
4101 if (_vtk_find_package_UNPARSED_ARGUMENTS)
4103 "Unparsed arguments for vtk_module_find_package: "
4104 "${_vtk_find_package_UNPARSED_ARGUMENTS}")
4107 if (NOT DEFINED _vtk_find_package_PACKAGE)
4109 "The `PACKAGE` argument is required.")
4112 if (DEFINED _vtk_find_package_FORWARD_VERSION_REQ)
4113 if (_vtk_find_package_PRIVATE)
4115 "The `FORWARD_VERSION_REQ` argument is incompatible with the "
4119 if (NOT _vtk_find_package_FORWARD_VERSION_REQ STREQUAL "MAJOR" AND
4120 NOT _vtk_find_package_FORWARD_VERSION_REQ STREQUAL "MINOR" AND
4121 NOT _vtk_find_package_FORWARD_VERSION_REQ STREQUAL "PATCH" AND
4122 NOT _vtk_find_package_FORWARD_VERSION_REQ STREQUAL "EXACT")
4124 "The `FORWARD_VERSION_REQ` argument must be one of `MAJOR`, `MINOR`, "
4125 "`PATCH`, or `EXACT`.")
4129 if (NOT DEFINED _vtk_find_package_VERSION_VAR)
4130 set(_vtk_find_package_VERSION_VAR
4131 "${_vtk_find_package_PACKAGE}_VERSION")
4134 set(_vtk_find_package_config)
4135 if (_vtk_find_package_CONFIG_MODE)
4136 set(_vtk_find_package_config "CONFIG")
4139 find_package("${_vtk_find_package_PACKAGE}"
4140 ${_vtk_find_package_VERSION}
4141 ${_vtk_find_package_config}
4142 COMPONENTS ${_vtk_find_package_COMPONENTS}
4143 OPTIONAL_COMPONENTS ${_vtk_find_package_OPTIONAL_COMPONENTS})
4144 if (NOT ${_vtk_find_package_PACKAGE}_FOUND)
4146 "Could not find the ${_vtk_find_package_PACKAGE} external dependency.")
4150 set(_vtk_find_package_optional_components_found)
4151 foreach (_vtk_find_package_optional_component IN LISTS _vtk_find_package_OPTIONAL_COMPONENTS)
4152 if (${_vtk_find_package_PACKAGE}_${_vtk_find_package_optional_component}_FOUND)
4153 list(APPEND _vtk_find_package_optional_components_found
4154 "${_vtk_find_package_optional_component}")
4158 if (NOT _vtk_find_package_PRIVATE)
4159 set_property(GLOBAL APPEND
4161 "_vtk_module_find_packages_${_vtk_build_PACKAGE}" "${_vtk_find_package_PACKAGE}")
4162 set(_vtk_find_package_base "_vtk_module_find_package_${_vtk_build_module}")
4163 set_property(GLOBAL APPEND
4165 "${_vtk_find_package_base}" "${_vtk_find_package_PACKAGE}")
4166 set(_vtk_find_package_base_package "${_vtk_find_package_base}_${_vtk_find_package_PACKAGE}")
4169 "${_vtk_find_package_base_package}_version" "${_vtk_find_package_VERSION}")
4172 "${_vtk_find_package_base_package}_config" "${_vtk_find_package_CONFIG_MODE}")
4173 set_property(GLOBAL APPEND
4175 "${_vtk_find_package_base_package}_components" "${_vtk_find_package_COMPONENTS}")
4176 set_property(GLOBAL APPEND
4178 "${_vtk_find_package_base_package}_optional_components" "${_vtk_find_package_OPTIONAL_COMPONENTS}")
4179 set_property(GLOBAL APPEND
4181 "${_vtk_find_package_base_package}_optional_components_found" "${_vtk_find_package_optional_components_found}")
4184 "${_vtk_find_package_base_package}_exact" "0")
4185 if (DEFINED _vtk_find_package_FORWARD_VERSION_REQ)
4186 string(FIND "${_vtk_find_package_VERSION_VAR}" "@" _vtk_find_package_idx)
4187 if (_vtk_find_package_idx EQUAL -1)
4188 if (NOT DEFINED "${_vtk_find_package_VERSION_VAR}")
4190 "The `${_vtk_find_package_VERSION_VAR}` variable is not defined.")
4192 set(_vtk_find_package_version "${${_vtk_find_package_VERSION_VAR}}")
4194 string(CONFIGURE "${_vtk_find_package_VERSION_VAR}" _vtk_find_package_version)
4196 unset(_vtk_find_package_idx)
4198 if ("${_vtk_find_package_version}" STREQUAL "")
4200 "The `${_vtk_find_package_PACKAGE}` version is empty.")
4203 if (_vtk_find_package_FORWARD_VERSION_REQ STREQUAL "MAJOR")
4204 set(_vtk_find_package_version_regex "^\([^.]*\).*")
4205 elseif (_vtk_find_package_FORWARD_VERSION_REQ STREQUAL "MINOR")
4206 set(_vtk_find_package_version_regex "^\([^.]*.[^.]*\).*")
4207 elseif (_vtk_find_package_FORWARD_VERSION_REQ STREQUAL "PATCH")
4208 set(_vtk_find_package_version_regex "^\([^.]*.[^.]*.[^.]*\).*")
4209 elseif (_vtk_find_package_FORWARD_VERSION_REQ STREQUAL "EXACT")
4210 set(_vtk_find_package_version_regex "^\\(.*\\)$")
4213 "${_vtk_find_package_base_package}_exact" "1")
4216 string(REGEX REPLACE "${_vtk_find_package_version_regex}" "\\1"
4217 _vtk_find_package_found_version "${_vtk_find_package_version}")
4218 unset(_vtk_find_package_version_regex)
4219 unset(_vtk_find_package_version)
4223 "${_vtk_find_package_base_package}_version" "${_vtk_find_package_found_version}")
4224 unset(_vtk_find_package_found_version)
4228 unset(_vtk_find_package_base)
4229 unset(_vtk_find_package_base_package)
4230 unset(_vtk_find_package_COMPONENTS)
4231 unset(_vtk_find_package_FORWARD_VERSION_REQ)
4232 unset(_vtk_find_package_OPTIONAL_COMPONENTS)
4233 unset(_vtk_find_package_PACKAGE)
4234 unset(_vtk_find_package_PRIVATE)
4235 unset(_vtk_find_package_UNPARSED_ARGUMENTS)
4236 unset(_vtk_find_package_VERSION)
4237 unset(_vtk_find_package_VERSION_VAR)
4242 @brief Export find_package calls for dependencies
4244 When installing a project that is meant to be found via `find_package` from
4245 CMake, using imported targets in the build means that imported targets need to
4246 be created during the `find_package` as well. This function writes a file
4247 suitable for inclusion from a `<package>-config.cmake` file to satisfy
4248 dependencies. It assumes that the exported targets are named
4249 `${CMAKE_FIND_PACKAGE_NAME}::${component}`. Dependent packages will only be
4250 found if a requested component requires the package to be found either directly
4254 vtk_module_export_find_packages(
4255 CMAKE_DESTINATION <directory>
4256 FILE_NAME <filename>
4257 [COMPONENT <component>]
4258 MODULES <module>...)
4261 The file will be named according to the `FILE_NAME` argument will be installed
4262 into `CMAKE_DESTINATION` in the build and install trees with the given
4263 filename. If not provided, the `development` component will be used.
4265 The `vtk_module_find_package` calls made by the modules listed in `MODULES`
4266 will be exported to this file.
4268 function (vtk_module_export_find_packages)
4269 cmake_parse_arguments(_vtk_export
4271 "CMAKE_DESTINATION;FILE_NAME;COMPONENT"
4275 if (_vtk_export_UNPARSED_ARGUMENTS)
4277 "Unparsed arguments for vtk_module_export_find_packages: "
4278 "${_vtk_export_UNPARSED_ARGUMENTS}")
4281 if (NOT DEFINED _vtk_export_CMAKE_DESTINATION)
4283 "The `CMAKE_DESTINATION` is required.")
4286 if (NOT DEFINED _vtk_export_FILE_NAME)
4288 "The `FILE_NAME` is required.")
4291 if (NOT DEFINED _vtk_export_COMPONENT)
4292 set(_vtk_export_COMPONENT "development")
4295 set(_vtk_export_output_file
4296 "${CMAKE_BINARY_DIR}/${_vtk_export_CMAKE_DESTINATION}/${_vtk_export_FILE_NAME}")
4297 file(WRITE "${_vtk_export_output_file}"
4298 "set(_vtk_module_find_package_quiet)
4299 if (\${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
4300 set(_vtk_module_find_package_quiet QUIET)
4303 set(_vtk_module_find_package_components_checked)
4304 set(_vtk_module_find_package_components_to_check
4305 \${\${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS})
4306 set(_vtk_module_find_package_components)
4307 set(_vtk_module_find_package_components_required)
4308 while (_vtk_module_find_package_components_to_check)
4309 list(GET _vtk_module_find_package_components_to_check 0 _vtk_module_component)
4310 list(REMOVE_AT _vtk_module_find_package_components_to_check 0)
4311 if (_vtk_module_component IN_LIST _vtk_module_find_package_components_checked)
4314 list(APPEND _vtk_module_find_package_components_checked
4315 \"\${_vtk_module_component}\")
4317 list(APPEND _vtk_module_find_package_components
4318 \"\${_vtk_module_component}\")
4319 if (\${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_\${_vtk_module_component})
4320 list(APPEND _vtk_module_find_package_components_required
4321 \"\${_vtk_module_component}\")
4324 if (TARGET \"\${CMAKE_FIND_PACKAGE_NAME}::\${_vtk_module_component}\")
4325 set(_vtk_module_find_package_component_target \"\${CMAKE_FIND_PACKAGE_NAME}::\${_vtk_module_component}\")
4326 elseif (TARGET \"\${_vtk_module_component}\")
4327 set(_vtk_module_find_package_component_target \"\${_vtk_module_component}\")
4329 # No such target for the component; skip.
4332 get_property(_vtk_module_find_package_depends
4333 TARGET \"\${_vtk_module_find_package_component_target}\"
4334 PROPERTY \"INTERFACE_vtk_module_depends\")
4335 string(REPLACE \"\${CMAKE_FIND_PACKAGE_NAME}::\" \"\" _vtk_module_find_package_depends \"\${_vtk_module_find_package_depends}\")
4336 list(APPEND _vtk_module_find_package_components_to_check
4337 \${_vtk_module_find_package_depends})
4338 get_property(_vtk_module_find_package_depends
4339 TARGET \"\${_vtk_module_find_package_component_target}\"
4340 PROPERTY \"INTERFACE_vtk_module_private_depends\")
4341 string(REPLACE \"\${CMAKE_FIND_PACKAGE_NAME}::\" \"\" _vtk_module_find_package_depends \"\${_vtk_module_find_package_depends}\")
4342 list(APPEND _vtk_module_find_package_components_to_check
4343 \${_vtk_module_find_package_depends})
4344 get_property(_vtk_module_find_package_depends
4345 TARGET \"\${_vtk_module_find_package_component_target}\"
4346 PROPERTY \"INTERFACE_vtk_module_optional_depends\")
4347 foreach (_vtk_module_find_package_depend IN LISTS _vtk_module_find_package_depends)
4348 if (TARGET \"\${_vtk_module_find_package_depend}\")
4349 string(REPLACE \"\${CMAKE_FIND_PACKAGE_NAME}::\" \"\" _vtk_module_find_package_depend \"\${_vtk_module_find_package_depend}\")
4350 list(APPEND _vtk_module_find_package_components_to_check
4351 \"\${_vtk_module_find_package_depend}\")
4354 get_property(_vtk_module_find_package_depends
4355 TARGET \"\${_vtk_module_find_package_component_target}\"
4356 PROPERTY \"INTERFACE_vtk_module_forward_link\")
4357 string(REPLACE \"\${CMAKE_FIND_PACKAGE_NAME}::\" \"\" _vtk_module_find_package_depends \"\${_vtk_module_find_package_depends}\")
4358 list(APPEND _vtk_module_find_package_components_to_check
4359 \${_vtk_module_find_package_depends})
4361 get_property(_vtk_module_find_package_kit
4362 TARGET \"\${_vtk_module_find_package_component_target}\"
4363 PROPERTY \"INTERFACE_vtk_module_kit\")
4364 if (_vtk_module_find_package_kit)
4365 get_property(_vtk_module_find_package_kit_modules
4366 TARGET \"\${_vtk_module_find_package_kit}\"
4367 PROPERTY \"INTERFACE_vtk_kit_kit_modules\")
4368 string(REPLACE \"\${CMAKE_FIND_PACKAGE_NAME}::\" \"\" _vtk_module_find_package_kit_modules \"\${_vtk_module_find_package_kit_modules}\")
4369 list(APPEND _vtk_module_find_package_components_to_check
4370 \${_vtk_module_find_package_kit_modules})
4373 unset(_vtk_module_find_package_component_target)
4374 unset(_vtk_module_find_package_components_to_check)
4375 unset(_vtk_module_find_package_components_checked)
4376 unset(_vtk_module_component)
4377 unset(_vtk_module_find_package_depend)
4378 unset(_vtk_module_find_package_depends)
4379 unset(_vtk_module_find_package_kit)
4380 unset(_vtk_module_find_package_kit_modules)
4382 if (_vtk_module_find_package_components)
4383 list(REMOVE_DUPLICATES _vtk_module_find_package_components)
4385 if (_vtk_module_find_package_components_required)
4386 list(REMOVE_DUPLICATES _vtk_module_find_package_components_required)
4389 foreach (_vtk_export_module IN LISTS _vtk_export_MODULES)
4390 get_property(_vtk_export_target_name GLOBAL
4391 PROPERTY "_vtk_module_${_vtk_export_module}_target_name")
4392 set(_vtk_export_base "_vtk_module_find_package_${_vtk_export_module}")
4393 get_property(_vtk_export_packages GLOBAL
4394 PROPERTY "${_vtk_export_base}")
4395 if (NOT _vtk_export_packages)
4399 file(APPEND "${_vtk_export_output_file}"
4400 "set(_vtk_module_find_package_enabled OFF)
4401 set(_vtk_module_find_package_is_required OFF)
4402 set(_vtk_module_find_package_fail_if_not_found OFF)
4403 if (_vtk_module_find_package_components)
4404 if (\"${_vtk_export_target_name}\" IN_LIST _vtk_module_find_package_components)
4405 set(_vtk_module_find_package_enabled ON)
4406 if (\"${_vtk_export_target_name}\" IN_LIST _vtk_module_find_package_components_required)
4407 set(_vtk_module_find_package_is_required \"\${\${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED}\")
4408 set(_vtk_module_find_package_fail_if_not_found ON)
4412 set(_vtk_module_find_package_enabled ON)
4413 set(_vtk_module_find_package_is_required \"\${\${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED}\")
4414 set(_vtk_module_find_package_fail_if_not_found ON)
4417 if (_vtk_module_find_package_enabled)
4418 set(_vtk_module_find_package_required)
4419 if (_vtk_module_find_package_is_required)
4420 set(_vtk_module_find_package_required REQUIRED)
4423 list(REMOVE_DUPLICATES _vtk_export_packages)
4424 foreach (_vtk_export_package IN LISTS _vtk_export_packages)
4425 set(_vtk_export_base_package "${_vtk_export_base}_${_vtk_export_package}")
4426 get_property(_vtk_export_version GLOBAL
4427 PROPERTY "${_vtk_export_base_package}_version")
4428 get_property(_vtk_export_config GLOBAL
4429 PROPERTY "${_vtk_export_base_package}_config")
4430 get_property(_vtk_export_exact GLOBAL
4431 PROPERTY "${_vtk_export_base_package}_exact")
4432 get_property(_vtk_export_components GLOBAL
4433 PROPERTY "${_vtk_export_base_package}_components")
4434 get_property(_vtk_export_optional_components GLOBAL
4435 PROPERTY "${_vtk_export_base_package}_optional_components")
4436 get_property(_vtk_export_optional_components_found GLOBAL
4437 PROPERTY "${_vtk_export_base_package}_optional_components_found")
4439 # Assume that any found optional components end up being required.
4440 if (${_vtk_export_base_package}_optional_components_found)
4441 list(REMOVE_ITEM _vtk_export_optional_components
4442 ${_vtk_export_optional_components_found})
4443 list(APPEND _vtk_export_components
4444 ${_vtk_export_optional_components_found})
4447 set(_vtk_export_config_arg)
4448 if (_vtk_export_config)
4449 set(_vtk_export_config_arg CONFIG)
4452 set(_vtk_export_exact_arg)
4453 if (_vtk_export_exact)
4454 set(_vtk_export_exact_arg EXACT)
4457 file(APPEND "${_vtk_export_output_file}"
4458 " find_package(${_vtk_export_package}
4459 ${_vtk_export_version}
4460 ${_vtk_export_exact_arg}
4461 ${_vtk_export_config_arg}
4462 \${_vtk_module_find_package_quiet}
4463 \${_vtk_module_find_package_required}
4464 COMPONENTS ${_vtk_export_components}
4465 OPTIONAL_COMPONENTS ${_vtk_export_optional_components})
4466 if (NOT ${_vtk_export_package}_FOUND AND _vtk_module_find_package_fail_if_not_found)
4467 if (NOT \${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
4469 \"Could not find the \${CMAKE_FIND_PACKAGE_NAME} package due to a \"
4470 \"missing dependency: ${_vtk_export_package}\")
4472 set(\"\${CMAKE_FIND_PACKAGE_NAME}_${_vtk_export_target_name}_FOUND\" 0)
4473 list(APPEND \"\${CMAKE_FIND_PACKAGE_NAME}_${_vtk_export_target_name}_NOT_FOUND_MESSAGE\"
4474 \"Failed to find the ${_vtk_export_package} package.\")
4478 file(APPEND "${_vtk_export_output_file}"
4481 unset(_vtk_module_find_package_fail_if_not_found)
4482 unset(_vtk_module_find_package_enabled)
4483 unset(_vtk_module_find_package_required)\n\n")
4487 file(APPEND "${_vtk_export_output_file}"
4488 "unset(_vtk_module_find_package_components)
4489 unset(_vtk_module_find_package_components_required)
4490 unset(_vtk_module_find_package_quiet)\n")
4493 FILES "${CMAKE_BINARY_DIR}/${_vtk_export_CMAKE_DESTINATION}/${_vtk_export_FILE_NAME}"
4494 DESTINATION "${_vtk_export_CMAKE_DESTINATION}"
4495 COMPONENT "${_vtk_export_COMPONENT}")
4499 @page module-overview
4502 @section module-third-party Third party support
4504 The module system acknowledges that third party support is a pain and offers
4505 APIs to help wrangle them. Sometimes third party code needs a shim introduced
4506 to make it behave better, so an `INTERFACE` library to add that in is very
4507 useful. Other times, third party code is hard to ensure that it exists
4508 everywhere, so it is bundled. When that happens, the ability to select between
4509 the bundled copy and an external copy is useful. All three (and more) of these
4512 The following functions are used to handle third party modules:
4514 - @ref vtk_module_third_party
4515 - @ref vtk_module_third_party_external
4516 - @ref vtk_module_third_party_internal
4521 @brief Third party module
4523 When a project has modules which represent third party packages, there are some
4524 convenience functions to help deal with them. First, there is the meta-wrapper:
4527 vtk_module_third_party(
4528 [INTERNAL <internal arguments>...]
4529 [EXTERNAL <external arguments>...])
4532 This offers a cache variable named `VTK_MODULE_USE_EXTERNAL_<module name>` that
4533 may be set to trigger between the internal copy and an externally provided
4534 copy. This is available as a local variable named
4535 `VTK_MODULE_USE_EXTERNAL_<library name>`. See the
4536 @ref vtk_module_third_party_external and @ref vtk_module_third_party_internal
4537 functions for the arguments supported by the `EXTERNAL` and `INTERNAL`
4538 arguments, respectively.
4540 function (vtk_module_third_party)
4541 cmake_parse_arguments(_vtk_third_party
4547 if (_vtk_third_party_UNPARSED_ARGUMENTS)
4549 "Unparsed arguments for vtk_module_third_party: "
4550 "${_vtk_third_party_UNPARSED_ARGUMENTS}")
4553 string(REPLACE "::" "_" _vtk_build_module_safe "${_vtk_build_module}")
4554 option("VTK_MODULE_USE_EXTERNAL_${_vtk_build_module_safe}"
4555 "Use externally provided ${_vtk_build_module}"
4556 "${_vtk_build_USE_EXTERNAL}")
4557 mark_as_advanced("VTK_MODULE_USE_EXTERNAL_${_vtk_build_module_safe}")
4558 get_property(_vtk_third_party_library_name GLOBAL
4559 PROPERTY "_vtk_module_${_vtk_build_module}_library_name")
4560 set("VTK_MODULE_USE_EXTERNAL_${_vtk_third_party_library_name}"
4561 "${VTK_MODULE_USE_EXTERNAL_${_vtk_build_module_safe}}"
4564 if (VTK_MODULE_USE_EXTERNAL_${_vtk_build_module_safe})
4565 # XXX(cmake): https://gitlab.kitware.com/cmake/cmake/issues/16364.
4566 # Unset a variable which CMake doesn't like when switching between real
4567 # libraries (internal) and interface libraries (external).
4568 unset(
"${_vtk_build_module}_LIB_DEPENDS" CACHE)
4571 # Bubble up variables again.
4572 foreach (_vtk_third_party_variable IN LISTS _vtk_third_party_variables)
4573 set(
"${_vtk_third_party_variable}"
4574 "${${_vtk_third_party_variable}}"
4578 set(_vtk_third_party_has_external_support 1)
4584 @ingroup module-
impl
4585 @brief Mark a module as being third party
4587 Mark a module as being a third party module.
4595 set_target_properties(
"${target}"
4597 "INTERFACE_vtk_module_exclude_wrap" 1
4598 "INTERFACE_vtk_module_third_party" 1)
4603 @brief External third party
package
4605 A third party dependency may be expressed as a module using this function.
4606 Third party packages are found using CMake's `find_package` function. It is
4607 highly recommended that imported targets are used to make usage easier. The
4608 module itself will be created as an `INTERFACE` library which exposes the
4612 vtk_module_third_party_external(
4615 [COMPONENTS <component>...]
4616 [OPTIONAL_COMPONENTS <component>...]
4617 [INCLUDE_DIRS <path-or-variable>...]
4618 [LIBRARIES <target-or-variable>...]
4619 [DEFINITIONS <variable>...]
4620 [FORWARD_VERSION_REQ <MAJOR|MINOR|PATCH|EXACT>]
4621 [VERSION_VAR <version-spec>]
4622 [USE_VARIABLES <variable>...]
4624 [STANDARD_INCLUDE_DIRS])
4627 Only the `PACKAGE` argument is required. The arguments are as follows:
4629 * `PACKAGE`: (Required) The name of the package to find.
4630 * `VERSION`: If specified, the minimum version of the dependency that must be
4632 * `COMPONENTS`: The list of components to request from the package.
4633 * `OPTIONAL_COMPONENTS`: The list of optional components to request from the
4635 * `STANDARD_INCLUDE_DIRS`: If present, standard include directories will be
4636 added to the module target. This is usually only required if both internal
4637 and external are supported for a given dependency.
4638 * `INCLUDE_DIRS`: If specified, this is added as a `SYSTEM INTERFACE` include
4639 directory for the target. If a variable name is given, it will be
4641 * `LIBRARIES`: The libraries to link from the package. If a variable name is
4642 given, it will be dereferenced, however a warning that imported targets are
4643 not being used will be emitted.
4644 * `DEFINITIONS`: If specified, the given variables will be added to the
4645 target compile definitions interface.
4646 * `CONFIG_MODE`: Force `CONFIG` mode.
4647 * `FORWARD_VERSION_REQ` and `VERSION_VAR`: See documentation for
4648 @ref vtk_module_find_package.
4649 * `USE_VARIABLES`: List of variables from the `find_package` to make
4650 available to the caller.
4652 function (vtk_module_third_party_external)
4653 cmake_parse_arguments(_vtk_third_party_external
4654 "STANDARD_INCLUDE_DIRS;CONFIG_MODE
"
4655 "VERSION;PACKAGE;FORWARD_VERSION_REQ;VERSION_VAR
"
4656 "COMPONENTS;OPTIONAL_COMPONENTS;LIBRARIES;INCLUDE_DIRS;DEFINITIONS;TARGETS;USE_VARIABLES
"
4659 if (_vtk_third_party_external_UNPARSED_ARGUMENTS)
4662 "${_vtk_third_party_external_UNPARSED_ARGUMENTS}
")
4665 get_property(_vtk_third_party_external_is_third_party GLOBAL
4666 PROPERTY "_vtk_module_${_vtk_build_module}_third_party
")
4667 if (NOT _vtk_third_party_external_is_third_party)
4669 "The ${_vtk_build_module} has not been declared as a third party
"
4673 if (NOT DEFINED _vtk_third_party_external_PACKAGE)
4675 "The `PACKAGE` argument is required.
")
4678 set(_vtk_third_party_external_args)
4679 if (DEFINED _vtk_third_party_external_FORWARD_VERSION_REQ)
4680 list(APPEND _vtk_third_party_external_args
4681 FORWARD_VERSION_REQ "${_vtk_third_party_external_FORWARD_VERSION_REQ}
")
4683 if (DEFINED _vtk_third_party_external_VERSION_VAR)
4684 list(APPEND _vtk_third_party_external_args
4685 VERSION_VAR "${_vtk_third_party_external_VERSION_VAR}
")
4688 if (_vtk_third_party_external_TARGETS)
4689 set(_vtk_third_party_external_config_mode)
4690 if (_vtk_third_party_external_CONFIG_MODE)
4691 set(_vtk_third_party_external_config_mode "CONFIG_MODE
")
4694 # If we have targets, they must be exported to the install as well.
4695 vtk_module_find_package(
4696 PACKAGE "${_vtk_third_party_external_PACKAGE}
"
4697 VERSION "${_vtk_third_party_external_VERSION}
"
4698 COMPONENTS ${_vtk_third_party_external_COMPONENTS}
4699 OPTIONAL_COMPONENTS ${_vtk_third_party_external_OPTIONAL_COMPONENTS}
4700 ${_vtk_third_party_external_config_mode}
4701 ${_vtk_third_party_external_args})
4703 set(_vtk_third_party_external_config)
4704 if (_vtk_third_party_external_CONFIG_MODE)
4705 set(_vtk_third_party_external_config "CONFIG
")
4708 # If there are no targets, the install uses strings and therefore does not
4709 # need to find the dependency again.
4710 find_package("${_vtk_third_party_external_PACKAGE}
"
4711 ${_vtk_third_party_external_VERSION}
4712 ${_vtk_third_party_external_config}
4713 COMPONENTS ${_vtk_third_party_external_COMPONENTS}
4714 OPTIONAL_COMPONENTS ${_vtk_third_party_external_OPTIONAL_COMPONENTS})
4717 get_property(_vtk_third_party_external_target_name GLOBAL
4718 PROPERTY "_vtk_module_${_vtk_build_module}_target_name
")
4720 # Check if an imported target of the same name already exists.
4721 set(_vtk_third_party_external_real_target_name
4722 "${_vtk_third_party_external_target_name}
")
4723 set(_vtk_third_party_external_using_mangled_name OFF)
4724 if (TARGET "${_vtk_third_party_external_target_name}
")
4725 # Ensure that the target collision comes from an imported target.
4726 get_property(_vtk_third_party_external_is_imported
4727 TARGET "${_vtk_third_party_external_target_name}
"
4729 if (NOT _vtk_third_party_external_is_imported)
4731 "It appears as though there is a conflicting
target named
"
4732 "`${_vtk_third_party_external_target_name}` expected to be used by
"
4733 "the `${_vtk_build_module}` module already added to the build. This
"
4734 "conflicts with the
target name expected to be used by an external
"
4735 "third party dependency.
")
4738 # If it does, we need to have a module name that is not the same as this
4739 # one. Error out if this is detected.
4740 if (_vtk_build_module STREQUAL _vtk_third_party_external_target_name)
4742 "An imported
target has the same
name used by the module system
for "
4743 "the facade of the external dependency
for `${_vtk_build_module}`.
"
4744 "This module must be either renamed or placed into a
namespace.
")
4747 # Mangle the internal name. The alias is the expected use case anyways and
4748 # since this is an INTERFACE target, there's nothing to break with respect
4749 # to `make $target` anyways.
4750 string(APPEND _vtk_third_party_external_real_target_name
4751 "_vtk_module_mangle
")
4752 set_property(GLOBAL APPEND_STRING
4753 PROPERTY "_vtk_module_${_vtk_build_module}_target_name
"
4754 "_vtk_module_mangle
")
4755 set(_vtk_third_party_external_using_mangled_name ON)
4758 add_library("${_vtk_third_party_external_real_target_name}
" INTERFACE)
4759 if (_vtk_third_party_external_using_mangled_name)
4760 set_property(TARGET "${_vtk_third_party_external_real_target_name}
"
4762 EXPORT_NAME "${_vtk_third_party_external_target_name}
")
4764 if (NOT _vtk_build_module STREQUAL _vtk_third_party_external_target_name)
4765 add_library("${_vtk_build_module}
" ALIAS
4766 "${_vtk_third_party_external_real_target_name}
")
4769 if (_vtk_third_party_external_STANDARD_INCLUDE_DIRS)
4770 _vtk_module_standard_includes(TARGET "${_vtk_third_party_external_real_target_name}
"
4774 # Try to use targets if they're specified and available.
4775 set(_vtk_third_party_external_have_targets FALSE)
4776 set(_vtk_third_party_external_used_targets FALSE)
4777 if (_vtk_third_party_external_TARGETS)
4778 set(_vtk_third_party_external_have_targets TRUE)
4779 set(_vtk_third_party_external_all_targets_okay TRUE)
4780 foreach (_vtk_third_party_external_target IN LISTS _vtk_third_party_external_TARGETS)
4781 if (NOT TARGET "${_vtk_third_party_external_target}
")
4782 set(_vtk_third_party_external_all_targets_okay FALSE)
4787 if (_vtk_third_party_external_all_targets_okay)
4788 target_link_libraries("${_vtk_third_party_external_real_target_name}
"
4790 ${_vtk_third_party_external_TARGETS})
4791 set(_vtk_third_party_external_used_targets TRUE)
4795 if (NOT _vtk_third_party_external_used_targets)
4796 if (NOT _vtk_third_party_external_have_targets)
4798 "A third party dependency
for ${_vtk_build_module} was found externally
"
4799 "using paths rather than targets; it is recommended to use imported
"
4800 "targets rather than find_library and such.
")
4803 set(_vtk_third_party_external_have_includes FALSE)
4804 foreach (_vtk_third_party_external_include_dir IN LISTS _vtk_third_party_external_INCLUDE_DIRS)
4805 if (DEFINED "${_vtk_third_party_external_include_dir}
")
4806 if (${_vtk_third_party_external_include_dir})
4807 set(_vtk_third_party_external_have_includes TRUE)
4809 target_include_directories("${_vtk_third_party_external_real_target_name}
" SYSTEM
4810 INTERFACE "${${_vtk_third_party_external_include_dir}}
")
4814 if (_vtk_third_party_external_have_targets AND
4815 NOT _vtk_third_party_external_have_includes)
4817 "A third party dependency
for ${_vtk_build_module} has external targets
"
4818 "which were not found and no `INCLUDE_DIRS` were found either.
"
4819 "Including
this module may not work.
")
4822 foreach (_vtk_third_party_external_define IN LISTS _vtk_third_party_external_DEFINITIONS)
4823 if (DEFINED "${_vtk_third_party_external_define}
")
4824 target_compile_definitions("${_vtk_third_party_external_real_target_name}
"
4825 INTERFACE "${${_vtk_third_party_external_define}}
")
4829 set(_vtk_third_party_external_have_libraries FALSE)
4830 foreach (_vtk_third_party_external_library IN LISTS _vtk_third_party_external_LIBRARIES)
4831 if (DEFINED "${_vtk_third_party_external_library}
")
4832 if (${_vtk_third_party_external_library})
4833 set(_vtk_third_party_external_have_libraries TRUE)
4835 target_link_libraries("${_vtk_third_party_external_real_target_name}
"
4836 INTERFACE "${${_vtk_third_party_external_library}}
")
4840 if (_vtk_third_party_external_have_targets AND
4841 NOT _vtk_third_party_external_have_libraries)
4843 "A third party dependency
for ${_vtk_build_module} has external targets
"
4844 "which were not found and no `LIBRARIES` were found either. Linking to
"
4845 "this this module may not work.
")
4849 if (DEFINED _vtk_third_party_external_USE_VARIABLES)
4850 # If we're called from `vtk_module_third_party`, the variables need bubbled
4852 if (DEFINED _vtk_third_party_EXTERNAL)
4853 set(_vtk_third_party_variables
4854 "${_vtk_third_party_external_USE_VARIABLES}
"
4858 foreach (_vtk_third_party_external_variable IN LISTS _vtk_third_party_external_USE_VARIABLES)
4859 if (NOT DEFINED "${_vtk_third_party_external_variable}
")
4861 "The variable `${_vtk_third_party_external_variable}` was expected
"
4862 "to have been available, but was not defined.
")
4865 set("${_vtk_third_party_external_variable}
"
4866 "${${_vtk_third_party_external_variable}}
"
4871 _vtk_module_mark_third_party("${_vtk_third_party_external_real_target_name}
")
4872 _vtk_module_install("${_vtk_third_party_external_real_target_name}
")
4877 @brief Internal third party package
4879 Third party modules may also be bundled with the project itself. In this case,
4880 it is an internal third party dependency. The dependency is assumed to be in a
4881 subdirectory that will be used via `add_subdirectory`. Unless it is marked as
4882 `HEADERS_ONLY`, it is assumed that it will create a target with the name of the
4886 vtk_module_third_party_internal(
4887 [SUBDIRECTORY <path>]
4888 [HEADERS_SUBDIR <subdir>]
4889 [LICENSE_FILES <file>...]
4893 [STANDARD_INCLUDE_DIRS])
4896 All arguments are optional, however warnings are emitted if `LICENSE_FILES` or
4897 `VERSION` is not specified. They are as follows:
4899 * `SUBDIRECTORY`: (Defaults to the library name of the module) The
4900 subdirectory containing the `CMakeLists.txt` for the dependency.
4901 * `HEADERS_SUBDIR`: If non-empty, the subdirectory to use for installing
4903 * `LICENSE_FILES`: A list of license files to install for the dependency. If
4904 not given, a warning will be emitted.
4905 * `VERSION`: The version of the library that is included.
4906 * `HEADER_ONLY`: The dependency is header only and will not create a target.
4907 * `INTERFACE`: The dependency is an `INTERFACE` library.
4908 * `STANDARD_INCLUDE_DIRS`: If present, module-standard include directories
4909 will be added to the module target.
4911 function (vtk_module_third_party_internal)
4912 # TODO: Support scanning for third-party modules which don't support an
4915 cmake_parse_arguments(_vtk_third_party_internal
4916 "INTERFACE;HEADER_ONLY;STANDARD_INCLUDE_DIRS
"
4917 "SUBDIRECTORY;HEADERS_SUBDIR;VERSION
"
4921 if (_vtk_third_party_internal_UNPARSED_ARGUMENTS)
4924 "${_vtk_third_party_internal_UNPARSED_ARGUMENTS}
")
4927 get_property(_vtk_third_party_internal_is_third_party GLOBAL
4928 PROPERTY "_vtk_module_${_vtk_build_module}_third_party
")
4929 if (NOT _vtk_third_party_internal_is_third_party)
4931 "The ${_vtk_build_module} has not been declared as a third party
"
4935 get_property(_vtk_third_party_internal_library_name GLOBAL
4936 PROPERTY "_vtk_module_${_vtk_build_module}_library_name
")
4937 if (NOT DEFINED _vtk_third_party_internal_SUBDIRECTORY)
4938 set(_vtk_third_party_internal_SUBDIRECTORY "${_vtk_third_party_internal_library_name}
")
4941 if (NOT DEFINED _vtk_third_party_internal_LICENSE_FILES)
4943 "The ${_vtk_build_module} third party
package is embedded, but does not "
4944 "specify any license files.")
4947 if (NOT DEFINED _vtk_third_party_internal_VERSION)
4949 "The ${_vtk_build_module} third party package is embedded, but does not "
4950 "specify the version it is based on.")
4953 get_property(_vtk_third_party_internal_target_name GLOBAL
4954 PROPERTY "_vtk_module_${_vtk_build_module}_target_name")
4955 set(_vtk_third_party_internal_include_type)
4956 if (_vtk_third_party_internal_INTERFACE)
4957 set(_vtk_third_party_internal_include_type INTERFACE)
4958 elseif (_vtk_third_party_internal_HEADER_ONLY)
4959 add_library("${_vtk_third_party_internal_target_name}" INTERFACE)
4960 if (NOT _vtk_build_module STREQUAL _vtk_third_party_internal_target_name)
4961 add_library("${_vtk_build_module}" ALIAS
4962 "${_vtk_third_party_internal_target_name}")
4964 set(_vtk_third_party_internal_include_type INTERFACE)
4965 set(_vtk_third_party_internal_STANDARD_INCLUDE_DIRS 1)
4968 add_subdirectory("${_vtk_third_party_internal_SUBDIRECTORY}")
4970 if (NOT TARGET "${_vtk_build_module}")
4972 "The ${_vtk_build_module} is being built as an internal third party "
4973 "library, but a matching target was not created.")
4976 if (_vtk_third_party_internal_STANDARD_INCLUDE_DIRS)
4977 _vtk_module_standard_includes(
4978 TARGET "${_vtk_third_party_internal_target_name}"
4979 SYSTEM ${_vtk_third_party_internal_include_type}
4980 HEADERS_DESTINATION "${_vtk_build_HEADERS_DESTINATION}/${_vtk_third_party_internal_HEADERS_SUBDIR}")
4983 _vtk_module_apply_properties("${_vtk_third_party_internal_target_name}")
4984 if (_vtk_third_party_internal_INTERFACE)
4986 elseif (_vtk_third_party_internal_HEADER_ONLY)
4987 _vtk_module_install("${_vtk_third_party_internal_target_name}")
4990 if (_vtk_third_party_internal_LICENSE_FILES)
4992 FILES ${_vtk_third_party_internal_LICENSE_FILES}
4993 DESTINATION "${_vtk_build_LICENSE_DESTINATION}/${_vtk_third_party_internal_library_name}/"
4994 COMPONENT "license")
4997 _vtk_module_mark_third_party("${_vtk_third_party_internal_target_name}")