diff --git a/BlueBerry/CMake/MacroCreatePlugin.cmake b/BlueBerry/CMake/MacroCreatePlugin.cmake index ba23779fa5..39c2b81f61 100755 --- a/BlueBerry/CMake/MacroCreatePlugin.cmake +++ b/BlueBerry/CMake/MacroCreatePlugin.cmake @@ -1,202 +1,206 @@ # MACRO_CREATE_PLUGIN() # # Creates the current plugin. # This macro should be called from the plugins CMakeLists.txt file. The plugin # library is build in a subdirectory of PLUGIN_OUTPUT_DIR, which is derived from # the variable PLUGIN_OUTPUT_BASE_DIR coming from COLLECT_PLUGINS(). # The target name is available as PLUGIN_TARGET # to add additional libraries in your CMakeLists.txt. Include paths and link # libraries are set depending on the value of the Required-Bundles header # in your plugins MANIFEST.MF file. # # Available variables: # # - PLUGIN_OUTPUT_DIR the binary output directory of your plugin # - PLUGIN_TARGET the target name of your plugins dll # # MACRO(MACRO_CREATE_PLUGIN) IF(MSVC80) ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS) ENDIF(MSVC80) MESSAGE(STATUS "Creating plugin ${BUNDLE-SYMBOLICNAME}") PROJECT(${BUNDLE-SYMBOLICNAME}) STRING(REPLACE . _ PLUGIN_TARGET ${BUNDLE-SYMBOLICNAME}) SET(PLUGIN_OUTPUT_DIR ${${BUNDLE-SYMBOLICNAME}_OUT_DIR}) FILE(MAKE_DIRECTORY ${PLUGIN_OUTPUT_DIR}) INCLUDE(files.cmake) SET(PLUGIN_CPP_FILES ${CPP_FILES}) SET(PLUGIN_MOC_H_FILES ${MOC_H_FILES}) SET(PLUGIN_UI_FILES ${UI_FILES}) SET(PLUGIN_RESOURCE_FILES ${RESOURCE_FILES}) SET(PLUGIN_RES_FILES ${RES_FILES}) SET(PLUGIN_H_FILES ${H_FILES}) SET(PLUGIN_TXX_FILES ${TXX_FILES}) SET(PLUGIN_DOX_FILES ${DOX_FILES}) SET(PLUGIN_CMAKE_FILES ${CMAKE_FILES} files.cmake) SET(PLUGIN_FILE_DEPENDENCIES ${FILE_DEPENDENCIES}) # Copy the META-INF directory into the binary output dir SET (PLUGIN_META_FILES ${PLUGIN_META_FILES} ${CMAKE_CURRENT_SOURCE_DIR}/META-INF/MANIFEST.MF) CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/META-INF/MANIFEST.MF ${PLUGIN_OUTPUT_DIR}/META-INF/MANIFEST.MF COPYONLY) # Copy the plugin.xml into the binary output dir SET(PLUGINXML ${CMAKE_CURRENT_SOURCE_DIR}/plugin.xml) IF(EXISTS ${PLUGINXML}) SET (PLUGIN_META_FILES ${PLUGIN_META_FILES} ${CMAKE_CURRENT_SOURCE_DIR}/plugin.xml) CONFIGURE_FILE(${PLUGINXML} ${PLUGIN_OUTPUT_DIR}/plugin.xml COPYONLY) ENDIF(EXISTS ${PLUGINXML}) # Copy the resource files into the binary output dir FOREACH(_resource ${PLUGIN_RESOURCE_FILES}) CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/${_resource}" "${PLUGIN_OUTPUT_DIR}/${_resource}" COPYONLY) ENDFOREACH(_resource ${PLUGIN_RESOURCE_FILES}) SET(PLUGIN_GENERATED_UI_FILES ) IF(PLUGIN_UI_FILES) QT4_WRAP_UI(PLUGIN_GENERATED_UI_FILES ${PLUGIN_UI_FILES}) ENDIF(PLUGIN_UI_FILES) SET(PLUGIN_GENERATED_MOC_FILES ) IF(PLUGIN_MOC_H_FILES) # this is a workaround for Visual Studio. The relative include paths in the generated # moc files can get very long and can't be resolved by the MSVC compiler. See bug #1961 # for details. FOREACH(moc_h_file ${PLUGIN_MOC_H_FILES}) QT4_WRAP_CPP(PLUGIN_GENERATED_MOC_FILES ${moc_h_file} OPTIONS -f${moc_h_file}) ENDFOREACH(moc_h_file) ENDIF(PLUGIN_MOC_H_FILES) SET(PLUGIN_GENERATED_QRC_FILES ) IF(PLUGIN_RES_FILES) QT4_ADD_RESOURCES(PLUGIN_GENERATED_QRC_FILES ${PLUGIN_RES_FILES}) ENDIF(PLUGIN_RES_FILES) #------------------------------------------------------------# #------------------ Qt Help support -------------------------# SET(PLUGIN_GENERATED_QCH_FILES ) IF (BLUEBERRY_USE_QT_HELP AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/documentation/UserManual") SET(PLUGIN_DOXYGEN_INPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/documentation/UserManual") SET(PLUGIN_DOXYGEN_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/documentation/UserManual") _MACRO_CREATE_QT_COMPRESSED_HELP(PLUGIN_GENERATED_QCH_FILES ) ENDIF() INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_BINARY_DIR}) _MACRO_SETUP_PLUGIN_DEPENDENCIES(_linklibs) MACRO_ORGANIZE_SOURCES(SOURCE ${PLUGIN_CPP_FILES} HEADER ${PLUGIN_H_FILES} TXX ${PLUGIN_TXX_FILES} DOC ${PLUGIN_DOX_FILES} UI ${PLUGIN_UI_FILES} QRC ${PLUGIN_RES_FILES} META ${PLUGIN_META_FILES} MOC ${PLUGIN_GENERATED_MOC_FILES} GEN_UI ${PLUGIN_GENERATED_UI_FILES} GEN_QRC ${PLUGIN_GENERATED_QRC_FILES}) SET(_all_target_files ${PLUGIN_CPP_FILES} ${PLUGIN_H_FILES} ${PLUGIN_TXX_FILES} ${PLUGIN_DOX_FILES} ${PLUGIN_UI_FILES} ${PLUGIN_RES_FILES} ${PLUGIN_META_FILES} ${PLUGIN_GENERATED_MOC_FILES} ${PLUGIN_GENERATED_UI_FILES} ${PLUGIN_GENERATED_QRC_FILES} ${PLUGIN_GENERATED_QCH_FILES} ${PLUGIN_CMAKE_FILES} ${CORRESPONDING__H_FILES} ${GLOBBED__H_FILES} ${PLUGIN_FILE_DEPENDENCIES} ) ADD_LIBRARY(${PLUGIN_TARGET} ${_all_target_files}) SET(PLUGIN_TARGETS ${PLUGIN_TARGETS} ${PLUGIN_TARGET} CACHE INTERNAL "Temporary list of plug-in targets") SET_TARGET_PROPERTIES(${PLUGIN_TARGET} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${PLUGIN_OUTPUT_DIR}/bin" LIBRARY_OUTPUT_DIRECTORY "${PLUGIN_OUTPUT_DIR}/bin" ARCHIVE_OUTPUT_DIRECTORY "${PLUGIN_OUTPUT_DIR}/bin" DEBUG_POSTFIX ${BLUEBERRY_DEBUG_POSTFIX}) IF(mbilog_FOUND) TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} mbilog) ENDIF() # we need to explicitly state the debug versions of the libraries # we are linking to in the TARGET_LINK_LIBRARIES command. # Although we set the debug postfix to d, CMake automatically # appends it in a TARGET_LINK_LIBRARIES(target lib1) command only # if lib1 has been build within the same project. # External projects using this macro would therefore always link # to lib1, instead of lib1d in debug configurations SET(_debug_linklibs "") FOREACH(_linklib ${PLUGIN_LINK_LIBRARIES}) SET(_debug_linklibs ${_debug_linklibs} optimized "${_linklib}" debug "${_linklib}${BLUEBERRY_DEBUG_POSTFIX}") ENDFOREACH(_linklib) TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} ${_debug_linklibs}) TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} optimized "PocoFoundation" debug "PocoFoundation${BLUEBERRY_DEBUG_POSTFIX}" optimized "PocoUtil" debug "PocoUtil${BLUEBERRY_DEBUG_POSTFIX}" optimized "PocoXML" debug "PocoXML${BLUEBERRY_DEBUG_POSTFIX}") # Fix a "bug" in CMake, which does not include all transitive link libraries for a given target LIST(FIND PLUGIN_LINK_LIBRARIES org_blueberry_test _is_unittest_plugin) IF(NOT _is_unittest_plugin EQUAL -1) TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} optimized CppUnit debug CppUnitd) ENDIF() + IF(MINGW) + TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} ssp) # add stack smash protection lib + ENDIF() + #SET_TARGET_PROPERTIES(${PLUGIN_TARGET} PROPERTIES PREFIX lib IMPORT_PREFIX lib) SET_TARGET_PROPERTIES(${PLUGIN_TARGET} PROPERTIES PREFIX lib) #------------------------------------------------------------# #------------------ Installer support -----------------------# SET(install_directories "") IF(NOT MACOSX_BUNDLE_NAMES) SET(install_directories bin) ELSE(NOT MACOSX_BUNDLE_NAMES) FOREACH(bundle_name ${MACOSX_BUNDLE_NAMES}) LIST(APPEND install_directories ${bundle_name}.app/Contents/MacOS) ENDFOREACH(bundle_name) ENDIF(NOT MACOSX_BUNDLE_NAMES) FOREACH(install_subdir ${install_directories}) FILE(RELATIVE_PATH _toplevel_dir "${PLUGINS_SOURCE_BASE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}") STRING(REGEX REPLACE ".*/(.+)/?$" "\\1" _toplevel_output_dir ${PLUGINS_OUTPUT_BASE_DIR}) MACRO_INSTALL_PLUGIN("${PLUGINS_OUTPUT_BASE_DIR}/${_toplevel_dir}" TARGETS ${PLUGIN_TARGET} DESTINATION "${install_subdir}/${_toplevel_output_dir}") ENDFOREACH() ENDMACRO(MACRO_CREATE_PLUGIN) # Macro to set specific Qt options, calls CREATE_PLUGIN at the end MACRO(MACRO_CREATE_QT_PLUGIN) IF(QT4_FOUND) INCLUDE(${QT_USE_FILE}) MACRO_CREATE_PLUGIN() TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} ${QT_LIBRARIES}) ENDIF(QT4_FOUND) ENDMACRO(MACRO_CREATE_QT_PLUGIN) diff --git a/CMake/mitkMacroCreateModule.cmake b/CMake/mitkMacroCreateModule.cmake index cb67f60561..d88fa16266 100644 --- a/CMake/mitkMacroCreateModule.cmake +++ b/CMake/mitkMacroCreateModule.cmake @@ -1,190 +1,197 @@ ################################################################## # # MITK_CREATE_MODULE # #! Creates a module for the automatic module dependency system within MITK. #! Configurations are generated in the moduleConf directory. #! #! USAGE: #! #! \code #! MITK_CREATE_MODULE( #! [INCLUDE_DIRS ] #! [INTERNAL_INCLUDE_DIRS ] #! [DEPENDS ] #! [PROVIDES ] #! [PACKAGE_DEPENDS ] #! [EXPORT_DEFINE ] #! [QT_MODULE] #! \endcode #! #! \param MODULE_NAME_IN The name for the new module # ################################################################## MACRO(MITK_CREATE_MODULE MODULE_NAME_IN) MACRO_PARSE_ARGUMENTS(MODULE "SUBPROJECTS;INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PROVIDES;PACKAGE_DEPENDS;EXPORT_DEFINE;ADDITIONAL_LIBS;GENERATED_CPP" "QT_MODULE;FORCE_STATIC;HEADERS_ONLY" ${ARGN}) SET(MODULE_NAME ${MODULE_NAME_IN}) IF(NOT MODULE_SUBPROJECTS) IF(MITK_DEFAULT_SUBPROJECTS) SET(MODULE_SUBPROJECTS ${MITK_DEFAULT_SUBPROJECTS}) ENDIF() ENDIF() # check if the subprojects exist as targets IF(MODULE_SUBPROJECTS) FOREACH(subproject ${MODULE_SUBPROJECTS}) IF(NOT TARGET ${subproject}) MESSAGE(SEND_ERROR "The subproject ${subproject} does not have a corresponding target") ENDIF() ENDFOREACH() ENDIF() # assume worst case SET(MODULE_IS_ENABLED 0) # first of all we check for the dependencies MITK_CHECK_MODULE(_MISSING_DEP ${MODULE_DEPENDS}) IF(_MISSING_DEP) MESSAGE("Module ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}") SET(MODULE_IS_ENABLED 0) ELSE(_MISSING_DEP) SET(MODULE_IS_ENABLED 1) # now check for every package if it is enabled. This overlaps a bit with # MITK_CHECK_MODULE ... FOREACH(_package ${MODULE_PACKAGE_DEPENDS}) IF((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package})) MESSAGE("Module ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.") SET(MODULE_IS_ENABLED 0) ENDIF() ENDFOREACH() IF(MODULE_IS_ENABLED) IF(NOT MODULE_QT_MODULE OR MITK_USE_QT) SET(MODULE_IS_ENABLED 1) _MITK_CREATE_MODULE_CONF() IF(NOT MODULE_EXPORT_DEFINE) SET(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT) ENDIF(NOT MODULE_EXPORT_DEFINE) CONFIGURE_FILE(${MITK_SOURCE_DIR}/CMake/moduleExports.h.in ${MITK_MODULES_CONF_DIR}/${MODULE_NAME}Exports.h @ONLY) IF(MITK_GENERATE_MODULE_DOT) MESSAGE("MODULEDOTNAME ${MODULE_NAME}") FOREACH(dep ${MODULE_DEPENDS}) MESSAGE("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ") ENDFOREACH(dep) ENDIF(MITK_GENERATE_MODULE_DOT) SET(DEPENDS "${MODULE_DEPENDS}") SET(DEPENDS_BEFORE "not initialized") SET(PACKAGE_DEPENDS "${MODULE_PACKAGE_DEPENDS}") MITK_USE_MODULE("${MODULE_DEPENDS}") # ok, now create the module itself INCLUDE_DIRECTORIES(. ${ALL_INCLUDE_DIRECTORIES}) INCLUDE(files.cmake) IF(NOT MODULE_QT_MODULE) ORGANIZE_SOURCES(SOURCE ${CPP_FILES} HEADER ${H_FILES} TXX ${TXX_FILES} DOC ${DOX_FILES} ) IF(MODULE_FORCE_STATIC) SET(_STATIC ${MITK_WIN32_FORCE_STATIC}) ENDIF(MODULE_FORCE_STATIC) SET(coverage_sources ${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES} ${TOOL_CPPS}) IF(MODULE_SUBPROJECTS) SET_PROPERTY(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK) ENDIF() IF(NOT MODULE_HEADERS_ONLY) IF(ALL_LIBRARY_DIRS) # LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) ENDIF(ALL_LIBRARY_DIRS) ADD_LIBRARY(${MODULE_PROVIDES} ${_STATIC} ${coverage_sources} ${CPP_FILES_GENERATED} ${DOX_FILES} ${UI_FILES}) IF(MODULE_SUBPROJECTS) SET_PROPERTY(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK) FOREACH(subproject ${MODULE_SUBPROJECTS}) ADD_DEPENDENCIES(${subproject} ${MODULE_PROVIDES}) ENDFOREACH() ENDIF() IF(ALL_LIBRARIES) TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${ALL_LIBRARIES}) ENDIF(ALL_LIBRARIES) + + IF(MINGW) + TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ssp) # add stack smash protection lib + ENDIF() ENDIF() ELSE(NOT MODULE_QT_MODULE) INCLUDE(files.cmake) IF(UI_FILES) QT4_WRAP_UI(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES}) ENDIF(UI_FILES) IF(MOC_H_FILES) QT4_WRAP_CPP(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES}) ENDIF(MOC_H_FILES) IF(QRC_FILES) QT4_ADD_RESOURCES(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES}) ENDIF(QRC_FILES) SET(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP}) ORGANIZE_SOURCES(SOURCE ${CPP_FILES} HEADER ${H_FILES} TXX ${TXX_FILES} DOC ${DOX_FILES} UI ${UI_FILES} QRC ${QRC_FILES} MOC ${Q${KITNAME}_GENERATED_MOC_CPP} GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP} GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP}) # MITK_GENERATE_TOOLS_LIBRARY(Qmitk${LIBPOSTFIX} "NO") SET(coverage_sources ${CPP_FILES} ${CORRESPONDING__H_FILES} ${GLOBBED__H_FILES} ${TXX_FILES} ${TOOL_GUI_CPPS}) SET_PROPERTY(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS}) IF(NOT MODULE_HEADERS_ONLY) IF(ALL_LIBRARY_DIRS) # LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) ENDIF(ALL_LIBRARY_DIRS) ADD_LIBRARY(${MODULE_PROVIDES} ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP} ${DOX_FILES} ${UI_FILES} ${QRC_FILES}) TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${QT_LIBRARIES} ${ALL_LIBRARIES} QVTK) + IF(MINGW) + TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ssp) # add stack smash protection lib + ENDIF() IF(MODULE_SUBPROJECTS) SET_PROPERTY(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK) FOREACH(subproject ${MODULE_SUBPROJECTS}) ADD_DEPENDENCIES(${subproject} ${MODULE_PROVIDES}) ENDFOREACH() ENDIF() ENDIF() ENDIF(NOT MODULE_QT_MODULE) #IF(NOT MODULE_HEADERS_ONLY AND TARGET EP_MITK) # ADD_DEPENDENCIES(${MODULE_PROVIDES} EP_MITK) #ENDIF() # install only if shared lib (for now) IF(NOT _STATIC OR MINGW) IF(NOT MODULE_HEADERS_ONLY) # # deprecated: MITK_INSTALL_TARGETS(${MODULE_PROVIDES}) ENDIF() ENDIF(NOT _STATIC OR MINGW) ENDIF(NOT MODULE_QT_MODULE OR MITK_USE_QT) ENDIF(MODULE_IS_ENABLED) ENDIF(_MISSING_DEP) IF(NOT MODULE_IS_ENABLED) _MITK_CREATE_MODULE_CONF() ENDIF(NOT MODULE_IS_ENABLED) ENDMACRO(MITK_CREATE_MODULE) diff --git a/CMakeExternals/ITK.cmake b/CMakeExternals/ITK.cmake index 94cb65e476..aad3234068 100644 --- a/CMakeExternals/ITK.cmake +++ b/CMakeExternals/ITK.cmake @@ -1,35 +1,44 @@ #----------------------------------------------------------------------------- # ITK #----------------------------------------------------------------------------- # Sanity checks IF(DEFINED ITK_DIR AND NOT EXISTS ${ITK_DIR}) MESSAGE(FATAL_ERROR "ITK_DIR variable is defined but corresponds to non-existing directory") ENDIF() SET(proj ITK) SET(proj_DEPENDENCIES GDCM) SET(ITK_DEPENDS ${proj}) IF(NOT DEFINED ITK_DIR) + + SET(additional_cmake_args ) + IF(MINGW) + SET(additional_cmake_args + -DCMAKE_USE_WIN32_THREADS:BOOL=ON + -DCMAKE_USE_PTHREADS:BOOL=OFF) + ENDIF() + ExternalProject_Add(${proj} URL http://mitk.org/download/thirdparty/InsightToolkit-3.20.0.tar.gz BINARY_DIR ${proj}-build INSTALL_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} + ${additional_cmake_args} -DBUILD_TESTING:BOOL=OFF -DBUILD_EXAMPLES:BOOL=OFF -DITK_USE_SYSTEM_GDCM:BOOL=ON -DGDCM_DIR:PATH=${GDCM_DIR} DEPENDS ${proj_DEPENDENCIES} ) SET(ITK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build) ELSE() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") ENDIF() diff --git a/CMakeExternals/VTK.cmake b/CMakeExternals/VTK.cmake index c451c5083b..1ab2f3cf2b 100644 --- a/CMakeExternals/VTK.cmake +++ b/CMakeExternals/VTK.cmake @@ -1,45 +1,56 @@ #----------------------------------------------------------------------------- # VTK #----------------------------------------------------------------------------- IF(WIN32) OPTION(VTK_USE_SYSTEM_FREETYPE OFF) ELSE(WIN32) OPTION(VTK_USE_SYSTEM_FREETYPE ON) ENDIF(WIN32) # Sanity checks IF(DEFINED VTK_DIR AND NOT EXISTS ${VTK_DIR}) MESSAGE(FATAL_ERROR "VTK_DIR variable is defined but corresponds to non-existing directory") ENDIF() SET(proj VTK) SET(proj_DEPENDENCIES ) SET(VTK_DEPENDS ${proj}) IF(NOT DEFINED VTK_DIR) + + SET(additional_cmake_args ) + IF(MINGW) + SET(additional_cmake_args + -DCMAKE_USE_WIN32_THREADS:BOOL=ON + -DCMAKE_USE_PTHREADS:BOOL=OFF + -DVTK_USE_VIDEO4WINDOWS:BOOL=OFF # no header files provided by MinGW + ) + ENDIF() + ExternalProject_Add(${proj} URL http://mitk.org/download/thirdparty/vtk-5.6.1.tar.gz BINARY_DIR ${proj}-build INSTALL_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} + ${additional_cmake_args} -DVTK_WRAP_TCL:BOOL=OFF -DVTK_WRAP_PYTHON:BOOL=OFF -DVTK_WRAP_JAVA:BOOL=OFF -DBUILD_SHARED_LIBS:BOOL=ON -DVTK_USE_PARALLEL:BOOL=ON -DVTK_USE_CHARTS:BOOL=OFF -DVTK_USE_GEOVIS:BOOL=OFF -DVTK_USE_SYSTEM_FREETYPE:BOOL=${VTK_USE_SYSTEM_FREETYPE} ${vtk_QT_ARGS} DEPENDS ${proj_DEPENDENCIES} ) SET(VTK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build) ELSE() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") ENDIF()