diff --git a/CMake/MITKDashboardDriverScript.cmake b/CMake/MITKDashboardDriverScript.cmake
index 26e8dcd851..5fd806257a 100644
--- a/CMake/MITKDashboardDriverScript.cmake
+++ b/CMake/MITKDashboardDriverScript.cmake
@@ -1,438 +1,438 @@
 
 #
 # 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
   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_SOURCE_DIRECTORY
   CTEST_BINARY_DIRECTORY
   CTEST_BUILD_NAME
   SCRIPT_MODE
   CTEST_COVERAGE_COMMAND
   CTEST_MEMORYCHECK_COMMAND
   CTEST_GIT_COMMAND
   QT_QMAKE_EXECUTABLE
   PROJECT_BUILD_DIR
   SUPERBUILD_TARGETS
   )
 
 foreach(var ${expected_variables})
   if(NOT DEFINED ${var})
     message(FATAL_ERROR "Variable ${var} should be defined in top-level script !")
   endif()
 endforeach()
 
 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(initial_force_build FALSE)
 
 # Set model options
 set(model "")
 if (SCRIPT_MODE STREQUAL "experimental")
   set(empty_binary_directory FALSE)
   set(initial_force_build TRUE)
   set(model Experimental)
 elseif (SCRIPT_MODE STREQUAL "continuous")
   set(empty_binary_directory FALSE)
   set(initial_force_build FALSE)
   set(model Continuous)
 elseif (SCRIPT_MODE STREQUAL "nightly")
   set(empty_binary_directory TRUE)
   set(initial_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:${initial_force_build}")
 
 if(empty_binary_directory)
   message("Directory ${CTEST_BINARY_DIRECTORY} cleaned !")
   ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY})
 endif()
 
 if(NOT DEFINED CTEST_CHECKOUT_DIR)
   set(CTEST_CHECKOUT_DIR ${CTEST_SOURCE_DIRECTORY})
 endif()
 
 if(NOT EXISTS "${CTEST_CHECKOUT_DIR}")
   set(CTEST_CHECKOUT_COMMAND "\"${CTEST_GIT_COMMAND}\" clone ${GIT_BRANCH} ${GIT_REPOSITORY} \"${CTEST_CHECKOUT_DIR}\"")
 endif()
 
 set(CTEST_UPDATE_TYPE "git")
 set(CTEST_UPDATE_COMMAND "${CTEST_GIT_COMMAND}")
 
 #----------------------------------------------------------------------
 # Utility macros 
 #----------------------------------------------------------------------
 
 function(func_build_target target build_dir)
   set(CTEST_BUILD_TARGET ${target})
   ctest_build(BUILD "${build_dir}" APPEND
               RETURN_VALUE res
               NUMBER_ERRORS num_errors
               NUMBER_WARNINGS num_warnings)
   ctest_submit(PARTS Build)
   
   if(num_errors)
     math(EXPR build_errors "${build_errors} + ${num_errors}")
     set(build_errors ${build_errors} PARENT_SCOPE)
   endif()
   if(num_warnings)
     math(EXPR build_warnings "${build_warnings} + ${num_warnings}")
     set(build_warnings ${build_warnings} PARENT_SCOPE)
   endif()
 endfunction()
 
 function(func_test label build_dir)
   if (NOT TESTING_PARALLEL_LEVEL)
     set(TESTING_PARALLEL_LEVEL 8)
   endif()
   ctest_test(BUILD "${build_dir}"
              INCLUDE_LABEL ${label}
              PARALLEL_LEVEL ${TESTING_PARALLEL_LEVEL}
              EXCLUDE ${TEST_TO_EXCLUDE_REGEX}
              RETURN_VALUE res
             )
   ctest_submit(PARTS Test)
         
   if(res)
     math(EXPR test_errors "${test_errors} + 1")
     set(test_errors ${test_errors} PARENT_SCOPE)
   endif()
   
   if(ARG3)
     set(WITH_COVERAGE ${ARG3})
   endif()
   if(ARG4)
     set(WITH_MEMCHECK ${ARG4})
   endif()
   
   if(WITH_COVERAGE AND CTEST_COVERAGE_COMMAND)
     message("----------- [ Coverage ${label} ] -----------")
     ctest_coverage(BUILD "${build_dir}" LABELS ${label})
     ctest_submit(PARTS Coverage)
   endif ()
 
   #if(WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND)
   #  ctest_memcheck(BUILD "${build_dir}" INCLUDE_LABEL ${label})
   #  ctest_submit(PARTS MemCheck)
   #endif ()
 endfunction()
 
 #---------------------------------------------------------------------
 # run_ctest macro
 #---------------------------------------------------------------------
 MACRO(run_ctest)
 
   set(build_warnings 0)
   set(build_errors 0)
   set(test_errors 0)
   
   ctest_start(${model})
 
   ctest_update(SOURCE "${CTEST_CHECKOUT_DIR}" RETURN_VALUE res)
   
   if(res LESS 0)
     # update error
     math(EXPR build_errors "${build_errors} + 1") 
   endif()
   
   set(force_build ${initial_force_build})
   
   # Check if a forced run was requested
   set(cdash_remove_rerun_url )
   if(NOT MITK_NO_CDASH_WEBADMIN)
     set(cdash_rerun_url "http://mbits/rerun/${CTEST_BUILD_NAME}")
     set(cdash_remove_rerun_url "http://mbits/rerun/rerun.php?name=${CTEST_BUILD_NAME}&remove=1")
     file(DOWNLOAD
          "${cdash_rerun_url}"
          "${CTEST_BINARY_DIRECTORY}/tmp.txt"
          STATUS status
          )
     list(GET status 0 error_code)
     file(READ "${CTEST_BINARY_DIRECTORY}/tmp.txt" rerun_content LIMIT 1)
     if(NOT error_code AND NOT rerun_content)
       set(force_build 1)
     endif()
   endif()
   
   if(COMMAND MITK_OVERRIDE_FORCE_BUILD)
     MITK_OVERRIDE_FORCE_BUILD(force_build)
   endif()
 
   # 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.
     if (NOT DEFINED BUILD_TESTING)
       set(BUILD_TESTING ON)
     endif()
 
     # Write initial cache.
     file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt" "
 CTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
 CTEST_PROJECT_ADDITIONAL_TARGETS:INTERNAL=${CTEST_PROJECT_ADDITIONAL_TARGETS}
 BUILD_TESTING:BOOL=${BUILD_TESTING}
-MITK_CTEST_SCRIPT_MODE:BOOL=TRUE
+MITK_CTEST_SCRIPT_MODE:STRING=${SCRIPT_MODE}
 CMAKE_BUILD_TYPE:STRING=${CTEST_BUILD_CONFIGURATION}
 QT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
 WITH_COVERAGE:BOOL=${WITH_COVERAGE}
 ${INITIAL_CMAKECACHE_OPTIONS}
 ")
   endif()
   
   if(res GREATER 0 OR force_build)
   
     # Clear the forced rerun request
     if(NOT MITK_NO_CDASH_WEBADMIN AND cdash_remove_rerun_url)
       file(DOWNLOAD "${cdash_remove_rerun_url}" "${CTEST_BINARY_DIRECTORY}/tmp.txt")
       file(REMOVE "${CTEST_BINARY_DIRECTORY}/tmp.txt")
     endif()
     
     if(CTEST_PROJECT_NAME_SUPERBUILD)
       set(ctest_project_name_orig ${CTEST_PROJECT_NAME})
       set(CTEST_PROJECT_NAME ${CTEST_PROJECT_NAME_SUPERBUILD})
     endif()
 
     message("----------- [ Configure SuperBuild ] -----------")
     
     set_property(GLOBAL PROPERTY SubProject SuperBuild)
     set_property(GLOBAL PROPERTY Label SuperBuild)
     
     ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
     
     if(res)
       math(EXPR build_errors "${build_errors} + 1") 
     endif()
     
     # Project.xml is generated during the superbuild configure step
     ctest_submit(FILES "${CTEST_BINARY_DIRECTORY}/Project.xml")
     
     ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}")
     
     ctest_submit(PARTS Configure)
     
     # submit the update results *after* the submitting the Configure info,
     # otherwise CDash is somehow confused and cannot add the update info
     # to the superbuild project
     ctest_submit(PARTS Update)
     
     # To get CTEST_PROJECT_SUBPROJECTS and CTEST_PROJECT_EXTERNALS definition
     include("${CTEST_BINARY_DIRECTORY}/CTestConfigSubProject.cmake")
 
     # Build top level (either all or the supplied targets at
     # superbuild level
     if(SUPERBUILD_TARGETS)
       foreach(superbuild_target ${SUPERBUILD_TARGETS})
         
         message("----------- [ Build ${superbuild_target} - SuperBuild ] -----------")
         func_build_target(${superbuild_target} "${CTEST_BINARY_DIRECTORY}")
         
         # runs only tests that have a LABELS property matching "SuperBuild"
         func_test("SuperBuild" "${CTEST_BINARY_DIRECTORY}")
       endforeach()
       
       # HACK Unfortunately ctest_coverage ignores the build argument, back-up the original dirs
       file(READ "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" old_coverage_dirs)
       
       # explicitly build requested external projects as subprojects
       foreach(external_project_with_build_dir ${CTEST_PROJECT_EXTERNALS})
       
         string(REPLACE "^^" ";" external_project_with_build_dir_list "${external_project_with_build_dir}")
         list(GET external_project_with_build_dir_list 0 external_project)
         list(GET external_project_with_build_dir_list 1 external_project_build_dir)
                 
         set_property(GLOBAL PROPERTY SubProject ${external_project})
         set_property(GLOBAL PROPERTY Label ${external_project})
         
         message("----------- [ Build ${external_project} ] -----------")
        
         # Build target
         func_build_target(${external_project} "${CTEST_BINARY_DIRECTORY}")
         
         # HACK Unfortunately ctest_coverage ignores the build argument, try to force it...
         file(READ "${CTEST_BINARY_DIRECTORY}/${external_project_build_dir}/CMakeFiles/TargetDirectories.txt" mitk_build_coverage_dirs)
         file(APPEND "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${mitk_build_coverage_dirs}")
         
         message("----------- [ Test ${external_project} ] -----------")
 
         # runs only tests that have a LABELS property matching "${external_project}"
         func_test(${external_project} "${CTEST_BINARY_DIRECTORY}/${external_project_build_dir}")
         
         # restore old coverage dirs
         file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${old_coverage_dirs}")
       
       endforeach()
 
       # switch back to SuperBuild label
       set_property(GLOBAL PROPERTY SubProject SuperBuild)
       set_property(GLOBAL PROPERTY Label SuperBuild)
       
       message("----------- [ Finish SuperBuild ] -----------")
     else()
        message("----------- [ Build SuperBuild ] -----------")
     endif()
     
     # build everything at superbuild level which has not yet been built
     func_build_target("" "${CTEST_BINARY_DIRECTORY}")
     
     # runs only tests that have a LABELS property matching "SuperBuild" 
     #func_test("SuperBuild" "${CTEST_BINARY_DIRECTORY}")
     
     set(build_dir "${CTEST_BINARY_DIRECTORY}/${PROJECT_BUILD_DIR}")
     if(CTEST_PROJECT_NAME_SUPERBUILD)
       set(CTEST_PROJECT_NAME ${ctest_project_name_orig})
     endif()
     
     message("----------- [ Configure ${build_dir} ] -----------")
     # Configure target
     ctest_configure(BUILD "${build_dir}"
       OPTIONS "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}"
       RETURN_VALUE res
     )
     ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}")
     ctest_submit(PARTS Configure)
     
     if(res)
       math(EXPR build_errors "${build_errors} + 1") 
     endif()
     
     foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
       set_property(GLOBAL PROPERTY SubProject ${subproject})
       set_property(GLOBAL PROPERTY Label ${subproject})
       message("----------- [ Build ${subproject} ] -----------")
      
       # Build target
       func_build_target(${subproject} "${build_dir}")
     endforeach()
     
     # Build the rest of the project
     set_property(GLOBAL PROPERTY SubProject SuperBuild)
     set_property(GLOBAL PROPERTY Label SuperBuild)
     
     message("----------- [ Build All ] -----------")
     func_build_target("" "${build_dir}")
     
     # HACK Unfortunately ctest_coverage ignores the build argument, try to force it...
     file(READ ${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} ] -----------")
 
       # runs only tests that have a LABELS property matching "${subproject}"
       func_test(${subproject} "${build_dir}")
     endforeach()
     
     # Build any additional target which is not build by "all"
     # i.e. the "package" target
     if(CTEST_PROJECT_ADDITIONAL_TARGETS)
       foreach(additional_target ${CTEST_PROJECT_ADDITIONAL_TARGETS})
         set_property(GLOBAL PROPERTY SubProject ${additional_target})
         set_property(GLOBAL PROPERTY Label ${additional_target})
         
         message("----------- [ Build ${additional_target} ] -----------")
         func_build_target(${additional_target} "${build_dir}")
         
         message("----------- [ Test ${additional_target} ] -----------")
         # runs only tests that have a LABELS property matching "${subproject}"
         func_test(${additional_target} "${build_dir}")
       endforeach()
     endif()
     
     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)
       func_build_target("doc" "${build_dir}")
       set(CTEST_USE_LAUNCHERS 1)
     endif()
     
     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 "${build_dir}" APPEND)
       ctest_submit(PARTS Coverage)
     endif ()
     
     # Global dynamic analysis ...
     if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND)
       message("----------- [ Global memcheck ] -----------")
       ctest_memcheck(BUILD "${build_dir}")
       ctest_submit(PARTS MemCheck)
     endif ()
     
     # Note should be at the end
     ctest_submit(PARTS Notes)
     
     # Send status to the "CDash Web Admin"
     if(NOT MITK_NO_CDASH_WEBADMIN)
       set(cdash_admin_url "http://mbits/cdashadmin-web/index.php?pw=4da12ca9c06d46d3171d7f73974c900f")
       string(REGEX REPLACE ".*\\?project=(.*)&?" "\\1" _ctest_project "${CTEST_DROP_LOCATION}")
       file(DOWNLOAD
            "${cdash_admin_url}&action=submit&name=${CTEST_BUILD_NAME}&hasTestErrors=${test_errors}&hasBuildErrors=${build_errors}&hasBuildWarnings=${build_warnings}&ctestDropSite=${CTEST_DROP_SITE}&ctestProject=${_ctest_project}"
            "${CTEST_BINARY_DIRECTORY}/cdashadmin.txt"
            STATUS status
            )
       list(GET status 0 error_code)
       list(GET status 1 error_msg)
       if(error_code)
         message(FATAL_ERROR "error: Failed to communicate with cdashadmin-web - ${error_msg}")
       endif()
     endif()
   
   endif()
   
   # Clear the CTEST_CHECKOUT_COMMAND variable to prevent continuous clients
   # to try to checkout again
   set(CTEST_CHECKOUT_COMMAND "")
   
 endmacro()
 
 if(SCRIPT_MODE STREQUAL "continuous")
   while(1)
     run_ctest()
     # Loop no faster than once every 5 minutes
     message("Wait for 5 minutes ...")
     ctest_sleep(300)
   endwhile()
 else()
   run_ctest()
 endif()
 
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index bcd0de84de..a4631a739a 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,248 +1,249 @@
 
 #-----------------------------------------------------------------------------
 # 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}
   #debug flags
   -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
   -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
   #release flags
   -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
   -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
   #relwithdebinfo
   -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
   -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
 )
 
 #-----------------------------------------------------------------------------
 # ExternalProjects 
 #-----------------------------------------------------------------------------
 
 SET(external_projects
   VTK
   GDCM
   ITK
   Boost
   DCMTK
   CTK
   OpenCV
   MITKData
   )
   
 # 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_BUILD_ALL_PLUGINS
   MITK_BUILD_TUTORIAL
   MITK_USE_Boost
   MITK_USE_BLUEBERRY
   MITK_USE_CTK
   MITK_USE_DCMTK
   MITK_USE_OpenCV
   )
   
 #-----------------------------------------------------------------------------
 # 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}
     ${OpenCV_DEPENDS}
     ${MITK-Data_DEPENDS}
 )
 
 #-----------------------------------------------------------------------------
 # MITK Configure
 #-----------------------------------------------------------------------------
 
 IF(MITK_INITIAL_CACHE_FILE)
   SET(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}")
 ENDIF()
 
 SET(proj MITK-Configure)
 
 STRING(REPLACE ";" "^^" MITK_MODULES_TO_BUILD_PARAM "${MITK_MODULES_TO_BUILD}")
 MESSAGE("PARAM: ${MITK_MODULES_TO_BUILD_PARAM}")
 ExternalProject_Add(${proj}
   LIST_SEPARATOR ^^
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
   CMAKE_ARGS
     ${ep_common_args}
     ${mitk_superbuild_boolean_args}
     -DMITK_USE_SUPERBUILD:BOOL=OFF
     -DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
     -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
+    -DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE}
     -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
     -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
     -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE}
     -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD_PARAM}
     -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
     -DOpenCV_DIR:PATH=${OpenCV_DIR}
     -DGDCM_DIR:PATH=${GDCM_DIR}
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
     -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
     -DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
     ${mitk_initial_cache_arg}
 
   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
 )