110 PROPERTY
"exclude_wrap"
111 VARIABLE _vtk_python_exclude_wrap)
112 if (_vtk_python_exclude_wrap)
116 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_python_library_name}Python
")
118 set(_vtk_python_args_file "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_python_library_name}Python/${_vtk_python_library_name}-python.$<CONFIGURATION>.args
")
120 set(_vtk_python_hierarchy_depends "${
module}")
121 _vtk_module_get_module_property("${module}"
122 PROPERTY "private_depends"
123 VARIABLE _vtk_python_private_depends)
124 list(APPEND _vtk_python_hierarchy_depends
125 ${_vtk_python_private_depends})
126 _vtk_module_get_module_property("${module}"
127 PROPERTY "optional_depends"
128 VARIABLE _vtk_python_optional_depends)
129 foreach (_vtk_python_optional_depend IN LISTS _vtk_python_optional_depends)
130 if (TARGET "${_vtk_python_optional_depend}")
131 list(APPEND _vtk_python_hierarchy_depends
132 "${_vtk_python_optional_depend}")
136 set(_vtk_python_command_depends)
137 foreach (_vtk_python_hierarchy_depend IN LISTS _vtk_python_hierarchy_depends)
138 _vtk_module_get_module_property("${_vtk_python_hierarchy_depend}"
140 VARIABLE _vtk_python_hierarchy_file)
141 if (_vtk_python_hierarchy_file)
142 list(APPEND _vtk_python_hierarchy_files "${_vtk_python_hierarchy_file}")
143 get_property(_vtk_python_is_imported
144 TARGET "${_vtk_python_hierarchy_depend}"
146 if (_vtk_python_is_imported OR CMAKE_GENERATOR MATCHES "Ninja")
147 list(APPEND _vtk_python_command_depends "${_vtk_python_hierarchy_file}")
149 _vtk_module_get_module_property("${_vtk_python_hierarchy_depend}"
150 PROPERTY "library_name"
151 VARIABLE _vtk_python_hierarchy_library_name)
152 if (TARGET "${_vtk_python_hierarchy_library_name}-hierarchy")
153 list(APPEND _vtk_python_command_depends "${_vtk_python_hierarchy_library_name}-hierarchy")
156 "The ${_vtk_python_hierarchy_depend} hierarchy file is attached to a non-imported target "
157 "and a hierarchy target (${_vtk_python_hierarchy_library_name}-hierarchy) is "
164 set(_vtk_python_genex_compile_definitions
165 "$<TARGET_PROPERTY:${_vtk_python_target_name},COMPILE_DEFINITIONS>")
166 set(_vtk_python_genex_include_directories
167 "$<TARGET_PROPERTY:${_vtk_python_target_name},INCLUDE_DIRECTORIES>")
169 OUTPUT "${_vtk_python_args_file}"
170 CONTENT "$<$<BOOL:${_vtk_python_genex_compile_definitions}>:\n-D\'$<JOIN:${_vtk_python_genex_compile_definitions},\'\n-D\'>\'>\n
171$<$<BOOL:${_vtk_python_genex_include_directories}>:\n-I\'$<JOIN:${_vtk_python_genex_include_directories},\'\n-I\'>\'>\n
172$<$<BOOL:${_vtk_python_hierarchy_files}>:\n--types \'$<JOIN:${_vtk_python_hierarchy_files},\'\n--types \'>\'>\n")
174 set(_vtk_python_sources)
176 # Get the list of public headers from the module.
177 _vtk_module_get_module_property("${module}"
179 VARIABLE _vtk_python_headers)
180 set(_vtk_python_classes)
181 foreach (_vtk_python_header IN LISTS _vtk_python_headers)
182 # Assume the class name matches the basename of the header. This is VTK
184 get_filename_component(_vtk_python_basename "${_vtk_python_header}" NAME_WE)
185 list(APPEND _vtk_python_classes
186 "${_vtk_python_basename}")
188 set(_vtk_python_source_output
189 "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_python_library_name}Python/${_vtk_python_basename}Python.cxx")
190 list(APPEND _vtk_python_sources
191 "${_vtk_python_source_output}")
193 set(_vtk_python_wrap_target "VTK::WrapPython")
194 set(_vtk_python_macros_args)
195 if (TARGET VTKCompileTools::WrapPython)
196 set(_vtk_python_wrap_target "VTKCompileTools::WrapPython")
197 if (TARGET VTKCompileTools_macros)
198 list(APPEND _vtk_python_command_depends
199 "VTKCompileTools_macros")
200 list(APPEND _vtk_python_macros_args
202 -imacros "${_VTKCompileTools_macros_file}")
207 OUTPUT "${_vtk_python_source_output}"
208 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR}
209 "$<TARGET_FILE:${_vtk_python_wrap_target}>"
210 "@${_vtk_python_args_file}"
211 -o "${_vtk_python_source_output}"
212 "${_vtk_python_header}"
213 ${_vtk_python_macros_args}
215 CXX "${_vtk_python_header}"
216 COMMENT "Generating Python wrapper sources for ${_vtk_python_basename}"
218 "${_vtk_python_header}"
219 "${_vtk_python_args_file}"
220 "$<TARGET_FILE:${_vtk_python_wrap_target}>"
221 ${_vtk_python_command_depends})
225 "${_vtk_python_sources}"
228 "${_vtk_python_classes}"
250function (_vtk_module_wrap_python_library name)
251 set(_vtk_python_library_sources)
252 set(_vtk_python_library_classes)
253 foreach (_vtk_python_module IN LISTS ARGN)
254 _vtk_module_get_module_property("${_vtk_python_module}"
255 PROPERTY "exclude_wrap"
256 VARIABLE _vtk_python_exclude_wrap)
257 if (_vtk_python_exclude_wrap)
260 _vtk_module_real_target(_vtk_python_target_name "${_vtk_python_module}")
261 _vtk_module_get_module_property("${_vtk_python_module}"
262 PROPERTY "library_name"
263 VARIABLE _vtk_python_library_name)
265 # Wrap the module independently of the other VTK modules in the Python
267 _vtk_module_wrap_python_sources("${_vtk_python_module}" _vtk_python_sources _vtk_python_classes)
268 list(APPEND _vtk_python_library_sources
269 ${_vtk_python_sources})
270 list(APPEND _vtk_python_library_classes
271 ${_vtk_python_classes})
273 # Make sure the module doesn't already have an associated Python package.
274 vtk_module_get_property("${_vtk_python_module}"
275 PROPERTY "INTERFACE_vtk_module_python_package"
276 VARIABLE _vtk_python_current_python_package)
277 if (DEFINED _vtk_python_current_python_package)
279 "It appears as though the ${_vtk_python_module} has already been "
280 "wrapped in Python in the ${_vtk_python_current_python_package} "
283 vtk_module_set_property("${_vtk_python_module}"
284 PROPERTY "INTERFACE_vtk_module_python_package"
285 VALUE "${_vtk_python_PYTHON_PACKAGE}")
287 if (_vtk_python_INSTALL_HEADERS)
288 _vtk_module_export_properties(
289 BUILD_FILE "${_vtk_python_properties_build_file}"
290 INSTALL_FILE "${_vtk_python_properties_install_file}"
291 MODULE "${_vtk_python_module}"
293 # Export the wrapping hints file.
294 INTERFACE_vtk_module_python_package)
298 # The foreach needs to be split so that dependencies are guaranteed to have
299 # the INTERFACE_vtk_module_python_package property set.
300 foreach (_vtk_python_module IN LISTS ARGN)
301 _vtk_module_get_module_property("${_vtk_python_module}"
302 PROPERTY "exclude_wrap"
303 VARIABLE _vtk_python_exclude_wrap)
304 if (_vtk_python_exclude_wrap)
308 _vtk_module_get_module_property("${_vtk_python_module}"
309 PROPERTY "library_name"
310 VARIABLE _vtk_python_library_name)
312 _vtk_module_get_module_property("${_vtk_python_module}"
314 VARIABLE _vtk_python_module_depends)
315 set(_vtk_python_module_load_depends)
316 foreach (_vtk_python_module_depend IN LISTS _vtk_python_module_depends)
317 _vtk_module_get_module_property("${_vtk_python_module_depend}"
318 PROPERTY "exclude_wrap"
319 VARIABLE _vtk_python_module_depend_exclude_wrap)
320 if (_vtk_python_module_depend_exclude_wrap)
324 _vtk_module_get_module_property("${_vtk_python_module_depend}"
325 PROPERTY "python_package"
326 VARIABLE _vtk_python_depend_module_package)
327 _vtk_module_get_module_property("${_vtk_python_module_depend}"
328 PROPERTY "library_name"
329 VARIABLE _vtk_python_depend_library_name)
331 # XXX(kits): This doesn't work for kits.
332 list(APPEND _vtk_python_module_load_depends
333 "${_vtk_python_depend_module_package}.${_vtk_python_depend_library_name}")
336 if (_vtk_python_BUILD_STATIC)
337 # If static, we use .py modules that grab the contents from the baked-in modules.
338 set(_vtk_python_module_file
339 "${CMAKE_BINARY_DIR}/${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_path}/${_vtk_python_library_name}.py")
340 set(_vtk_python_module_contents
341 "from ${_vtk_python_import_prefix}${_vtk_python_library_name} import *\n")
344 OUTPUT "${_vtk_python_module_file}"
345 CONTENT "${_vtk_python_module_contents}")
347 # Set `python_modules` to provide the list of python files that go along with
349 _vtk_module_set_module_property("${_vtk_python_module}" APPEND
350 PROPERTY "python_modules"
351 VALUE "${_vtk_python_module_file}")
355 if (NOT _vtk_python_library_sources)
359 set(_vtk_python_init_data_file "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${name}Python/${name}-init.data")
362 OUTPUT "${_vtk_python_init_data_file}"
363 CONTENT "${_vtk_python_library_name}\n$<JOIN:${_vtk_python_classes},\n>\nDEPENDS\n$<JOIN:${_vtk_python_module_load_depends},\n>\n")
365 set(_vtk_python_init_output
366 "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${name}Python/${name}Init.cxx")
367 set(_vtk_python_init_impl_output
368 "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${name}Python/${name}InitImpl.cxx")
369 list(APPEND _vtk_python_library_sources
370 "${_vtk_python_init_output}"
371 "${_vtk_python_init_impl_output}")
373 set(_vtk_python_wrap_target "VTK::WrapPythonInit")
374 if (TARGET VTKCompileTools::WrapPythonInit)
375 set(_vtk_python_wrap_target "VTKCompileTools::WrapPythonInit")
378 if(_vtk_python_BUILD_STATIC)
379 set(additonal_options "${_vtk_python_import_prefix}")
382 OUTPUT "${_vtk_python_init_output}"
383 "${_vtk_python_init_impl_output}"
384 COMMAND "${_vtk_python_wrap_target}"
385 "${_vtk_python_init_data_file}"
386 "${_vtk_python_init_output}"
387 "${_vtk_python_init_impl_output}"
388 "${additonal_options}"
389 COMMENT "Generating the Python module initialization sources for ${name}"
391 "${_vtk_python_init_data_file}"
392 "$<TARGET_FILE:${_vtk_python_wrap_target}>")
394 if (_vtk_python_BUILD_STATIC)
395 set(_vtk_python_module_header_file
396 "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${name}/static_python/${name}.h")
397 set(_vtk_python_module_header_content
401#include <vtkPython.h>
406#if PY_VERSION_HEX < 0x03000000
407extern void init${_vtk_python_library_name}();
409extern PyObject* PyInit_${_vtk_python_library_name}();
419 OUTPUT "${_vtk_python_module_header_file}
"
420 CONTENT "${_vtk_python_module_header_content}
")
421 # XXX(cmake): Why is this necessary? One would expect that `file(GENERATE)`
422 # would do this automatically.
423 set_property(SOURCE "${_vtk_python_module_header_file}
"
427 add_library("${
name}
" STATIC
428 ${_vtk_python_library_sources}
429 "${_vtk_python_module_header_file}
")
430 target_include_directories("${
name}
"
432 "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${
name}/static_python>
")
433 target_link_libraries("${
name}
"
437 if (_vtk_python_UTILITY_TARGET)
438 target_link_libraries("${
name}
"
440 "${_vtk_python_UTILITY_TARGET}
")
443 set_property(TARGET "${
name}
"
445 LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${_vtk_python_STATIC_MODULE_DESTINATION}
")
447 add_library("${
name}
" MODULE
448 ${_vtk_python_library_sources})
449 if (WIN32 AND NOT CYGWIN)
450 # This is enabled explicitly by the USE_DEBUG_SUFFIX argument because
451 # there's no reliable way to detect whether we're using a debug build of
454 # The proper fix is to dig around and ask the backing `PythonN::Python`
455 # target used by `VTK::Python` for its properties to find out, per
456 # configuration, whether it is a debug build. If it is, add the postfix
457 # (regardless of VTK's build type). Otherwise, no postfix.
458 if (_vtk_python_USE_DEBUG_SUFFIX)
459 set_property(TARGET "${
name}
"
464 set_property(TARGET "${
name}
"
468 set_property(TARGET "${
name}
"
470 LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_path}
")
471 get_property(_vtk_python_is_multi_config GLOBAL
472 PROPERTY GENERATOR_IS_MULTI_CONFIG)
473 if (_vtk_python_is_multi_config)
474 # XXX(MultiNinja): This isn't going to work in general since MultiNinja
475 # will error about overlapping output paths.
476 foreach (_vtk_python_config IN LISTS CMAKE_CONFIGURATION_TYPES)
477 string(TOUPPER "${_vtk_python_config}
" _vtk_python_config_upper)
478 set_property(TARGET "${
name}
"
480 "LIBRARY_OUTPUT_DIRECTORY_${_vtk_python_config_upper}
" "${CMAKE_BINARY_DIR}/${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_path}
")
484 if (_vtk_python_UTILITY_TARGET)
485 target_link_libraries("${
name}
"
487 "${_vtk_python_UTILITY_TARGET}
")
490 set_target_properties("${
name}
"
493 OUTPUT_NAME "${_vtk_python_library_name}
"
494 ARCHIVE_OUTPUT_NAME "${
name}
")
501 # The wrapper code will expand PYTHON_PACKAGE as needed
502 target_compile_definitions("${
name}
"
504 "-DPYTHON_PACKAGE=\
"${_vtk_python_PYTHON_PACKAGE}\"")
506 target_link_libraries(
"${name}"
509 VTK::WrappingPythonCore
512 set(_vtk_python_export)
513 if (_vtk_python_INSTALL_EXPORT)
514 list(APPEND _vtk_python_export
515 EXPORT
"${_vtk_python_INSTALL_EXPORT}")
518 set(_vtk_python_wrap_component "${_vtk_python_COMPONENT}
")
519 if (_vtk_python_TARGET_SPECIFIC_COMPONENTS)
520 string(PREPEND _vtk_python_wrap_component "${
name}-
")
525 ${_vtk_python_export}
526 COMPONENT "${_vtk_python_wrap_component}
"
527 RUNTIME DESTINATION "${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_path}
"
528 LIBRARY DESTINATION "${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_path}
"
529 ARCHIVE DESTINATION "${_vtk_python_STATIC_MODULE_DESTINATION}
")
616function (vtk_module_wrap_python)
617 cmake_parse_arguments(PARSE_ARGV 0 _vtk_python
619 "MODULE_DESTINATION;STATIC_MODULE_DESTINATION;LIBRARY_DESTINATION;PYTHON_PACKAGE;BUILD_STATIC;INSTALL_HEADERS;INSTALL_EXPORT;TARGET_SPECIFIC_COMPONENTS;TARGET;COMPONENT;WRAPPED_MODULES;CMAKE_DESTINATION;SOABI;USE_DEBUG_SUFFIX;UTILITY_TARGET;BUILD_PYI_FILES
"
622 if (_vtk_python_UNPARSED_ARGUMENTS)
625 "${_vtk_python_UNPARSED_ARGUMENTS}
")
628 if (NOT _vtk_python_MODULES)
630 "No modules were requested
for Python wrapping.
")
634 _vtk_module_split_module_name("${_vtk_python_TARGET}
" _vtk_python)
636 set(_vtk_python_depends)
637 foreach (_vtk_python_depend IN LISTS _vtk_python_DEPENDS)
638 _vtk_module_split_module_name("${_vtk_python_depend}
" _vtk_python_depends)
639 list(APPEND _vtk_python_depends
640 "${_vtk_python_depends_TARGET_NAME}
")
643 if (NOT DEFINED _vtk_python_MODULE_DESTINATION)
644 vtk_module_python_default_destination(_vtk_python_MODULE_DESTINATION)
647 if (NOT DEFINED _vtk_python_INSTALL_HEADERS)
648 set(_vtk_python_INSTALL_HEADERS ON)
651 if (NOT DEFINED _vtk_python_BUILD_PYI_FILES)
652 set(_vtk_python_BUILD_PYI_FILES OFF)
655 if (NOT DEFINED _vtk_python_TARGET_SPECIFIC_COMPONENTS)
656 set(_vtk_python_TARGET_SPECIFIC_COMPONENTS OFF)
659 if (NOT DEFINED _vtk_python_USE_DEBUG_SUFFIX)
660 set(_vtk_python_USE_DEBUG_SUFFIX OFF)
663 if (_vtk_python_SOABI)
664 get_property(_vtk_python_is_multi_config GLOBAL
665 PROPERTY GENERATOR_IS_MULTI_CONFIG)
666 if (_vtk_python_is_multi_config)
667 foreach (_vtk_python_config IN LISTS CMAKE_CONFIGURATION_TYPES)
668 string(TOUPPER "${_vtk_python_config}
" _vtk_python_upper_config)
669 set("CMAKE_${_vtk_python_upper_config}_POSTFIX
"
670 ".${_vtk_python_SOABI}
")
673 string(TOUPPER "${CMAKE_BUILD_TYPE}
" _vtk_python_upper_config)
674 set("CMAKE_${_vtk_python_upper_config}_POSTFIX
"
675 ".${_vtk_python_SOABI}
")
679 if (_vtk_python_INSTALL_HEADERS AND NOT DEFINED _vtk_python_CMAKE_DESTINATION)
681 "No CMAKE_DESTINATION set, but headers from the Python wrapping were
"
682 "requested
for install and the CMake files are required to work with
"
686 if (NOT DEFINED _vtk_python_BUILD_STATIC)
687 if (BUILD_SHARED_LIBS)
688 set(_vtk_python_BUILD_STATIC OFF)
690 set(_vtk_python_BUILD_STATIC ON)
693 if (NOT _vtk_python_BUILD_STATIC AND NOT BUILD_SHARED_LIBS)
695 "Building shared Python modules against
static VTK modules only
"
696 "supports consuming the VTK modules via their Python interfaces due
"
697 "to the lack of support
for an SDK to use the same
static libraries.
")
701 if (NOT DEFINED _vtk_python_STATIC_MODULE_DESTINATION)
702 # TODO: Is this correct?
703 set(_vtk_python_STATIC_MODULE_DESTINATION "${CMAKE_INSTALL_LIBDIR}
")
706 if (NOT DEFINED _vtk_python_COMPONENT)
707 set(_vtk_python_COMPONENT "python
")
710 if (NOT _vtk_python_PYTHON_PACKAGE)
712 "No `PYTHON_PACKAGE` was given; Python modules must be placed into a
"
715 string(REPLACE ".
" "/
" _vtk_python_package_path "${_vtk_python_PYTHON_PACKAGE}
")
717 if(_vtk_python_BUILD_STATIC)
718 # When doing static builds we want the statically initialized built-ins to be
719 # used. It is unclear in the Python-C API how to construct `namespace.module`
720 # so instead at the C++ level we import "namespace_module
" during startup
721 # and than the python modules moving those imports into the correct python
723 string(REPLACE ".
" "_
" _vtk_python_import_prefix "${_vtk_python_PYTHON_PACKAGE}_
")
725 # We are building dynamic libraries therefore the prefix is simply '.'
726 set(_vtk_python_import_prefix ".
")
729 _vtk_module_check_destinations(_vtk_python_
731 STATIC_MODULE_DESTINATION
735 if (_vtk_python_INSTALL_HEADERS)
736 set(_vtk_python_properties_filename "${_vtk_python_PYTHON_PACKAGE}-
vtk-python-module-properties.cmake
")
737 set(_vtk_python_properties_install_file "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_python_TARGET_NAME}/${_vtk_python_properties_filename}.install
")
738 set(_vtk_python_properties_build_file "${CMAKE_BINARY_DIR}/${_vtk_python_CMAKE_DESTINATION}/${_vtk_python_properties_filename}
")
740 file(WRITE "${_vtk_python_properties_build_file}
")
741 file(WRITE "${_vtk_python_properties_install_file}
")
744 if (DEFINED _vtk_python_LIBRARY_DESTINATION)
746 set(CMAKE_BUILD_RPATH_USE_ORIGIN 1)
748 file(RELATIVE_PATH _vtk_python_relpath
749 "/prefix/${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_path}
"
750 "/prefix/${_vtk_python_LIBRARY_DESTINATION}
")
753 set(_vtk_python_origin_stem "@loader_path
")
755 set(_vtk_python_origin_stem "$ORIGIN
")
758 list(APPEND CMAKE_INSTALL_RPATH
759 "${_vtk_python_origin_stem}/${_vtk_python_relpath}
")
763 set(_vtk_python_sorted_modules ${_vtk_python_MODULES})
764 foreach (_vtk_python_module IN LISTS _vtk_python_MODULES)
765 _vtk_module_get_module_property("${_vtk_python_module}
"
767 VARIABLE "_vtk_python_${_vtk_python_module}_depends
")
769 vtk_topological_sort(_vtk_python_sorted_modules "_vtk_python_
" "_depends
")
771 set(_vtk_python_sorted_modules_filtered)
772 foreach (_vtk_python_module IN LISTS _vtk_python_sorted_modules)
773 if (_vtk_python_module IN_LIST _vtk_python_MODULES)
774 list(APPEND _vtk_python_sorted_modules_filtered
775 "${_vtk_python_module}
")
779 set(_vtk_python_headers_component "development
")
780 set(_vtk_python_component "${_vtk_python_COMPONENT}
")
781 if (_vtk_python_TARGET_SPECIFIC_COMPONENTS)
782 string(PREPEND _vtk_python_headers_component "${_vtk_python_TARGET_NAME}-
")
783 string(PREPEND _vtk_python_component "${_vtk_python_TARGET_NAME}-
")
786 # Disable CMake's automoc support for these targets.
791 set(_vtk_python_all_modules)
792 set(_vtk_python_all_wrapped_modules)
793 foreach (_vtk_python_module IN LISTS _vtk_python_sorted_modules_filtered)
794 _vtk_module_get_module_property("${_vtk_python_module}
"
795 PROPERTY "library_name
"
796 VARIABLE _vtk_python_library_name)
797 _vtk_module_wrap_python_library("${_vtk_python_library_name}Python
" "${_vtk_python_module}
")
799 if (TARGET "${_vtk_python_library_name}Python
")
800 list(APPEND _vtk_python_all_modules
801 "${_vtk_python_library_name}Python
")
802 list(APPEND _vtk_python_all_wrapped_modules
803 "${_vtk_python_module}
")
807 if (NOT _vtk_python_all_modules)
809 "No modules given could be wrapped.
")
812 if (_vtk_python_INSTALL_HEADERS)
814 FILES "${_vtk_python_properties_install_file}
"
815 DESTINATION "${_vtk_python_CMAKE_DESTINATION}
"
816 RENAME "${_vtk_python_properties_filename}
"
817 COMPONENT "${_vtk_python_headers_component}
")
820 if (DEFINED _vtk_python_WRAPPED_MODULES)
821 set("${_vtk_python_WRAPPED_MODULES}
"
822 "${_vtk_python_all_wrapped_modules}
"
826 if (_vtk_python_TARGET)
827 add_library("${_vtk_python_TARGET_NAME}
" INTERFACE)
828 target_include_directories("${_vtk_python_TARGET_NAME}
"
830 "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_python_TARGET_NAME}/static_python>
")
831 target_link_libraries("${_vtk_python_TARGET_NAME}
"
833 ${_vtk_python_DEPENDS})
834 if (NOT _vtk_python_TARGET STREQUAL _vtk_python_TARGET_NAME)
835 add_library("${_vtk_python_TARGET}
" ALIAS
836 "${_vtk_python_TARGET_NAME}
")
839 if (_vtk_python_INSTALL_EXPORT)
841 TARGETS "${_vtk_python_TARGET_NAME}
"
842 EXPORT "${_vtk_python_INSTALL_EXPORT}
"
843 COMPONENT "${_vtk_python_headers_component}
")
846 set(_vtk_python_all_modules_include_file
847 "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_python_TARGET_NAME}/static_python/${_vtk_python_TARGET_NAME}.h
")
848 set(_vtk_python_all_modules_include_content
849 "#ifndef ${_vtk_python_TARGET_NAME}_h\n#define ${_vtk_python_TARGET_NAME}_h\n
")
851 if (_vtk_python_BUILD_STATIC)
852 foreach (_vtk_python_module IN LISTS _vtk_python_all_modules)
853 string(APPEND _vtk_python_all_modules_include_content
854 "#include \
"${_vtk_python_module}.h\"\n")
858 foreach (_vtk_python_depend IN LISTS _vtk_python_depends)
859 string(APPEND _vtk_python_all_modules_include_content
860 "
#include \"${_vtk_python_depend}.h\"\n")
863 string(APPEND _vtk_python_all_modules_include_content
864"
#if PY_VERSION_HEX < 0x03000000
865#define PY_APPEND_INIT(module) PyImport_AppendInittab(\"${_vtk_python_import_prefix}\" #module, init ## module)
866#define PY_IMPORT(module) init ## module();
868#define PY_APPEND_INIT(module) PyImport_AppendInittab(\"${_vtk_python_import_prefix}\" #module, PyInit_ ## module)
869#define PY_IMPORT(module) { \\
870 PyObject* var_ ## module = PyInit_ ## module(); \\
871 PyDict_SetItemString(PyImport_GetModuleDict(), \"${_vtk_python_import_prefix}\" #module,var_ ## module); \\
872 Py_DECREF(var_ ## module); }
875#define PY_APPEND_INIT_OR_IMPORT(module, do_import) \\
876 if (do_import) { PY_IMPORT(module); } else { PY_APPEND_INIT(module); }
878static void ${_vtk_python_TARGET_NAME}_load() {\n")
880 foreach (_vtk_python_depend IN LISTS _vtk_python_depends)
881 string(APPEND _vtk_python_all_modules_include_content
882 " ${_vtk_python_depend}_load();\n")
885 if (_vtk_python_BUILD_STATIC)
886 string(APPEND _vtk_python_all_modules_include_content
887 "
int do_import = Py_IsInitialized();\n")
888 foreach (_vtk_python_module IN LISTS _vtk_python_sorted_modules_filtered)
890 PROPERTY "library_name
"
891 VARIABLE _vtk_python_library_name)
892 if (TARGET "${_vtk_python_library_name}Python
")
893 string(APPEND _vtk_python_all_modules_include_content
894 " PY_APPEND_INIT_OR_IMPORT(${_vtk_python_library_name}, do_import);\n
")
899 string(APPEND _vtk_python_all_modules_include_content
900 "}\n#undef PY_APPEND_INIT\n#undef PY_IMPORT\n#undef PY_APPEND_INIT_OR_IMPORT\n#endif\n
")
902 # TODO: Install this header.
904 OUTPUT "${_vtk_python_all_modules_include_file}
"
905 CONTENT "${_vtk_python_all_modules_include_content}
")
907 if (_vtk_python_BUILD_STATIC)
908 # TODO: Install these targets.
909 target_link_libraries("${_vtk_python_TARGET_NAME}
"
911 ${_vtk_python_all_modules})
914 if (_vtk_python_BUILD_STATIC)
915 # Next, we generate a Python module that can be imported to import any
916 # static artifacts e.g. all wrapping Python modules in static builds,
917 # (eventually, frozen modules etc.)
918 string(REPLACE ".
" "_
" _vtk_python_static_importer_name "_${_vtk_python_PYTHON_PACKAGE}_static
")
919 set(_vtk_python_static_importer_file
920 "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_vtk_python_TARGET_NAME}/static_python/${_vtk_python_static_importer_name}.c
")
921 set(_vtk_python_static_importer_content "
922#include <vtkPython.h>
923#include \"${_vtk_python_TARGET_NAME}.h\"
925 static PyMethodDef Py${_vtk_python_static_importer_name}_Methods[] = {
926 {NULL, NULL, 0, NULL}};
927#if PY_VERSION_HEX >= 0x03000000
928 static PyModuleDef ${_vtk_python_static_importer_name}Module = {
929 PyModuleDef_HEAD_INIT,
930 \"${_vtk_python_static_importer_name}\", // m_name
931 \"module to import static components for ${_vtk_python_TARGET_NAME}\", // m_doc
933 Py${_vtk_python_static_importer_name}_Methods, // m_methods
941#if PY_VERSION_HEX >= 0x03000000
942 PyMODINIT_FUNC PyInit_${_vtk_python_static_importer_name}(void)
944 PyMODINIT_FUNC init${_vtk_python_static_importer_name}(void)
947 // since this gets called after `Py_Initialize`, this will import the static
948 // modules and not just update the init table.
949 ${_vtk_python_TARGET_NAME}_load();
950#if PY_VERSION_HEX >= 0x03000000
951 return PyModule_Create(&${_vtk_python_static_importer_name}Module);
953 Py_InitModule(\"${_vtk_python_static_importer_name}\", Py${_vtk_python_static_importer_name}_Methods);
957 # TODO: Install this header.
959 OUTPUT
"${_vtk_python_static_importer_file}"
960 CONTENT
"${_vtk_python_static_importer_content}")
962 add_library(
"${_vtk_python_static_importer_name}" MODULE
963 ${_vtk_python_static_importer_file})
964 if (WIN32 AND NOT CYGWIN)
965 set_property(TARGET
"${_vtk_python_static_importer_name}"
969 set_property(TARGET "${_vtk_python_static_importer_name}
"
971 LIBRARY_OUTPUT_DIRECTORY "${_vtk_python_MODULE_DESTINATION}
")
972 get_property(_vtk_python_is_multi_config GLOBAL
973 PROPERTY GENERATOR_IS_MULTI_CONFIG)
974 if (_vtk_python_is_multi_config)
975 # XXX(MultiNinja): This isn't going to work in general since MultiNinja
976 # will error about overlapping output paths.
977 foreach (_vtk_python_config IN LISTS CMAKE_CONFIGURATION_TYPES)
978 string(TOUPPER "${_vtk_python_config}
" _vtk_python_config_upper)
979 set_property(TARGET "${_vtk_python_static_importer_name}
"
981 "LIBRARY_OUTPUT_DIRECTORY_${_vtk_python_config_upper}
" "${CMAKE_BINARY_DIR}/${_vtk_python_MODULE_DESTINATION}
")
984 set_property(TARGET "${_vtk_python_static_importer_name}
"
987 target_link_libraries("${_vtk_python_static_importer_name}
"
989 ${_vtk_python_TARGET_NAME}
990 VTK::WrappingPythonCore
994 TARGETS "${_vtk_python_static_importer_name}
"
995 COMPONENT "${_vtk_python_component}
"
996 RUNTIME DESTINATION "${_vtk_python_MODULE_DESTINATION}
"
997 LIBRARY DESTINATION "${_vtk_python_MODULE_DESTINATION}
"
998 ARCHIVE DESTINATION "${_vtk_python_STATIC_MODULE_DESTINATION}
")
999 endif () # if (_vtk_python_BUILD_STATIC)
1001 # convert package "x.y
" into "x/y
" to access its contents on the filesystem
1002 string(REPLACE ".
" "/
" _vtk_python_package_dir "${_vtk_python_PYTHON_PACKAGE}
")
1004 if (_vtk_python_BUILD_PYI_FILES)
1005 set(_vtk_python_pyi_files)
1006 set(_vtk_python_modules)
1007 set(_vtk_python_module_targets)
1008 foreach (_vtk_python_module IN LISTS _vtk_python_all_wrapped_modules)
1009 get_property(_vtk_python_library_name
1010 TARGET "${_vtk_python_module}
"
1011 PROPERTY "INTERFACE_vtk_module_library_name
")
1012 list(APPEND _vtk_python_pyi_files
1013 "${CMAKE_BINARY_DIR}/${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_dir}/${_vtk_python_library_name}.pyi
")
1014 list(APPEND _vtk_python_modules "${_vtk_python_library_name}
")
1015 if (TARGET "${_vtk_python_library_name}Python
")
1016 list(APPEND _vtk_python_module_targets "${_vtk_python_library_name}Python
")
1020 if (TARGET VTK::vtkpython)
1021 set(_vtk_python_exe $<TARGET_FILE:VTK::vtkpython>)
1023 set(_vtk_python_exe "${Python3_EXECUTABLE}
")
1026 # XXX(python2): Remove this conditional
1027 if (NOT VTK_PYTHON_VERSION STREQUAL "2
")
1029 OUTPUT ${_vtk_python_pyi_files}
1030 COMMAND "${_vtk_python_exe}
"
1031 -m vtkmodules.generate_pyi
1032 -p "${_vtk_python_PYTHON_PACKAGE}
"
1033 -o "${CMAKE_BINARY_DIR}/${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_dir}
"
1034 ${_vtk_python_modules}
1036 "${CMAKE_BINARY_DIR}/${_vtk_python_MODULE_DESTINATION}
"
1037 DEPENDS ${_vtk_python_module_targets}
1038 ${_vtk_python_static_importer_name}
1039 "${_vtk_pyi_script}
"
1040 COMMENT "Creating .pyi files
for ${_vtk_python_TARGET_NAME}
")
1043 FILES ${_vtk_python_pyi_files}
1044 DESTINATION "${_vtk_python_MODULE_DESTINATION}/${_vtk_python_package_dir}
"
1045 COMPONENT "${_vtk_python_component}
")
1047 add_custom_target("${_vtk_python_TARGET_NAME}_pyi
" ALL
1048 DEPENDS ${_vtk_python_pyi_files})
1094function (vtk_module_add_python_package name)
1095 if (NOT name STREQUAL _vtk_build_module)
1097 "Python modules must match their module names.
")
1100 cmake_parse_arguments(PARSE_ARGV 1 _vtk_add_python_package
1102 "PACKAGE;MODULE_DESTINATION;COMPONENT
"
1105 if (_vtk_add_python_package_UNPARSED_ARGUMENTS)
1108 "${_vtk_add_python_package_UNPARSED_ARGUMENTS}
")
1111 if (NOT _vtk_add_python_package_PACKAGE)
1113 "The `PACKAGE` argument is required.
")
1115 string(REPLACE ".
" "/
" _vtk_add_python_package_path "${_vtk_add_python_package_PACKAGE}
")
1117 if (NOT _vtk_add_python_package_FILES)
1119 "The `FILES` argument is required.
")
1122 if (NOT DEFINED _vtk_add_python_package_MODULE_DESTINATION)
1123 vtk_module_python_default_destination(_vtk_add_python_package_MODULE_DESTINATION)
1126 if (NOT DEFINED _vtk_add_python_package_COMPONENT)
1127 set(_vtk_add_python_package_COMPONENT "python
")
1130 set(_vtk_add_python_package_file_outputs)
1131 foreach (_vtk_add_python_package_file IN LISTS _vtk_add_python_package_FILES)
1132 if (IS_ABSOLUTE "${_vtk_add_python_package_file}
")
1133 file(RELATIVE_PATH _vtk_add_python_package_name
1134 "${CMAKE_CURRENT_BINARY_DIR}
"
1135 "${_vtk_add_python_package_file}
")
1137 set(_vtk_add_python_package_name
1138 "${_vtk_add_python_package_file}
")
1139 string(PREPEND _vtk_add_python_package_file
1140 "${CMAKE_CURRENT_SOURCE_DIR}/
")
1143 set(_vtk_add_python_package_file_output
1144 "${CMAKE_BINARY_DIR}/${_vtk_add_python_package_MODULE_DESTINATION}/${_vtk_add_python_package_name}
")
1146 OUTPUT "${_vtk_add_python_package_file_output}
"
1147 DEPENDS "${_vtk_add_python_package_file}
"
1148 COMMAND "${CMAKE_COMMAND}
" -E copy_if_different
1149 "${_vtk_add_python_package_file}
"
1150 "${_vtk_add_python_package_file_output}
"
1151 COMMENT "Copying ${_vtk_add_python_package_name} to the binary directory
")
1152 list(APPEND _vtk_add_python_package_file_outputs
1153 "${_vtk_add_python_package_file_output}
")
1154 if (BUILD_SHARED_LIBS)
1155 get_filename_component(_vtk_add_python_package_install_path "${_vtk_add_python_package_name}
" DIRECTORY)
1157 FILES "${_vtk_add_python_package_name}
"
1158 DESTINATION "${_vtk_add_python_package_MODULE_DESTINATION}/${_vtk_add_python_package_install_path}
"
1159 COMPONENT "${_vtk_add_python_package_COMPONENT}
")
1163 get_property(_vtk_add_python_package_module GLOBAL
1164 PROPERTY "_vtk_module_${_vtk_build_module}_target_name
")
1165 add_custom_target("${_vtk_add_python_package_module}-${_vtk_add_python_package_PACKAGE}
" ALL
1167 ${_vtk_add_python_package_file_outputs})
1169 # Set `python_modules` to provide the list of python files that go along with
1171 set_property(TARGET "${_vtk_add_python_package_module}-${_vtk_add_python_package_PACKAGE}
"
1173 "python_modules
" "${_vtk_add_python_package_file_outputs}
")