diff --git a/Applications/CoreApp/CMakeLists.txt b/Applications/CoreApp/CMakeLists.txt index 2202d16166..8044c1c25d 100644 --- a/Applications/CoreApp/CMakeLists.txt +++ b/Applications/CoreApp/CMakeLists.txt @@ -1,60 +1,66 @@ FIND_PACKAGE(BlueBerry REQUIRED) INCLUDE_DIRECTORIES( ${BLUEBERRY_PLUGIN_SOURCE_DIRS} ${org.blueberry.osgi_BIN_DIR} # needed for generated berryConfig.h ${Poco_INCLUDE_DIRS} ) LINK_DIRECTORIES(${Poco_LIBRARY_DIRS} ${BLUEBERRY_PLUGINS_OUTPUT_DIR}/org.blueberry.osgi/bin ) IF(MITK_SHOW_CONSOLE_WINDOW) ADD_EXECUTABLE(CoreApp MACOSX_BUNDLE CoreApp.cpp) ELSE(MITK_SHOW_CONSOLE_WINDOW) ADD_EXECUTABLE(CoreApp MACOSX_BUNDLE WIN32 CoreApp.cpp) ENDIF(MITK_SHOW_CONSOLE_WINDOW) IF (WIN32) FIND_PACKAGE(Qt4) TARGET_LINK_LIBRARIES(CoreApp ${QT_QTCORE_LIBRARY} ${QT_QTMAIN_LIBRARY}) ENDIF(WIN32) TARGET_LINK_LIBRARIES(CoreApp optimized PocoFoundation debug PocoFoundationd optimized PocoUtil debug PocoUtild optimized org_blueberry_osgi debug org_blueberry_osgi${BLUEBERRY_DEBUG_POSTFIX}) SET_TARGET_PROPERTIES(CoreApp PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_RPATH};${CMAKE_INSTALL_RPATH}/BlueBerry/org.blueberry.osgi/bin") +# subproject support +ADD_DEPENDENCIES(MITK-CoreUI CoreApp) +IF(MITK_ENABLE_GUI_TESTING) + ADD_DEPENDENCIES(MITK-CoreUI solstice) +ENDIF() + SET(_plugin_deps ${BLUEBERRY_ENABLED_PLUGINS} ${MITK_CORE_ENABLED_PLUGINS} ${MITK_CORE_ENABLED_TEST_PLUGINS} ) IF(_plugin_deps) # Make sure all enabled plug-ins are up to date ADD_DEPENDENCIES(CoreApp ${_plugin_deps}) ENDIF() SET(BLUEBERRY_PLUGIN_CACHE_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugin_cache") CONFIGURE_FILE(CoreApp.ini ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.ini) IF(WIN32) FOREACH(COREAPP_BUILD_TYPE debug release) mitkFunctionCreateWindowsBatchScript(startCoreApp.bat.in ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/startCoreApp_${COREAPP_BUILD_TYPE}.bat ${COREAPP_BUILD_TYPE}) ENDFOREACH() ENDIF(WIN32) MITK_INSTALL_TARGETS(EXECUTABLES CoreApp GLOB_PLUGINS ) IF(UNIX AND MITK_INSTALL_RPATH_RELATIVE AND NOT APPLE) INSTALL(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME CoreApp.sh) ENDIF() SET(MITK_CPACK_PACKAGE_EXECUTABLES ${MITK_CPACK_PACKAGE_EXECUTABLES} "CoreApp;MITK - CoreApp Application" CACHE INTERNAL "Collecting windows shortcuts to executables") diff --git a/BlueBerry/Bundles/CMakeLists.txt b/BlueBerry/Bundles/CMakeLists.txt index 8990e1e3c0..7e6e6fc6bf 100755 --- a/BlueBerry/Bundles/CMakeLists.txt +++ b/BlueBerry/Bundles/CMakeLists.txt @@ -1,18 +1,23 @@ SET(_default_plugins org.blueberry.osgi org.blueberry.solstice.common org.blueberry.core.runtime org.blueberry.core.expressions org.blueberry.core.commands org.blueberry.ui org.blueberry.ui.qt ) MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${BLUEBERRY_PLUGINS_OUTPUT_DIR} CACHE_PLUGIN_TARGETS BLUEBERRY_ENABLED_PLUGINS BUNDLE_LIST_PATH "${BLUEBERRY_BINARY_DIR}/BlueBerryBundleList.cmake" CMAKE_CACHE_PREFIX "BLUEBERRY" PLUGIN_DEFAULT_ON ${_default_plugins} ${BLUEBERRY_BUILD_ALL_PLUGINS_OPTION}) - \ No newline at end of file + +add_dependencies(BlueBerry ${BLUEBERRY_ENABLED_PLUGINS}) +foreach(plugin ${BLUEBERRY_ENABLED_PLUGINS}) + string(REPLACE "." "_" plugin_target ${plugin}) + set_property(TARGET ${plugin_target} PROPERTY LABELS BlueBerry) +endforeach() diff --git a/BlueBerry/Bundles/org.blueberry.osgi/CMakeLists.txt b/BlueBerry/Bundles/org.blueberry.osgi/CMakeLists.txt index 528543ed1f..b6422387d8 100644 --- a/BlueBerry/Bundles/org.blueberry.osgi/CMakeLists.txt +++ b/BlueBerry/Bundles/org.blueberry.osgi/CMakeLists.txt @@ -1,25 +1,27 @@ CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/src/berryConfig.h.in" "${CMAKE_CURRENT_BINARY_DIR}/berryConfig.h" @ONLY) MACRO_CREATE_PLUGIN() TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} optimized PocoUtil debug PocoUtild optimized PocoXML debug PocoXMLd) ADD_EXECUTABLE(${OSGI_APP} MACOSX_BUNDLE "src/application/berryMain.cpp") # ADD_EXECUTABLE(${OSGI_APP} "src/application/berryMain.cpp") TARGET_LINK_LIBRARIES(${OSGI_APP} ${PLUGIN_TARGET} mbilog) IF (BLUEBERRY_ENABLED_TEST_PLUGINS) ADD_DEPENDENCIES(${OSGI_APP} ${BLUEBERRY_ENABLED_TEST_PLUGINS}) + ADD_DEPENDENCIES(BlueBerry ${OSGI_APP}) + SET_PROPERTY(TARGET ${OSGI_APP} APPEND PROPERTY LABELS BlueBerry) ENDIF() SET(BLUEBERRY_PLUGIN_CACHE_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugin_cache") CONFIGURE_FILE(src/application/solstice.ini ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}.ini) SET_TARGET_PROPERTIES(${OSGI_APP} PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_RPATH};${CMAKE_INSTALL_PREFIX}/bin/BlueBerry/org.blueberry.osgi/bin") # MITK_INSTALL_TARGETS(EXECUTABLES ${OSGI_APP} GLOB_PLUGINS ) # MITK_INSTALL_TARGETS(EXECUTABLES ${OSGI_APP} LIBRARY_DIRS ${CMAKE_INSTALL_PREFIX}/bin) # MITK_INSTALL_TARGETS(EXECUTABLES ${OSGI_APP} LIBRARY_DIRS ${CMAKE_INSTALL_PREFIX}/bin PLUGINS ${CMAKE_INSTALL_PREFIX}/bin/BlueBerry/org.blueberry.osgi/bin/liborg_blueberry_osgid.dylib) diff --git a/BlueBerry/CMake/berryTestingHelpers.cmake b/BlueBerry/CMake/berryTestingHelpers.cmake index ec78382350..09c5adf96a 100755 --- a/BlueBerry/CMake/berryTestingHelpers.cmake +++ b/BlueBerry/CMake/berryTestingHelpers.cmake @@ -1,49 +1,61 @@ # Call this macro after calling MACRO_CREATE_PLUGIN in your CMakeLists.txt # # Variables: # # - BLUEBERRY_TEST_APP contains the name of the executable which will start the OSGi framework # MACRO(MACRO_TEST_PLUGIN) SET(_cla_switch "--") IF(WIN32) IF(MSYS) SET(_cla_switch "//") ELSE() SET(_cla_switch "/") ENDIF() ENDIF() ADD_TEST(${BUNDLE-SYMBOLICNAME} ${BLUEBERRY_TEST_APP} ${_cla_switch}BlueBerry.application=coretestapplication ${_cla_switch}BlueBerry.testplugin=${BUNDLE-SYMBOLICNAME}) + SET(_labels ${ARGN}) + IF(NOT _labels) + SET(_labels BlueBerry) + ENDIF() + SET_PROPERTY(TEST ${BUNDLE-SYMBOLICNAME} PROPERTY LABELS ${_labels}) + ENDMACRO(MACRO_TEST_PLUGIN) # Variables: # # - BLUEBERRY_TEST_APP contains the name of the executable which will start the OSGi framework # - BLUEBERRY_TEST_APP_ID contains the application id of the application to test. If empty, # a minimalistic default application will be started MACRO(MACRO_TEST_UIPLUGIN) SET(_cla_switch "--") IF(WIN32) IF(MSYS) SET(_cla_switch "//") ELSE() SET(_cla_switch "/") ENDIF() ENDIF() IF(BLUEBERRY_ENABLE_GUI_TESTING) IF(BLUEBERRY_TEST_APP_ID) SET(_app_id_arg "${_cla_switch}BlueBerry.testapplication=${BLUEBERRY_TEST_APP_ID}") ELSE() SET(_app_id_arg ) ENDIF() ADD_TEST(${BUNDLE-SYMBOLICNAME} ${BLUEBERRY_TEST_APP} ${_cla_switch}BlueBerry.application=uitestapplication ${_app_id_arg} ${_cla_switch}BlueBerry.testplugin=${BUNDLE-SYMBOLICNAME}) + + SET(_labels ${ARGN}) + IF(NOT _labels) + SET(_labels BlueBerry) + ENDIF() + SET_PROPERTY(TEST ${BUNDLE-SYMBOLICNAME} PROPERTY LABELS ${_labels}) ENDIF() ENDMACRO(MACRO_TEST_UIPLUGIN) diff --git a/BlueBerry/CMakeLists.txt b/BlueBerry/CMakeLists.txt index 86818d2bc2..26ceb416b6 100644 --- a/BlueBerry/CMakeLists.txt +++ b/BlueBerry/CMakeLists.txt @@ -1,187 +1,189 @@ PROJECT(BlueBerry) CMAKE_MINIMUM_REQUIRED(VERSION 2.6) SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMake/") INCLUDE(MacroParseArguments) INCLUDE(MacroConvertSchema) INCLUDE(MacroOrganizeSources) INCLUDE(berryPluginHelpers) INCLUDE(MacroCollectPlugins) INCLUDE(MacroParseManifest) INCLUDE(MacroCreatePlugin) INCLUDE(MacroCreateQtHelp) INCLUDE(MacroInstallPlugin) OPTION(BLUEBERRY_INSTALL_RPATH_RELATIVE "Use relative rpath entries when installing" OFF) MARK_AS_ADVANCED(BLUEBERRY_INSTALL_RPATH_RELATIVE) IF(BLUEBERRY_INSTALL_RPATH_RELATIVE) SET(CMAKE_INSTALL_RPATH ".") ELSE() SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/bin") ENDIF() IF(MSVC) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250 /wd4275 /wd4251 /wd4503") ENDIF() IF (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin) ENDIF () FIND_PACKAGE(mbilog REQUIRED) INCLUDE_DIRECTORIES(${mbilog_INCLUDE_DIRS}) OPTION(BLUEBERRY_USE_QT "Use the Qt GUI toolkit" OFF) IF(NOT DESIRED_QT_VERSION) SET(DESIRED_QT_VERSION 4 CACHE STRING "Desired Qt version" FORCE) MARK_AS_ADVANCED(DESIRED_QT_VERSION) ENDIF() IF(BLUEBERRY_USE_QT AND NOT DESIRED_QT_VERSION EQUAL 4) MESSAGE("Attention: Qt4 is required to build the BlueBerry Qt plug-ins.") ENDIF() IF(BLUEBERRY_USE_QT AND DESIRED_QT_VERSION EQUAL 4) SET(QT_MT_REQUIRED 1) SET(BUILD_QT_PLUGINS 1) FIND_PACKAGE(Qt REQUIRED) IF(QT_QMAKE_CHANGED) SET(QT_HELPGENERATOR_EXECUTABLE NOTFOUND) SET(QT_COLLECTIONGENERATOR_EXECUTABLE NOTFOUND) SET(QT_ASSISTANT_EXECUTABLE NOTFOUND) ENDIF() FIND_PROGRAM(QT_HELPGENERATOR_EXECUTABLE NAMES qhelpgenerator qhelpgenerator-qt4 qhelpgenerator4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH ) FIND_PROGRAM(QT_COLLECTIONGENERATOR_EXECUTABLE NAMES qcollectiongenerator qcollectiongenerator-qt4 qcollectiongenerator4 PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH ) FIND_PROGRAM(QT_ASSISTANT_EXECUTABLE NAMES assistant-qt4 assistant4 assistant PATHS ${QT_BINARY_DIR} NO_DEFAULT_PATH ) OPTION(BLUEBERRY_USE_QT_HELP "Enable support for integrating bundle documentation into Qt Help" ON) MARK_AS_ADVANCED(BLUEBERRY_USE_QT_HELP QT_HELPGENERATOR_EXECUTABLE QT_COLLECTIONGENERATOR_EXECUTABLE QT_ASSISTANT_EXECUTABLE) SET(_doxygen_too_old 1) IF(BLUEBERRY_USE_QT_HELP) FIND_PACKAGE(Doxygen) IF(DOXYGEN_FOUND) EXECUTE_PROCESS(COMMAND ${DOXYGEN_EXECUTABLE} --version OUTPUT_VARIABLE _doxygen_version) IF(${_doxygen_version} VERSION_GREATER 1.6.0 OR ${_doxygen_version} VERSION_EQUAL 1.6.0) SET(_doxygen_too_old 0) ENDIF() ENDIF() ELSE(BLUEBERRY_USE_QT_HELP) CONFIGURE_FILE(../Documentation/pregenerated/MITKBlankPage.qch ${MITK_BINARY_DIR}/bin/ExtBundles/org.mitk.gui.qt.extapplication/resources/MITKBlankPage.qch COPYONLY) CONFIGURE_FILE(../Documentation/pregenerated/MitkExtQtHelpCollection.qhc ${MITK_BINARY_DIR}/bin/ExtBundles/org.mitk.gui.qt.extapplication/resources/MitkExtQtHelpCollection.qhc COPYONLY) ENDIF(BLUEBERRY_USE_QT_HELP) IF (BLUEBERRY_USE_QT_HELP AND _doxygen_too_old) MESSAGE("Doxygen was not found or is too old. Version 1.6.0 or later is needed if BLUEBERRY_USE_QT_HELP is ON") SET(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE) ENDIF() IF(BLUEBERRY_USE_QT_HELP AND NOT QT_HELPGENERATOR_EXECUTABLE) MESSAGE("You have enabled Qt Help support, but QT_HELPGENERATOR_EXECUTABLE is empty") SET(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE) ENDIF() INCLUDE(${QT_USE_FILE}) ENDIF() OPTION(BLUEBERRY_BUILD_ALL_PLUGINS "Build all BlueBerry plugins (overriding selection)" OFF) MARK_AS_ADVANCED(BLUEBERRY_BUILD_ALL_PLUGINS) IF(BLUEBERRY_BUILD_ALL_PLUGINS) SET(BLUEBERRY_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL") ENDIF() OPTION(BLUEBERRY_STATIC "Build all plugins as static libraries" OFF) MARK_AS_ADVANCED(BLUEBERRY_STATIC) OPTION(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF) MARK_AS_ADVANCED(BLUEBERRY_DEBUG_SMARTPOINTER) FIND_PACKAGE(Poco REQUIRED) FIND_PACKAGE(Ant) FIND_PACKAGE(Eclipse) SET(BLUEBERRY_SOURCE_DIR ${BlueBerry_SOURCE_DIR}) SET(BLUEBERRY_BINARY_DIR ${BlueBerry_BINARY_DIR}) SET(BLUEBERRY_PLUGINS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Bundles) SET(BLUEBERRY_PLUGINS_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Bundles) SET(OSGI_APP solstice) # Force should be removed after everybody has configured their old binary tree SET(BLUEBERRY_PLUGINS_OUTPUT_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/BlueBerry CACHE PATH "Directory where to build the BlueBerry Bundles" FORCE) MARK_AS_ADVANCED(BLUEBERRY_PLUGINS_OUTPUT_DIR) SET(BLUEBERRY_TEST_PLUGINS_OUTPUT_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/BlueBerryTests CACHE PATH "Directory where to build the BlueBerry test bundles") MARK_AS_ADVANCED(BLUEBERRY_TEST_PLUGINS_OUTPUT_DIR) # Clear the cache variables SET(BLUEBERRY_PLUGIN_SOURCE_DIRS "" CACHE INTERNAL "List of base plugin source directories" FORCE) SET(BLUEBERRY_PLUGIN_BINARY_DIRS "" CACHE INTERNAL "List of base plugin binary directories" FORCE) IF (Eclipse_DIR) SET(BLUEBERRY_DOC_TOOLS_DIR "${Eclipse_DIR}" CACHE PATH "Directory containing additional tools needed for generating the documentation") ELSE () SET(BLUEBERRY_DOC_TOOLS_DIR "" CACHE PATH "Directory containing additional tools needed for generating the documentation") ENDIF () SET(BLUEBERRY_DEBUG_POSTFIX d) +ADD_CUSTOM_TARGET(BlueBerry) + CONFIGURE_FILE(BlueBerryConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/BlueBerryConfig.cmake @ONLY) ADD_SUBDIRECTORY(Bundles) ADD_SUBDIRECTORY(Documentation) # Testing options OPTION(BLUEBERRY_BUILD_TESTING "Build the BlueBerry tests." OFF) IF(WIN32) SET(_gui_testing_default "ON") ELSE() SET(_gui_testing_default "OFF") ENDIF() OPTION(BLUEBERRY_ENABLE_GUI_TESTING "Enable the BlueBerry GUI tests" ${_gui_testing_default}) MARK_AS_ADVANCED(BLUEBERRY_ENABLE_GUI_TESTING) IF(BLUEBERRY_BUILD_TESTING) ENABLE_TESTING() ADD_SUBDIRECTORY(Testing) ENDIF() diff --git a/BlueBerry/Testing/CMakeLists.txt b/BlueBerry/Testing/CMakeLists.txt index 1afc1299e3..077bfbee0b 100755 --- a/BlueBerry/Testing/CMakeLists.txt +++ b/BlueBerry/Testing/CMakeLists.txt @@ -1,15 +1,22 @@ INCLUDE(berryTestingHelpers) INCLUDE(${BLUEBERRY_BINARY_DIR}/BlueBerryBundleList.cmake) SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}") GET_TARGET_PROPERTY(_is_macosx_bundle ${OSGI_APP} MACOSX_BUNDLE) IF(APPLE AND _is_macosx_bundle) SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}.app/Contents/MacOS/${OSGI_APP}") ENDIF() +SET(PLUGIN_EXCLUDE_LIST ) +IF(NOT BLUEBERRY_ENABLE_GUI_TESTING) + LIST(APPEND PLUGIN_EXCLUDE_LIST org.blueberry.ui.tests) +ENDIF() + MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${BLUEBERRY_TEST_PLUGINS_OUTPUT_DIR} CACHE_PLUGIN_TARGETS BLUEBERRY_ENABLED_TEST_PLUGINS BUNDLE_LIST_PATH "${BLUEBERRY_BINARY_DIR}/BlueBerryTestBundleList.cmake" CMAKE_CACHE_PREFIX "BLUEBERRY_TEST" + PLUGIN_EXCLUDES ${PLUGIN_EXCLUDE_LIST} ${BLUEBERRY_BUILD_ALL_PLUGINS_OPTION}) + diff --git a/CMake/MITKDashboardDriverScript.cmake b/CMake/MITKDashboardDriverScript.cmake index 298f226b77..29c793feff 100644 --- a/CMake/MITKDashboardDriverScript.cmake +++ b/CMake/MITKDashboardDriverScript.cmake @@ -1,251 +1,266 @@ # # Included from a dashboard script, this cmake file will drive the configure and build # steps of MITK # #----------------------------------------------------------------------------- # The following variable are expected to be define in the top-level script: set(expected_variables ADDITIONNAL_CMAKECACHE_OPTION CTEST_NOTES_FILES CTEST_SITE CTEST_DASHBOARD_ROOT CTEST_CMAKE_COMMAND CTEST_CMAKE_GENERATOR WITH_MEMCHECK WITH_COVERAGE WITH_DOCUMENTATION CTEST_BUILD_CONFIGURATION CTEST_TEST_TIMEOUT CTEST_BUILD_FLAGS TEST_TO_EXCLUDE_REGEX CTEST_PROJECT_NAME CTEST_SOURCE_DIRECTORY CTEST_BINARY_DIRECTORY CTEST_BUILD_NAME SCRIPT_MODE CTEST_COVERAGE_COMMAND CTEST_MEMORYCHECK_COMMAND CTEST_GIT_COMMAND QT_QMAKE_EXECUTABLE ) if(WITH_DOCUMENTATION) list(APPEND expected_variables DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY) endif() foreach(var ${expected_variables}) if(NOT DEFINED ${var}) message(FATAL_ERROR "Variable ${var} should be defined in top-level script !") endif() endforeach() # If the dashscript doesn't define a GIT_REPOSITORY variable, let's define it here. if (NOT DEFINED GIT_REPOSITORY OR GIT_REPOSITORY STREQUAL "") set(GIT_REPOSITORY git@mbits:MITK) endif() if (NOT DEFINED GIT_BRANCH OR GIT_BRANCH STREQUAL "") set(GIT_BRANCH "") else() set(GIT_BRANCH "-b ${GIT_BRANCH}") endif() # Should binary directory be cleaned? set(empty_binary_directory FALSE) # Attempt to build and test also if 'ctest_update' returned an error set(force_build FALSE) # Set model options set(model "") if (SCRIPT_MODE STREQUAL "experimental") set(empty_binary_directory FALSE) set(force_build TRUE) set(model Experimental) elseif (SCRIPT_MODE STREQUAL "continuous") set(empty_binary_directory TRUE) set(force_build FALSE) set(model Continuous) elseif (SCRIPT_MODE STREQUAL "nightly") set(empty_binary_directory TRUE) set(force_build TRUE) set(model Nightly) else() message(FATAL_ERROR "Unknown script mode: '${SCRIPT_MODE}'. Script mode should be either 'experimental', 'continuous' or 'nightly'") endif() #message("script_mode:${SCRIPT_MODE}") #message("model:${model}") #message("empty_binary_directory:${empty_binary_directory}") #message("force_build:${force_build}") set(CTEST_USE_LAUNCHERS 1) if(empty_binary_directory) message("Directory ${CTEST_BINARY_DIRECTORY} cleaned !") ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY}) endif() if(NOT EXISTS "${CTEST_SOURCE_DIRECTORY}") set(CTEST_CHECKOUT_COMMAND "${CTEST_GIT_COMMAND} clone ${GIT_BRANCH} ${GIT_REPOSITORY} ${CTEST_SOURCE_DIRECTORY}") endif() set(CTEST_UPDATE_COMMAND "${CTEST_GIT_COMMAND}") # # run_ctest macro # MACRO(run_ctest) ctest_start(${model}) ctest_update(SOURCE "${CTEST_SOURCE_DIRECTORY}" RETURN_VALUE res) # force a build if this is the first run and the build dir is empty if(NOT EXISTS "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt") message("First time build - Initialize CMakeCache.txt") set(res 1) # Write initial cache. file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt" " CTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS} BUILD_TESTING:BOOL=TRUE +BLUEBERRY_BUILD_TESTING:BOOL=TRUE BLUEBERRY_BUILD_ALL_PLUGINS:BOOL=TRUE MITK_BUILD_ALL_PLUGINS:BOOL=TRUE CMAKE_BUILD_TYPE:STRING=${CTEST_BUILD_CONFIGURATION} QT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} SUPERBUILD_EXCLUDE_MITKBUILD_TARGET:BOOL=TRUE WITH_COVERAGE:BOOL=${WITH_COVERAGE} #DOCUMENTATION_TARGET_IN_ALL:BOOL=${WITH_DOCUMENTATION} DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY:PATH=${DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY} ${ADDITIONNAL_CMAKECACHE_OPTION} ") endif() if (res GREATER 0 OR force_build) ctest_submit(PARTS Update) message("Configure SuperBuild") set_property(GLOBAL PROPERTY SubProject SuperBuild) set_property(GLOBAL PROPERTY Label SuperBuild) ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}" OPTIONS "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}" ) ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") ctest_submit(PARTS Configure) ctest_submit(FILES "${CTEST_BINARY_DIRECTORY}/Project.xml") # Build top level message("----------- [ Build SuperBuild ] -----------") ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND) ctest_submit(PARTS Build) ctest_test( BUILD "${CTEST_BINARY_DIRECTORY}" INCLUDE_LABEL "SuperBuild" PARALLEL_LEVEL 8 EXCLUDE ${TEST_TO_EXCLUDE_REGEX} ) # runs only tests that have a LABELS property matching "${subproject}" ctest_submit(PARTS Test) set(mitk_build_dir "${CTEST_BINARY_DIRECTORY}/MITK-build") - set(CTEST_PROJECT_SUBPROJECTS MITK) + # To get CTEST_PROJECT_SUBPROJECTS definition + include("${CTEST_BINARY_DIRECTORY}/CTestConfigSubProject.cmake") foreach(subproject ${CTEST_PROJECT_SUBPROJECTS}) set_property(GLOBAL PROPERTY SubProject ${subproject}) set_property(GLOBAL PROPERTY Label ${subproject}) message("----------- [ Build ${subproject} ] -----------") # Configure target ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}" OPTIONS "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}" ) ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}") ctest_submit(PARTS Configure) # Build target set(CTEST_BUILD_TARGET "${subproject}") - ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND) + ctest_build(BUILD "${mitk_build_dir}" APPEND) ctest_submit(PARTS Build) - + endforeach() + + # Build the rest of the project + set_property(GLOBAL PROPERTY SubProject SuperBuild) + set_property(GLOBAL PROPERTY Label SuperBuild) + + message("----------- [ Build All ] -----------") + set(CTEST_BUILD_TARGET) + ctest_build(BUILD "${mitk_build_dir}" APPEND) + ctest_submit(PARTS Build) + + # HACK Unfortunately ctest_coverage ignores the build argument, try to force it... + file(READ ${mitk_build_dir}/CMakeFiles/TargetDirectories.txt mitk_build_coverage_dirs) + file(APPEND "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${mitk_build_coverage_dirs}") + + foreach(subproject ${CTEST_PROJECT_SUBPROJECTS}) + set_property(GLOBAL PROPERTY SubProject ${subproject}) + set_property(GLOBAL PROPERTY Label ${subproject}) message("----------- [ Test ${subproject} ] -----------") ctest_test( BUILD "${mitk_build_dir}" APPEND INCLUDE_LABEL "${subproject}" PARALLEL_LEVEL 8 EXCLUDE ${TEST_TO_EXCLUDE_REGEX} ) # runs only tests that have a LABELS property matching "${subproject}" ctest_submit(PARTS Test) # Coverage per sub-project if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND) message("----------- [ Coverage ${subproject} ] -----------") ctest_coverage(BUILD "${mitk_build_dir}" LABELS "${subproject}") ctest_submit(PARTS Coverage) endif () #if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND) # ctest_memcheck(BUILD "${mitk_build_dir}" INCLUDE_LABEL "${subproject}") # ctest_submit(PARTS MemCheck) #endif () endforeach() if (WITH_DOCUMENTATION) message("----------- [ Build Documentation ] -----------") set(CTEST_USE_LAUNCHERS 0) # Build Documentation target set_property(GLOBAL PROPERTY SubProject Documentation) set_property(GLOBAL PROPERTY Label Documentation) set(CTEST_BUILD_TARGET "doc") ctest_build(BUILD "${mitk_build_dir}" APPEND) ctest_submit(PARTS Build) set(CTEST_USE_LAUNCHERS 1) endif() - # HACK Unfortunately ctest_coverage ignores the build argument, try to force it... - file(READ ${mitk_build_dir}/CMakeFiles/TargetDirectories.txt mitk_build_coverage_dirs) - file(APPEND "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${mitk_build_coverage_dirs}") - set_property(GLOBAL PROPERTY SubProject SuperBuild) set_property(GLOBAL PROPERTY Label SuperBuild) # Global coverage ... if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND) message("----------- [ Global coverage ] -----------") ctest_coverage(BUILD "${mitk_build_dir}" APPEND) ctest_submit(PARTS Coverage) endif () # Global dynamic analysis ... if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND) message("----------- [ Global memcheck ] -----------") ctest_memcheck(BUILD "${mitk_build_dir}") ctest_submit(PARTS MemCheck) endif () # Note should be at the end ctest_submit(PARTS Notes) endif() endmacro() if(SCRIPT_MODE STREQUAL "continuous") while(${CTEST_ELAPSED_TIME} LESS 68400) set(START_TIME ${CTEST_ELAPSED_TIME}) run_ctest() # Loop no faster than once every 5 minutes message("Wait for 5 minutes ...") ctest_sleep(${START_TIME} 300 ${CTEST_ELAPSED_TIME}) endwhile() else() run_ctest() endif() diff --git a/CMake/mitkFunctionGenerateProjectXml.cmake b/CMake/mitkFunctionGenerateProjectXml.cmake new file mode 100644 index 0000000000..c0d40feaba --- /dev/null +++ b/CMake/mitkFunctionGenerateProjectXml.cmake @@ -0,0 +1,45 @@ + + +function(mitkFunctionGenerateProjectXml dir name targets is_superbuild) + if(NOT EXISTS ${dir}) + message(FATAL_ERROR "Directory ${dir} doesn't exist!") + endif() + + set(xml_subprojects ) + + if(${is_superbuild}) + set(xml_subprojects ${xml_subprojects} " \n") + endif() + + foreach(target ${targets}) + + # Remarks: Project.xml should contains all sub-project. That way + # all dashboards should submit a similar file. + + set(xml_subprojects ${xml_subprojects} " \n") + + if(${is_superbuild}) + set(xml_subprojects ${xml_subprojects} " \n") + endif() + + # Generate XML related to the dependencies + #foreach(dependency_name ${dependencies}) + # set(xml_subprojects ${xml_subprojects} " \n") + #endforeach() + + set(xml_subprojects ${xml_subprojects} " \n") + endforeach() + + set(xml_subprojects ${xml_subprojects} " \n") + foreach(subproject ${targets}) + set(xml_subprojects ${xml_subprojects} " \n") + endforeach() + set(xml_subprojects ${xml_subprojects} " \n") + + set(xml_content "\n${xml_subprojects}") + set(filename "${dir}/Project.xml") + + file(WRITE ${filename} ${xml_content}) + message(STATUS "Generated: ${filename}") +endfunction() + diff --git a/CMake/mitkMacroCreateModule.cmake b/CMake/mitkMacroCreateModule.cmake index 286f1aae98..aa39f0b2fc 100644 --- a/CMake/mitkMacroCreateModule.cmake +++ b/CMake/mitkMacroCreateModule.cmake @@ -1,150 +1,183 @@ ################################################################## # # MITK_CREATE_MODULE # # Creates a module for the automatic module dependeny system within MITK. # Configurations are generated in the moduleConf directory. # # USAGE: # # MITK_CREATE_MODULE( # [INCLUDE_DIRS ] # [INTERNAL_INCLUDE_DIRS ] # [DEPENDS ] # [PROVIDES ] # [PACKAGE_DEPENDS ] # [EXPORT_DEFINE ] # [QT_MODULE] # ################################################################## MACRO(MITK_CREATE_MODULE MODULE_NAME_IN) MACRO_PARSE_ARGUMENTS(MODULE - "INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PROVIDES;PACKAGE_DEPENDS;EXPORT_DEFINE;ADDITIONAL_LIBS;GENERATED_CPP" + "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}) + 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} ${CPP_FILES} ${H_FILES} ${CPP_FILES_GENERATED} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES} ${DOX_FILES} ${UI_FILES} ${TOOL_CPPS}) - set_property(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${PROJECT_NAME}) + 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}) + FOREACH(subproject ${MODULE_SUBPROJECTS}) + ADD_DEPENDENCIES(${subproject} ${MODULE_PROVIDES}) + ENDFOREACH() + ENDIF() IF(ALL_LIBRARIES) TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${ALL_LIBRARIES}) ENDIF(ALL_LIBRARIES) 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} ${CPP_FILES} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP} ${CORRESPONDING__H_FILES} ${GLOBBED__H_FILES} ${TXX_FILES} ${DOX_FILES} ${UI_FILES} ${QRC_FILES} ${TOOL_GUI_CPPS}) - set_property(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${PROJECT_NAME}) + 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(MODULE_SUBPROJECTS) + SET_PROPERTY(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${MODULE_SUBPROJECTS}) + FOREACH(subproject ${MODULE_SUBPROJECTS}) + ADD_DEPENDENCIES(${subproject} ${MODULE_PROVIDES}) + ENDFOREACH() + ENDIF() ENDIF() ENDIF(NOT MODULE_QT_MODULE) # 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/CMake/mitkMacroCreateModuleTests.cmake b/CMake/mitkMacroCreateModuleTests.cmake index 4dfdf2d87d..a4d501c322 100644 --- a/CMake/mitkMacroCreateModuleTests.cmake +++ b/CMake/mitkMacroCreateModuleTests.cmake @@ -1,74 +1,85 @@ # # Create tests and testdriver for this module # # Usage: MITK_CREATE_MODULE_TESTS( [EXTRA_DRIVER_INIT init_code] ) # # EXTRA_DRIVER_INIT is inserted as c++ code in the testdriver and will be executed before each test # MACRO(MITK_CREATE_MODULE_TESTS) MACRO_PARSE_ARGUMENTS(MODULE_TEST "EXTRA_DRIVER_INIT;EXTRA_DRIVER_INCLUDE" "" ${ARGN}) IF(BUILD_TESTING AND MODULE_IS_ENABLED) SET(OLD_MOC_H_FILES ${MOC_H_FILES}) SET(MOC_H_FILES) INCLUDE(files.cmake) INCLUDE_DIRECTORIES(.) IF(DEFINED MOC_H_FILES) QT4_WRAP_CPP(MODULE_TEST_GENERATED_MOC_CPP ${MOC_H_FILES}) ENDIF(DEFINED MOC_H_FILES) SET(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "mitk::LoggingBackend::Register(); ${MODULE_TEST_EXTRA_DRIVER_INIT};") SET(CMAKE_TESTDRIVER_AFTER_TESTMAIN "mitk::LoggingBackend::Unregister();") IF(NOT MODULE_TEST_EXTRA_DRIVER_INCLUDE) # this is necessary to make the LoggingBackend calls available if nothing else is included SET(MODULE_TEST_EXTRA_DRIVER_INCLUDE "mitkLog.h") ENDIF(NOT MODULE_TEST_EXTRA_DRIVER_INCLUDE) CREATE_TEST_SOURCELIST(MODULETEST_SOURCE ${MODULE_NAME}TestDriver.cpp ${MODULE_TESTS} ${MODULE_IMAGE_TESTS} ${MODULE_CUSTOM_TESTS} EXTRA_INCLUDE ${MODULE_TEST_EXTRA_DRIVER_INCLUDE} ) SET(TESTDRIVER ${MODULE_NAME}TestDriver) ADD_EXECUTABLE(${TESTDRIVER} ${MODULETEST_SOURCE} ${MODULE_TEST_GENERATED_MOC_CPP}) - set_property(TARGET ${TESTDRIVER} PROPERTY LABELS ${PROJECT_NAME}) TARGET_LINK_LIBRARIES(${TESTDRIVER} ${MODULE_PROVIDES} ${ALL_LIBRARIES}) + IF(MODULE_SUBPROJECTS) + FOREACH(subproject ${MODULE_SUBPROJECTS}) + ADD_DEPENDENCIES(${subproject} ${TESTDRIVER}) + ENDFOREACH() + ENDIF() + # # Now tell CMake which tests should be run. This is done automatically # for all tests in ${KITNAME}_TESTS and ${KITNAME}_IMAGE_TESTS. The IMAGE_TESTS # are run for each image in the TESTIMAGES list. # FOREACH( test ${MODULE_TESTS} ) GET_FILENAME_COMPONENT(TName ${test} NAME_WE) ADD_TEST(${TName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName}) - set_property(TEST ${TName} PROPERTY LABELS ${PROJECT_NAME}) + # Add labels for CDash subproject support + IF(MODULE_SUBPROJECTS) + SET_PROPERTY(TEST ${TName} PROPERTY LABELS ${MODULE_SUBPROJECTS}) + ENDIF() ENDFOREACH( test ) FOREACH(image ${MODULE_TESTIMAGES} ${ADDITIONAL_TEST_IMAGES} ) IF(EXISTS ${image}) SET(IMAGE_FULL_PATH ${image}) ELSE(EXISTS ${image}) # todo: maybe search other paths as well # yes, please in mitk/Testing/Data, too SET(IMAGE_FULL_PATH ${MITK_SOURCE_DIR}/Core/Code/Testing/Data/${image}) ENDIF(EXISTS ${image}) IF(EXISTS ${IMAGE_FULL_PATH}) - FOREACH( test ${MODULE_IMAGE_TESTS} ) - GET_FILENAME_COMPONENT(TName ${test} NAME_WE) - GET_FILENAME_COMPONENT(ImageName ${IMAGE_FULL_PATH} NAME) - ADD_TEST(${TName}_${ImageName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${IMAGE_FULL_PATH}) - set_property(TEST ${TName}_${ImageName} PROPERTY LABELS ${PROJECT_NAME}) - ENDFOREACH( test ) + FOREACH( test ${MODULE_IMAGE_TESTS} ) + GET_FILENAME_COMPONENT(TName ${test} NAME_WE) + GET_FILENAME_COMPONENT(ImageName ${IMAGE_FULL_PATH} NAME) + ADD_TEST(${TName}_${ImageName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${IMAGE_FULL_PATH}) + # Add labels for CDash subproject support + IF(MODULE_SUBPROJECTS) + SET_PROPERTY(TEST ${TName} PROPERTY LABELS ${MODULE_SUBPROJECTS}) + ENDIF() + ENDFOREACH( test ) ELSE(EXISTS ${IMAGE_FULL_PATH}) MESSAGE("!!!!! No such file: ${IMAGE_FULL_PATH} !!!!!") ENDIF(EXISTS ${IMAGE_FULL_PATH}) ENDFOREACH( image ) SET(MOC_H_FILES ${OLD_MOC_H_FILES}) ENDIF(BUILD_TESTING AND MODULE_IS_ENABLED) ENDMACRO(MITK_CREATE_MODULE_TESTS) diff --git a/CMake/mitkMacroCreatePlugin.cmake b/CMake/mitkMacroCreatePlugin.cmake index 914541684f..f7f7984532 100755 --- a/CMake/mitkMacroCreatePlugin.cmake +++ b/CMake/mitkMacroCreatePlugin.cmake @@ -1,19 +1,25 @@ MACRO(MACRO_CREATE_MITK_PLUGIN) MITK_CHECK_MODULE(_MODULE_CHECK_RESULT Mitk ${ARGN}) IF(NOT _MODULE_CHECK_RESULT) - MITK_USE_MODULE(Mitk ${ARGN}) - - LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) - INCLUDE_DIRECTORIES(${ALL_INCLUDE_DIRECTORIES}) - MACRO_CREATE_PLUGIN() + MITK_USE_MODULE(Mitk ${ARGN}) + + LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) + INCLUDE_DIRECTORIES(${ALL_INCLUDE_DIRECTORIES}) + MACRO_CREATE_PLUGIN() - TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} ${ALL_LIBRARIES}) + TARGET_LINK_LIBRARIES(${PLUGIN_TARGET} ${ALL_LIBRARIES}) + IF(MITK_DEFAULT_SUBPROJECTS) + SET_PROPERTY(TARGET ${PLUGIN_TARGET} PROPERTY LABELS ${MITK_DEFAULT_SUBPROJECTS}) + FOREACH(subproject ${MITK_DEFAULT_SUBPROJECTS}) + ADD_DEPENDENCIES(${subproject} ${PLUGIN_TARGET}) + ENDFOREACH() + ENDIF() ELSE(NOT _MODULE_CHECK_RESULT) IF(NOT MITK_BUILD_ALL_PLUGINS) MESSAGE(SEND_ERROR "${BUNDLE-SYMBOLICNAME} is missing requirements and won't be built. Missing: ${_MODULE_CHECK_RESULT}") ELSE() MESSAGE(STATUS "${BUNDLE-SYMBOLICNAME} is missing requirements and won't be built. Missing: ${_MODULE_CHECK_RESULT}") ENDIF() ENDIF(NOT _MODULE_CHECK_RESULT) ENDMACRO() diff --git a/CMakeLists.txt b/CMakeLists.txt index 5c59fc3a6d..9991b14164 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,406 +1,436 @@ cmake_minimum_required(VERSION 2.8.2) project(MITK) #----------------------------------------------------------------------------- # See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details #----------------------------------------------------------------------------- set(project_policies CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used. CMP0002 # NEW: Logical target names must be globally unique. CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths. CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace. CMP0005 # NEW: Preprocessor definition values are now escaped automatically. CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION. CMP0007 # NEW: List command no longer ignores empty elements. CMP0008 # NEW: Libraries linked by full-path must have a valid library file name. CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default. CMP0010 # NEW: Bad variable reference syntax is an error. CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP. CMP0012 # NEW: if() recognizes numbers and boolean constants. CMP0013 # NEW: Duplicate binary directories are not allowed. CMP0014 # NEW: Input directories must have CMakeLists.txt ) foreach(policy ${project_policies}) if(POLICY ${policy}) cmake_policy(SET ${policy} NEW) endif() endforeach() #----------------------------------------------------------------------------- # Update CMake module path #------------------------------------------------------------------------------ set(CMAKE_MODULE_PATH ${MITK_SOURCE_DIR}/CMake ${CMAKE_MODULE_PATH} ) #----------------------------------------------------------------------------- # CMake Function(s) and Macro(s) #----------------------------------------------------------------------------- include(mitkMacroEmptyExternalProject) +include(mitkFunctionGenerateProjectXml) #----------------------------------------------------------------------------- # Superbuild Option - Enabled by default #----------------------------------------------------------------------------- option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON) #----------------------------------------------------------------------------- # Output directories. #----------------------------------------------------------------------------- foreach(type LIBRARY RUNTIME ARCHIVE) # Make sure the directory exists if(DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY AND NOT EXISTS ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}) message(FATAL_ERROR "MITK_CMAKE_${type}_OUTPUT_DIRECTORY is set to a non-existing directory [${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}]") endif() if(MITK_USE_SUPERBUILD) set(output_dir ${MITK_BINARY_DIR}/bin) if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY) set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_BINARY_DIR}/MITK-build/bin) endif() else() if(NOT DEFINED MITK_CMAKE_${type}_OUTPUT_DIRECTORY) SET(output_dir ${MITK_BINARY_DIR}/bin) else() SET(output_dir ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}) endif() endif() set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.") mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY) endforeach() #----------------------------------------------------------------------------- # Additional MITK Options (also shown during superbuild) #----------------------------------------------------------------------------- option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON) option(WITH_COVERAGE "Enable/Disable coverage" OFF) option(BUILD_TESTING "Test the project" ON) # some targets in Utilities also depend on Qt. Use this option # to decide if they should be build option(MITK_USE_QT "Use Trolltech's Qt library" ON) if(MITK_USE_QT) # find the package at the very beginning, so that QT4_FOUND is available find_package(Qt4 4.6.0 REQUIRED) endif() option(MITK_INSTALL_RPATH_RELATIVE "Use relative rpath entries for installation packages" OFF) option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF) option(MITK_BUILD_TUTORIAL "Build the MITK tutorial" ON) option(MITK_USE_Boost "Use the Boost C++ library" OFF) option(MITK_USE_GDCMIO "Use the GDCMIO class instead of ImageIO2 for DICOM" ON) option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON) option(MITK_USE_CTK "EXEPERIMENTAL, superbuild only: Use CTK in MITK" OFF) option(MITK_USE_DCMTK "EXEPERIMENTAL, superbuild only: Use DCMTK in MITK" OFF) mark_as_advanced(MITK_INSTALL_RPATH_RELATIVE MITK_BUILD_ALL_PLUGINS MITK_USE_CTK MITK_USE_DCMTK ) #----------------------------------------------------------------------------- # Additional CXX/C Flags #----------------------------------------------------------------------------- set(ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags") mark_as_advanced(ADDITIONAL_C_FLAGS) set(ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags") mark_as_advanced(ADDITIONAL_CXX_FLAGS) +#----------------------------------------------------------------------------- +# Project.xml +#----------------------------------------------------------------------------- + +# A list of topologically ordered targets +set(CTEST_PROJECT_SUBPROJECTS + MITK-Core + MITK-CoreUI + MITK-IGT + MITK-DTI + MITK-Registration + MITK-Modules # all modules not contained in a specific subproject + MITK-Plugins # all plugins not contained in a specific subproject + ) + +# Configure CTestConfigSubProject.cmake that could be used by CTest scripts +configure_file(${MITK_SOURCE_DIR}/CTestConfigSubProject.cmake.in + ${MITK_BINARY_DIR}/CTestConfigSubProject.cmake) + +# Generate Project.xml file expected by the CTest driver script +mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} ${PROJECT_NAME} "${CTEST_PROJECT_SUBPROJECTS}" ${MITK_USE_SUPERBUILD}) + #----------------------------------------------------------------------------- # Superbuild script #----------------------------------------------------------------------------- if(MITK_USE_SUPERBUILD) include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake") return() endif() #***************************************************************************** #**************************** END OF SUPERBUILD **************************** #***************************************************************************** #----------------------------------------------------------------------------- # CMake Function(s) and Macro(s) #----------------------------------------------------------------------------- include(mitkFunctionCheckCompilerFlags) include(mitkFunctionGetGccVersion) include(MacroParseArguments) include(mitkFunctionSuppressWarnings) # includes several functions include(mitkFunctionOrganizeSources) include(mitkFunctionGetVersion) include(mitkFunctionCreateWindowsBatchScript) include(mitkMacroCreateModuleConf) include(mitkMacroCreateModule) include(mitkMacroCheckModule) include(mitkMacroCreateModuleTests) include(mitkMacroUseModule) include(mitkMacroMultiplexPicType) include(mitkMacroInstall) include(mitkMacroInstallHelperApp) include(mitkMacroInstallTargets) include(mitkMacroGenerateToolsLibrary) #----------------------------------------------------------------------------- # Prerequesites #----------------------------------------------------------------------------- find_package(ITK REQUIRED) find_package(VTK REQUIRED) #----------------------------------------------------------------------------- # Set MITK specific options and variables (NOT available during superbuild) #----------------------------------------------------------------------------- # ASK THE USER TO SHOW THE CONSOLE WINDOW FOR CoreApp and ExtApp option(MITK_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting MITK GUI Applications" ON) mark_as_advanced(MITK_SHOW_CONSOLE_WINDOW) # TODO: check if necessary option(USE_ITKZLIB "Use the ITK zlib for pic compression." ON) mark_as_advanced(USE_ITKZLIB) #----------------------------------------------------------------------------- # Get MITK version info #----------------------------------------------------------------------------- mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK) #----------------------------------------------------------------------------- # Set symbol visibility Flags #----------------------------------------------------------------------------- # MinGW does not export all symbols automatically, so no need to set flags if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW) set(VISIBILITY_CXX_FLAGS ) #"-fvisibility=hidden -fvisibility-inlines-hidden") endif() #----------------------------------------------------------------------------- # Set coverage Flags #----------------------------------------------------------------------------- if(WITH_COVERAGE) if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG") set(COVERAGE_CXX_FLAGS ${coverage_flags}) set(COVERAGE_C_FLAGS ${coverage_flags}) endif() endif() #----------------------------------------------------------------------------- # MITK C/CXX Flags #----------------------------------------------------------------------------- set(MITK_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_C_FLAGS} ${ADDITIONAL_C_FLAGS}") set(MITK_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS} ${ADDITIONAL_CXX_FLAGS}") if(CMAKE_COMPILER_IS_GNUCXX) set(cflags "-Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -D_FORTIFY_SOURCE=2") mitkFunctionCheckCompilerFlags("-fdiagnostics-show-option" cflags) mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" cflags) mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION) # With older version of gcc supporting the flag -fstack-protector-all, an extra dependency to libssp.so # is introduced. If gcc is smaller than 4.4.0 and the build type is Release let's not include the flag. # Doing so should allow to build package made for distribution using older linux distro. if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0")) mitkFunctionCheckCompilerFlags("-fstack-protector-all" cflags) endif() if(MINGW) # suppress warnings about auto imported symbols set(MITK_CXX_FLAGS "-Wl,--enable-auto-import ${MITK_CXX_FLAGS}") # we need to define a Windows version set(MITK_CXX_FLAGS "-D_WIN32_WINNT=0x0500 ${MITK_CXX_FLAGS}") endif() set(MITK_C_FLAGS "${cflags} ${MITK_C_FLAGS}") #set(MITK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wold-style-cast -Wstrict-null-sentinel -Wsign-promo ${MITK_CXX_FLAGS}") set(MITK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wstrict-null-sentinel ${MITK_CXX_FLAGS}") endif() #----------------------------------------------------------------------------- # MITK Modules #----------------------------------------------------------------------------- set(MITK_MODULES_CONF_DIR ${MITK_BINARY_DIR}/modulesConf CACHE INTERNAL "Modules Conf") set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends) set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR}) #----------------------------------------------------------------------------- # Testing #----------------------------------------------------------------------------- if(BUILD_TESTING) enable_testing() include(CTest) mark_as_advanced(TCL_TCLSH DART_ROOT) + + option(MITK_ENABLE_GUI_TESTING OFF "Enable the MITK GUI tests") # Setup file for setting custom ctest vars configure_file( CMake/CTestCustom.cmake.in ${MITK_BINARY_DIR}/CTestCustom.cmake @ONLY ) # Configuration for the CMake-generated test driver set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include ") set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN " try {") set(CMAKE_TESTDRIVER_AFTER_TESTMAIN " } catch( std::exception & excp ) { fprintf(stderr,\"%s\\n\",excp.what()); return EXIT_FAILURE; } catch( ... ) { printf(\"Exception caught in the test driver\\n\"); return EXIT_FAILURE; } ") set(MITK_TEST_OUTPUT_DIR "${MITK_BINARY_DIR}/test_output") if(NOT EXISTS ${MITK_TEST_OUTPUT_DIR}) file(MAKE_DIRECTORY ${MITK_TEST_OUTPUT_DIR}) endif() configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h) endif() #----------------------------------------------------------------------------- # MITK_SUPERBUILD_BINARY_DIR #----------------------------------------------------------------------------- # If MITK_SUPERBUILD_BINARY_DIR isn't defined, it means MITK is *NOT* build using Superbuild. # In that specific case, MITK_SUPERBUILD_BINARY_DIR should default to MITK_BINARY_DIR if(NOT DEFINED MITK_SUPERBUILD_BINARY_DIR) set(MITK_SUPERBUILD_BINARY_DIR ${MITK_BINARY_DIR}) endif() #----------------------------------------------------------------------------- # Compile Utilities and set-up MITK variables #----------------------------------------------------------------------------- add_subdirectory(Utilities) include(mitkSetupVariables) if(MITK_USE_BLUEBERRY) include(mitkSetupBlueBerry) endif() #----------------------------------------------------------------------------- # Set C/CXX Flags for MITK code #----------------------------------------------------------------------------- set(CMAKE_CXX_FLAGS ${MITK_CXX_FLAGS}) set(CMAKE_C_FLAGS ${MITK_C_FLAGS}) if(MITK_USE_QT) add_definitions(-DQWT_DLL) endif() +#----------------------------------------------------------------------------- +# Add custom targets representing CDash subprojects +#----------------------------------------------------------------------------- + +foreach(subproject ${CTEST_PROJECT_SUBPROJECTS}) + add_custom_target(${subproject}) +endforeach() + #----------------------------------------------------------------------------- # Add subdirectories #----------------------------------------------------------------------------- link_directories(${MITK_LINK_DIRECTORIES}) add_subdirectory(Core) add_subdirectory(CoreUI) add_subdirectory(Modules) add_subdirectory(Applications) #----------------------------------------------------------------------------- # Python Wrapping #----------------------------------------------------------------------------- set(MITK_WRAPPING_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Wrapping) set(MITK_WRAPPING_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Wrapping) option(MITK_USE_PYTHON "Build cswig Python wrapper support (requires CableSwig)." OFF) if(MITK_USE_PYTHON) add_subdirectory(Wrapping) endif() #----------------------------------------------------------------------------- # Documentation #----------------------------------------------------------------------------- add_subdirectory(Documentation) #----------------------------------------------------------------------------- # Installation #----------------------------------------------------------------------------- if(MITK_INSTALL_RPATH_RELATIVE) set(CMAKE_INSTALL_RPATH ".") else() set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/bin") endif() # on Mac OSX all BlueBerry plugins get copied into every # application bundle (.app directory) specified here if(APPLE) if(MITK_BUILD_org.mitk.gui.qt.extapplication) set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} ExtApp) endif() if(MITK_BUILD_org.mitk.gui.qt.application) set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} CoreApp) endif() endif(APPLE) # set MITK cpack variables include(mitkSetupCPack) if(MITK_BUILD_org.mitk.gui.qt.application) list(APPEND CPACK_CREATE_DESKTOP_LINKS "CoreApp") endif() if(MITK_BUILD_org.mitk.gui.qt.extapplication) list(APPEND CPACK_CREATE_DESKTOP_LINKS "ExtApp") endif() configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY) set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake") # include CPack model once all variables are set include(CPack) # Additional installation rules include(mitkInstallRules) #----------------------------------------------------------------------------- # Last configuration steps #----------------------------------------------------------------------------- configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in ${MITK_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY) configure_file(${MITK_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in ${MITK_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY) configure_file(${MITK_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in ${MITK_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY) configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h) configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h) set(VECMATH_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/vecmath) set(IPFUNC_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/ipFunc) set(UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Utilities) -# Project.xml for CDash -CONFIGURE_FILE(MITKProject.xml "${MITK_BINARY_DIR}/Project.xml" COPYONlY) - configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h) configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY) diff --git a/CTestConfigSubProject.cmake.in b/CTestConfigSubProject.cmake.in new file mode 100644 index 0000000000..5bff13cd9b --- /dev/null +++ b/CTestConfigSubProject.cmake.in @@ -0,0 +1,2 @@ +set(CTEST_PROJECT_SUBPROJECTS @CTEST_PROJECT_SUBPROJECTS@) + diff --git a/Core/CMakeLists.txt b/Core/CMakeLists.txt index c5632ab443..3ba203af54 100644 --- a/Core/CMakeLists.txt +++ b/Core/CMakeLists.txt @@ -1,2 +1,4 @@ +SET(MITK_DEFAULT_SUBPROJECTS MITK-Core) + ADD_SUBDIRECTORY(Code) diff --git a/Core/Code/Testing/CMakeLists.txt b/Core/Code/Testing/CMakeLists.txt index 02d539ab6e..8ad3992bf4 100644 --- a/Core/Code/Testing/CMakeLists.txt +++ b/Core/Code/Testing/CMakeLists.txt @@ -1,8 +1,8 @@ -MITK_CREATE_MODULE_TESTS() +MITK_CREATE_MODULE_TESTS(LABELS MITK-Core) # MITK_INSTALL_TARGETS(EXECUTABLES MitkTestDriver) ADD_TEST(mitkPicFileReaderTest_emptyFile ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkPicFileReaderTest ${CMAKE_CURRENT_SOURCE_DIR}/Data/emptyFile.pic) -SET_PROPERTY(TEST mitkPicFileReaderTest_emptyFile PROPERTY LABELS ${PROJECT_NAME}) +SET_PROPERTY(TEST mitkPicFileReaderTest_emptyFile PROPERTY LABELS MITK-Core) ADD_TEST(mitkPicFileReaderTest_emptyGzipFile ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} mitkPicFileReaderTest ${CMAKE_CURRENT_SOURCE_DIR}/Data/emptyFile.pic.gz) -SET_PROPERTY(TEST mitkPicFileReaderTest_emptyGzipFile PROPERTY LABELS ${PROJECT_NAME}) +SET_PROPERTY(TEST mitkPicFileReaderTest_emptyGzipFile PROPERTY LABELS MITK-Core) diff --git a/CoreUI/BundleTesting/CMakeLists.txt b/CoreUI/BundleTesting/CMakeLists.txt index d7763917a6..583e57c265 100644 --- a/CoreUI/BundleTesting/CMakeLists.txt +++ b/CoreUI/BundleTesting/CMakeLists.txt @@ -1,28 +1,25 @@ IF(MITK_USE_BLUEBERRY) - SET(MITK_USE_BLUEBERRY 1) - FIND_PACKAGE(MITK REQUIRED) IF(NOT BLUEBERRY_MFPARSER) INCLUDE(${MITK_BINARY_DIR}/Bundles/MITKCoreBundleList.cmake) ENDIF() INCLUDE(berryTestingHelpers) SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp") GET_TARGET_PROPERTY(_is_macosx_bundle CoreApp MACOSX_BUNDLE) IF(APPLE AND _is_macosx_bundle) SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp") ENDIF() SET(BLUEBERRY_TEST_APP_ID "org.mitk.qt.application") MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/CoreBundles CACHE_PLUGIN_SOURCE_DIRS MITK_CORE_PLUGIN_SOURCE_DIRS CACHE_PLUGIN_OUTPUT_DIRS MITK_CORE_PLUGIN_OUTPUT_DIRS CACHE_PLUGIN_TARGETS MITK_CORE_ENABLED_TEST_PLUGINS CMAKE_CACHE_PREFIX "MITK" # DEPENDS "${BLUEBERRY_PLUGINS_OUTPUT_DIR}" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreBundles" ${MITK_BUILD_ALL_PLUGINS_OPTION}) -MESSAGE("SUFFIX: ${CMAKE_EXECUTABLE_SUFFIX}") ENDIF(MITK_USE_BLUEBERRY) diff --git a/CoreUI/BundleTesting/org.mitk.gui.qt.common.tests/CMakeLists.txt b/CoreUI/BundleTesting/org.mitk.gui.qt.common.tests/CMakeLists.txt index 8bf5b641df..9be81e7896 100644 --- a/CoreUI/BundleTesting/org.mitk.gui.qt.common.tests/CMakeLists.txt +++ b/CoreUI/BundleTesting/org.mitk.gui.qt.common.tests/CMakeLists.txt @@ -1,3 +1,4 @@ MACRO_CREATE_MITK_PLUGIN(Qmitk) -MACRO_TEST_UIPLUGIN() \ No newline at end of file +MACRO_TEST_UIPLUGIN(${MITK_DEFAULT_SUBPROJECTS}) + diff --git a/CoreUI/CMakeLists.txt b/CoreUI/CMakeLists.txt index 900a743190..944f180b67 100644 --- a/CoreUI/CMakeLists.txt +++ b/CoreUI/CMakeLists.txt @@ -1,15 +1,14 @@ +SET(MITK_DEFAULT_SUBPROJECTS MITK-CoreUI) + IF(MITK_USE_QT AND QT4_FOUND) ADD_SUBDIRECTORY(Qmitk) ENDIF() IF(MITK_USE_BLUEBERRY) ADD_SUBDIRECTORY(Bundles) - IF(BLUEBERRY_ENABLE_GUI_TESTING) - SET (MITK_ENABLE_GUI_TESTING OFF CACHE BOOL "Enables BlueBerry based GUI Tests for MITK Bundles") - IF(MITK_ENABLE_GUI_TESTING) - # ADD_SUBDIRECTORY(BundleTesting) - ENDIF(MITK_ENABLE_GUI_TESTING) - ENDIF(BLUEBERRY_ENABLE_GUI_TESTING) + IF(MITK_ENABLE_GUI_TESTING AND BLUEBERRY_ENABLE_GUI_TESTING) + ADD_SUBDIRECTORY(BundleTesting) + ENDIF() ENDIF() diff --git a/MITKProject.xml b/MITKProject.xml deleted file mode 100644 index 8a6597760f..0000000000 --- a/MITKProject.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - diff --git a/MITKSuperBuild.xml b/MITKSuperBuild.xml deleted file mode 100644 index 99a752541d..0000000000 --- a/MITKSuperBuild.xml +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - diff --git a/Modules/Bundles/CMakeLists.txt b/Modules/Bundles/CMakeLists.txt index bf6a99cc78..0ad7262b5d 100644 --- a/Modules/Bundles/CMakeLists.txt +++ b/Modules/Bundles/CMakeLists.txt @@ -1,34 +1,36 @@ IF(MITK_USE_BLUEBERRY) # INCLUDE("${MITK_BINARY_DIR}/mitkExtConfig.cmake") # INCLUDE("${MITK_BINARY_DIR}/QmitkExtConfig.cmake") INCLUDE("${MITK_BINARY_DIR}/Bundles/MITKCoreBundleList.cmake") + SET(MITK_DEFAULT_SUBPROJECTS MITK-Plugins) + SET(_mitk_bundles_default "org.mitk.core.ext" "org.mitk.planarfigure" ) IF(QT4_FOUND) LIST(APPEND _mitk_bundles_default "org.mitk.gui.qt.ext" "org.mitk.gui.qt.extapplication") # ExtApp required bundles LIST(APPEND _mitk_bundles_default "org.mitk.gui.qt.imagenavigator" "org.mitk.gui.qt.datamanager") ENDIF() SET(PLUGIN_EXCLUDE_LIST org.mitk.gui.qt.volumetry ) MACRO_COLLECT_PLUGINS(OUTPUT_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ExtBundles CACHE_PLUGIN_SOURCE_DIRS MITK_MODULES_PLUGIN_SOURCE_DIRS CACHE_PLUGIN_OUTPUT_DIRS MITK_MODULES_PLUGIN_OUTPUT_DIRS CACHE_PLUGIN_TARGETS MITK_MODULES_ENABLED_PLUGINS BUNDLE_LIST_PATH "${MITK_BINARY_DIR}/Bundles/MITKModulesBundleList.cmake" CMAKE_CACHE_PREFIX "MITK" PLUGIN_DEFAULT_ON ${_mitk_bundles_default} PLUGIN_EXCLUDES ${PLUGIN_EXCLUDE_LIST} ${MITK_BUILD_ALL_PLUGINS_OPTION}) ENDIF(MITK_USE_BLUEBERRY) diff --git a/Modules/CMakeLists.txt b/Modules/CMakeLists.txt index cbb5ea1f93..316a06f6cf 100644 --- a/Modules/CMakeLists.txt +++ b/Modules/CMakeLists.txt @@ -1,21 +1,30 @@ SET(LIBPOSTFIX "Ext") -ADD_SUBDIRECTORY(SceneSerializationBase) -ADD_SUBDIRECTORY(PlanarFigure) -ADD_SUBDIRECTORY(MitkExt) -ADD_SUBDIRECTORY(SceneSerialization) -ADD_SUBDIRECTORY(QmitkExt) -ADD_SUBDIRECTORY(DiffusionImaging) -ADD_SUBDIRECTORY(GPGPU) -ADD_SUBDIRECTORY(IGT) -ADD_SUBDIRECTORY(IGTUI) -ADD_SUBDIRECTORY(RigidRegistration) -ADD_SUBDIRECTORY(RigidRegistrationUI) -ADD_SUBDIRECTORY(DeformableRegistration) -ADD_SUBDIRECTORY(DeformableRegistrationUI) -ADD_SUBDIRECTORY(OpenCVVideoSupport) -ADD_SUBDIRECTORY(Overlays) -ADD_SUBDIRECTORY(InputDevices) + +SET(module_dirs + SceneSerializationBase + PlanarFigure + MitkExt + SceneSerialization + QmitkExt + DiffusionImaging + GPGPU + IGT + IGTUI + RigidRegistration + RigidRegistrationUI + DeformableRegistration + DeformableRegistrationUI + OpenCVVideoSupport + Overlays + InputDevices +) + +SET(MITK_DEFAULT_SUBPROJECTS MITK-Modules) + +FOREACH(module_dir ${module_dirs}) + ADD_SUBDIRECTORY(${module_dir}) +ENDFOREACH() IF(MITK_USE_BLUEBERRY) ADD_SUBDIRECTORY(Bundles) ENDIF() diff --git a/Modules/DeformableRegistration/CMakeLists.txt b/Modules/DeformableRegistration/CMakeLists.txt index 0f3b664ecd..3bba8ee0c0 100644 --- a/Modules/DeformableRegistration/CMakeLists.txt +++ b/Modules/DeformableRegistration/CMakeLists.txt @@ -1,7 +1,8 @@ MITK_CREATE_MODULE(MitkDeformableRegistration + SUBPROJECTS MITK-Registration DEPENDS Mitk MitkRigidRegistration PROVIDES MitkDeformableRegistration EXPORT_DEFINE MITK_DEFORMABLEREGISTRATION_EXPORT ) ADD_SUBDIRECTORY(Testing) diff --git a/Modules/DeformableRegistrationUI/CMakeLists.txt b/Modules/DeformableRegistrationUI/CMakeLists.txt index be87e9c5ca..f586ab68d0 100644 --- a/Modules/DeformableRegistrationUI/CMakeLists.txt +++ b/Modules/DeformableRegistrationUI/CMakeLists.txt @@ -1,6 +1,7 @@ MITK_CREATE_MODULE(MitkDeformableRegistrationUI + SUBPROJECTS MITK-Registration DEPENDS Qmitk MitkDeformableRegistration QT_MODULE PROVIDES MitkDeformableRegistrationUI EXPORT_DEFINE MITK_DEFORMABLEREGISTRATION_UI_EXPORT ) diff --git a/Modules/DiffusionImaging/CMakeLists.txt b/Modules/DiffusionImaging/CMakeLists.txt index 2910eacd25..3eda59963a 100644 --- a/Modules/DiffusionImaging/CMakeLists.txt +++ b/Modules/DiffusionImaging/CMakeLists.txt @@ -1,19 +1,20 @@ FIND_PACKAGE(ITK) IF(ITK_GDCM_DIR) INCLUDE(${ITK_GDCM_DIR}/GDCMConfig.cmake) IF(GDCM_MAJOR_VERSION EQUAL 2) ADD_DEFINITIONS(-DGDCM2) SET(ITK_USES_GDCM2 1) ENDIF(GDCM_MAJOR_VERSION EQUAL 2) ENDIF(ITK_GDCM_DIR) MITK_CREATE_MODULE( MitkDiffusionImaging + SUBPROJECTS MITK-DTI INCLUDE_DIRS Algorithms DicomImport IODataStructures/DiffusionWeightedImages IODataStructures/QBallImages IODataStructures/TensorImages IODataStructures Reconstruction Tractography Rendering ${CMAKE_CURRENT_BINARY_DIR} DEPENDS MitkExt PACKAGE_DEPENDS Boost ) ADD_SUBDIRECTORY(Testing) CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/mitkDiffusionImagingConfigure.h.in ${CMAKE_CURRENT_BINARY_DIR}/mitkDiffusionImagingConfigure.h) diff --git a/Modules/IGT/CMakeLists.txt b/Modules/IGT/CMakeLists.txt index 5aa0b6fbc1..86c067a85e 100644 --- a/Modules/IGT/CMakeLists.txt +++ b/Modules/IGT/CMakeLists.txt @@ -1,29 +1,30 @@ INCLUDE(MITKIGTHardware.cmake) IF(MITK_USE_MICRON_TRACKER) SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_MICRON_TRACKER_INCLUDE_DIR}) SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_MICRON_TRACKER_LIB}) ENDIF(MITK_USE_MICRON_TRACKER) IF(MITK_USE_MICROBIRD_TRACKER) SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR}) SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_USE_MICROBIRD_TRACKER_LIB}) ENDIF(MITK_USE_MICROBIRD_TRACKER) MITK_CREATE_MODULE(MitkIGT + SUBPROJECTS MITK-IGT INCLUDE_DIRS IGTFilters IGTTrackingDevices IGTToolManagement INTERNAL_INCLUDE_DIRS ${INCLUDE_DIRS_INTERNAL} DEPENDS Mitk tinyxml SceneSerialization PROVIDES mitkIGT ADDITIONAL_LIBS "${ADDITIONAL_LIBS}" ) ## create IGT config CONFIGURE_FILE(mitkIGTConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTConfig.h @ONLY) # add test programm for serial communication classADD_EXECUTABLE(SerialCommunicationTest IGTTrackingDevices/mitkSerialCommunicationTest.cpp)TARGET_LINK_LIBRARIES(SerialCommunicationTest mitkIGT mitkCore tinyxml PocoXML) ADD_EXECUTABLE (IGTTutorialStep1 IGTTutorial/IGTTutorialStep1.cpp) TARGET_LINK_LIBRARIES(IGTTutorialStep1 mitkIGT mitkCore tinyxml PocoXML) ADD_SUBDIRECTORY(Testing) diff --git a/Modules/IGTUI/CMakeLists.txt b/Modules/IGTUI/CMakeLists.txt index 5bc10ae910..a748a81d18 100644 --- a/Modules/IGTUI/CMakeLists.txt +++ b/Modules/IGTUI/CMakeLists.txt @@ -1,12 +1,13 @@ MITK_CREATE_MODULE(MitkIGTUI + SUBPROJECTS MITK-IGT INCLUDE_DIRS Qmitk DEPENDS MitkIGT Qmitk QmitkExt PROVIDES mitkIGTUI QT_MODULE GENERATED_CPP ${TOOL_GUI_CPPS} ${TOOL_CPPS} ) ## create IGTUI config CONFIGURE_FILE(mitkIGTUIConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTUIConfig.h @ONLY) diff --git a/Modules/RigidRegistration/CMakeLists.txt b/Modules/RigidRegistration/CMakeLists.txt index 4509e89ae1..1618ef4b52 100644 --- a/Modules/RigidRegistration/CMakeLists.txt +++ b/Modules/RigidRegistration/CMakeLists.txt @@ -1,7 +1,8 @@ MITK_CREATE_MODULE(MitkRigidRegistration + SUBPROJECTS MITK-Registration DEPENDS Mitk PROVIDES MitkRigidRegistration EXPORT_DEFINE MITK_RIGIDREGISTRATION_EXPORT ) ADD_SUBDIRECTORY(Testing) diff --git a/Modules/RigidRegistrationUI/CMakeLists.txt b/Modules/RigidRegistrationUI/CMakeLists.txt index 8c7f048517..8eb8586bc6 100644 --- a/Modules/RigidRegistrationUI/CMakeLists.txt +++ b/Modules/RigidRegistrationUI/CMakeLists.txt @@ -1,7 +1,8 @@ MITK_CREATE_MODULE(MitkRigidRegistrationUI + SUBPROJECTS MITK-Registration INCLUDE_DIRS RigidRegistrationMetrics RigidRegistrationOptimizer RigidRegistrationTransforms DEPENDS Qmitk MitkRigidRegistration QT_MODULE PROVIDES MitkRigidRegistrationUI EXPORT_DEFINE MITK_RIGIDREGISTRATION_UI_EXPORT ) diff --git a/SuperBuild.cmake b/SuperBuild.cmake index 438e5b30e2..072ce3574c 100644 --- a/SuperBuild.cmake +++ b/SuperBuild.cmake @@ -1,228 +1,223 @@ #----------------------------------------------------------------------------- # Convenient macro allowing to download a file #----------------------------------------------------------------------------- MACRO(downloadFile url dest) FILE(DOWNLOAD ${url} ${dest} STATUS status) LIST(GET status 0 error_code) LIST(GET status 1 error_msg) IF(error_code) MESSAGE(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}") ENDIF() ENDMACRO() #----------------------------------------------------------------------------- # MITK Prerequisites #----------------------------------------------------------------------------- #----------------------------- Qt --------------------------- if(MITK_USE_QT) find_package(Qt4 REQUIRED) set(vtk_QT_ARGS -DDESIRED_QT_VERSION:STRING=4 -DVTK_USE_GUISUPPORT:BOOL=ON -DVTK_USE_QVTK_QTOPENGL:BOOL=ON -DVTK_USE_QT:BOOL=ON -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} ) endif() #----------------------------------------------------------------------------- # External project settings #----------------------------------------------------------------------------- INCLUDE(ExternalProject) SET(ep_base "${CMAKE_BINARY_DIR}/CMakeExternals") SET_PROPERTY(DIRECTORY PROPERTY EP_BASE ${ep_base}) SET(ep_install_dir ${ep_base}/Install) #SET(ep_build_dir ${ep_base}/Build) #SET(ep_source_dir ${ep_base}/Source) #SET(ep_parallelism_level) SET(ep_build_shared_libs ON) SET(ep_build_testing OFF) # Compute -G arg for configuring external projects with the same CMake generator: IF(CMAKE_EXTRA_GENERATOR) SET(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}") ELSE() SET(gen "${CMAKE_GENERATOR}") ENDIF() # Use this value where semi-colons are needed in ep_add args: set(sep "^^") ## IF(MSVC90 OR MSVC10) SET(ep_common_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP") SET(ep_common_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP") ELSE() SET(ep_common_C_FLAGS "${CMAKE_C_FLAGS} -DLINUX_EXTRA") SET(ep_common_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DLINUX_EXTRA") ENDIF() SET(ep_common_args -DBUILD_TESTING:BOOL=${ep_build_testing} -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir} -DBUILD_SHARED_LIBS:BOOL=ON -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER} -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER} "-DCMAKE_C_FLAGS:STRING=${ep_common_C_FLAGS}" "-DCMAKE_CXX_FLAGS:STRING=${ep_common_CXX_FLAGS}" ) #----------------------------------------------------------------------------- # ExternalProjects #----------------------------------------------------------------------------- SET(external_projects VTK GDCM ITK Boost DCMTK CTK ) # Include external projects FOREACH(p ${external_projects}) INCLUDE(CMakeExternals/${p}.cmake) ENDFOREACH() #----------------------------------------------------------------------------- # Set superbuild boolean args #----------------------------------------------------------------------------- SET(mitk_cmake_boolean_args BUILD_SHARED_LIBS WITH_COVERAGE BUILD_TESTING MITK_USE_QT MITK_INSTALL_RPATH_RELATIVE MITK_BUILD_ALL_PLUGINS MITK_BUILD_TUTORIAL MITK_USE_Boost MITK_USE_GDCMIO MITK_USE_BLUEBERRY MITK_USE_CTK MITK_USE_DCMTK ) #----------------------------------------------------------------------------- # Generate cmake variable names for MITK bundles #----------------------------------------------------------------------------- INCLUDE(mitkSuperBuildPlugins) FOREACH(plugin ${MITK_SUPERBUILD_PLUGINS}) LIST(APPEND mitk_cmake_boolean_args MITK_BUILD_${plugin}) OPTION(MITK_BUILD_${plugin} "Build the MITK ${plugin} plugin" OFF) ENDFOREACH() #----------------------------------------------------------------------------- # Create the final variable containing superbuild boolean args #----------------------------------------------------------------------------- SET(mitk_superbuild_boolean_args) FOREACH(mitk_cmake_arg ${mitk_cmake_boolean_args}) LIST(APPEND mitk_superbuild_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}}) ENDFOREACH() IF(MITK_BUILD_ALL_PLUGINS) LIST(APPEND mitk_superbuild_boolean_args -DBLUEBERRY_BUILD_ALL_PLUGINS:BOOL=ON) ENDIF() #----------------------------------------------------------------------------- # MITK Utilities #----------------------------------------------------------------------------- set(proj MITK-Utilities) ExternalProject_Add(${proj} DOWNLOAD_COMMAND "" CONFIGURE_COMMAND "" BUILD_COMMAND "" INSTALL_COMMAND "" DEPENDS # Mandatory dependencies ${VTK_DEPENDS} ${ITK_DEPENDS} # Optionnal dependencies ${Boost_DEPENDS} ${CTK_DEPENDS} ${DCMTK_DEPENDS} ) #----------------------------------------------------------------------------- # MITK Configure #----------------------------------------------------------------------------- SET(proj MITK-Configure) ExternalProject_Add(${proj} DOWNLOAD_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} ${mitk_superbuild_boolean_args} -DMITK_USE_SUPERBUILD:BOOL=OFF -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS} -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR} -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE} -DCTK_DIR:PATH=${CTK_DIR} -DDCMTK_DIR:PATH=${DCMTK_DIR} -DVTK_DIR:PATH=${VTK_DIR} # FindVTK expects VTK_DIR -DITK_DIR:PATH=${ITK_DIR} # FindITK expects ITK_DIR -DGDCM_DIR:PATH=${GDCM_DIR} -DBOOST_ROOT:PATH=${BOOST_ROOT} -DMITK_USE_Boost:BOOL=${MITK_USE_Boost} -DMITK_USE_GDCMIO:BOOL=${MITK_USE_GDCMIO} -DMITK_USE_DCMTK:BOOL=${MITK_USE_DCMTK} -DMITK_USE_QT:BOOL=${MITK_USE_QT} SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build BUILD_COMMAND "" INSTALL_COMMAND "" DEPENDS MITK-Utilities ) #----------------------------------------------------------------------------- # MITK #----------------------------------------------------------------------------- #MESSAGE(STATUS SUPERBUILD_EXCLUDE_MITKBUILD_TARGET:${SUPERBUILD_EXCLUDE_MITKBUILD_TARGET}) IF(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET) SET(proj MITK-build) ExternalProject_Add(${proj} DOWNLOAD_COMMAND "" CMAKE_GENERATOR ${gen} SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} BINARY_DIR MITK-build INSTALL_COMMAND "" DEPENDS "MITK-Configure" ) ENDIF() #----------------------------------------------------------------------------- # Custom target allowing to drive the build of MITK project itself #----------------------------------------------------------------------------- ADD_CUSTOM_TARGET(MITK COMMAND ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build ) -#----------------------------------------------------------------------------- -# Project.xml for CDash -#----------------------------------------------------------------------------- - -CONFIGURE_FILE(MITKSuperBuild.xml "${MITK_BINARY_DIR}/Project.xml" COPYONlY)