diff --git a/CMake/MITKDashboardDriverScript.cmake b/CMake/MITKDashboardDriverScript.cmake
index 59f9b0ccf8..5fddae1af8 100644
--- a/CMake/MITKDashboardDriverScript.cmake
+++ b/CMake/MITKDashboardDriverScript.cmake
@@ -1,449 +1,444 @@
 
 #
 # 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_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
   )
 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 FALSE)
   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(NOT DARTCLIENT_ERROR_FILE)
   set(DARTCLIENT_ERROR_FILE "${CTEST_BINARY_DIRECTORY}/dartclient_error.txt")
 endif()
 
 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}")
 
 #
 # run_ctest macro
 #
 MACRO(run_ctest)
   set(dartclient_error)
 
   ctest_start(${model})
   ctest_update(SOURCE "${CTEST_CHECKOUT_DIR}" 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
 MITK_CTEST_SCRIPT_MODE: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(NOT dartclient_error AND res LESS 0)
     # update error
     set(dartclient_error "Update or checkout error") 
   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}"
       RETURN_VALUE res
     )
     
     if(NOT dartclient_error AND res)
       set(dartclient_error "SuperBuild configure error (code ${res})")
     endif()
     
     ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}")
     ctest_submit(PARTS Configure)
     ctest_submit(FILES "${CTEST_BINARY_DIRECTORY}/Project.xml")
     
     # 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 ] -----------")
         set(CTEST_BUILD_TARGET "${superbuild_target}")
         ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND
           RETURN_VALUE res
           NUMBER_ERRORS num_errors
           NUMBER_WARNINGS num_warnings)
         ctest_submit(PARTS Build)
         
         if(NOT dartclient_error AND res)
           set(dartclient_error "Build error for ${superbuild_target} (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}")
         elseif(NOT dartclient_error AND num_warnings)
           set(dartclient_error "Warnings for ${superbuild_target}: ${num_warnings}")
         endif()
         
         # runs only tests that have a LABELS property matching "SuperBuild"
         ctest_test(
           BUILD "${CTEST_BINARY_DIRECTORY}"
           INCLUDE_LABEL "SuperBuild"
           PARALLEL_LEVEL 8
           EXCLUDE ${TEST_TO_EXCLUDE_REGEX}
           RETURN_VALUE res
           )
         
         ctest_submit(PARTS Test)
         
         if(NOT dartclient_error AND res)
           set(dartclient_error "Test failures for ${superbuild_target} (code ${res})")
         endif()
       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
         set(CTEST_BUILD_TARGET "${external_project}")
         ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND
           RETURN_VALUE res
           NUMBER_ERRORS num_errors
           NUMBER_WARNINGS num_warnings)
         ctest_submit(PARTS Build)
         
         if(NOT dartclient_error AND res)
           set(dartclient_error "Build error for ${external_project} (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}")
         elseif(NOT dartclient_error AND num_warnings)
           set(dartclient_error "Warnings for ${external_project}: ${num_warnings}")
         endif()
         
         # 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}"
         ctest_test(
           BUILD "${CTEST_BINARY_DIRECTORY}/${external_project_build_dir}"
           APPEND
           INCLUDE_LABEL "${external_project}"
           PARALLEL_LEVEL 8
           EXCLUDE ${TEST_TO_EXCLUDE_REGEX}
           RETURN_VALUE res
           )
         
         ctest_submit(PARTS Test)
         
         if(NOT dartclient_error AND res)
           set(dartclient_error "Test failures for ${external_project} (code ${res})")
         endif()
 
         # Coverage per external project
         if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND)
           message("----------- [ Coverage ${external_project} ] -----------")
           ctest_coverage(BUILD "${CTEST_BINARY_DIRECTORY}/${external_project_build_dir}" LABELS "${external_project}")
           ctest_submit(PARTS Coverage)
         endif ()
 
         #if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND)
         #  ctest_memcheck(BUILD "${build_dir}" INCLUDE_LABEL "${subproject}")
         #  ctest_submit(PARTS MemCheck)
         #endif ()
         
         # restore old coverage dirs
         file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${old_coverage_dirs}")
       
       endforeach()
       
       message("----------- [ Finish SuperBuild ] -----------")
     else()
        message("----------- [ Build SuperBuild ] -----------")
     endif()
     
     # build everything at superbuild level which has not yet been built
     set(CTEST_BUILD_TARGET)
     ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND
       RETURN_VALUE res
       NUMBER_ERRORS num_errors
       NUMBER_WARNINGS num_warnings)
       
     ctest_submit(PARTS Build)
     
     if(NOT dartclient_error AND res)
       set(dartclient_error "Build error for SuperBuild (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}")
     elseif(NOT dartclient_error AND num_warnings)
       set(dartclient_error "Warnings for SuperBuild: ${num_warnings}")
     endif()
     
     # runs only tests that have a LABELS property matching "SuperBuild" 
     ctest_test(
       BUILD "${CTEST_BINARY_DIRECTORY}" 
       INCLUDE_LABEL "SuperBuild"
       PARALLEL_LEVEL 8
       EXCLUDE ${TEST_TO_EXCLUDE_REGEX}
       RETURN_VALUE res
       )
     
     ctest_submit(PARTS Test)
     
     if(NOT dartclient_error AND res)
       set(dartclient_error "Test failures for SuperBuild (code ${res})")
     endif()
     
     set(build_dir "${CTEST_BINARY_DIRECTORY}/${PROJECT_BUILD_DIR}")
     
     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(NOT dartclient_error AND res)
       set(dartclient_error "Configure error in ${build_dir} (code ${res})")
     endif()
     
     foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
       set_property(GLOBAL PROPERTY SubProject ${subproject})
       set_property(GLOBAL PROPERTY Label ${subproject})
       message("----------- [ Build ${subproject} ] -----------")
      
       # Build target
       set(CTEST_BUILD_TARGET "${subproject}")
       ctest_build(BUILD "${build_dir}" APPEND
         RETURN_VALUE res
         NUMBER_ERRORS num_errors
         NUMBER_WARNINGS num_warnings)
       ctest_submit(PARTS Build)
       
       if(NOT dartclient_error AND res)
         set(dartclient_error "Build error for ${subproject} (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}")
       elseif(NOT dartclient_error AND num_warnings)
         set(dartclient_error "Warnings for ${subproject}: ${num_warnings}")
       endif()
     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 "${build_dir}" APPEND
       RETURN_VALUE res
       NUMBER_ERRORS num_errors
       NUMBER_WARNINGS num_warnings)
     ctest_submit(PARTS Build)
   
     if(NOT dartclient_error AND res)
       set(dartclient_error "Build error (code ${res}): Warnings ${num_warnings}, Errors ${num_errors}")
     elseif(NOT dartclient_error AND num_warnings)
       set(dartclient_error "Warnings: ${num_warnings}")
     endif()
     
     # 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}"
       ctest_test(
         BUILD "${build_dir}"
         APPEND
         INCLUDE_LABEL "${subproject}"
         PARALLEL_LEVEL 8
         EXCLUDE ${TEST_TO_EXCLUDE_REGEX}
         RETURN_VALUE res
         )
       
       ctest_submit(PARTS Test)
       
       if(NOT dartclient_error AND res)
         set(dartclient_error "Test failures for ${subproject} (code ${res})")
       endif()
 
       # Coverage per sub-project
       if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND)
         message("----------- [ Coverage ${subproject} ] -----------")
         ctest_coverage(BUILD "${build_dir}" LABELS "${subproject}")
         ctest_submit(PARTS Coverage)
       endif ()
 
       #if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND)
       #  ctest_memcheck(BUILD "${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 "${build_dir}" APPEND)
       ctest_submit(PARTS Build)
       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)
   
   endif()
   
   # Clear the CTEST_CHECKOUT_COMMAND variable to prevent continuous clients
   # to try to checkout again
   set(CTEST_CHECKOUT_COMMAND "")
   
   if(dartclient_error)
     file(WRITE ${DARTCLIENT_ERROR_FILE} "${dartclient_error}")
   else()
     file(REMOVE ${DARTCLIENT_ERROR_FILE})
   endif()
 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/CMake/MITKDashboardScript.TEMPLATE.cmake b/CMake/MITKDashboardScript.TEMPLATE.cmake
index be80308e4e..b2ae9abf29 100644
--- a/CMake/MITKDashboardScript.TEMPLATE.cmake
+++ b/CMake/MITKDashboardScript.TEMPLATE.cmake
@@ -1,167 +1,118 @@
 #
 # OS: Ubuntu 9.04 2.6.28-18-generic
 # Hardware: x86_64 GNU/Linux
 # GPU: NA
 #
 
 # Note: The specific version and processor type of this machine should be reported in the 
 # header above. Indeed, this file will be send to the dashboard as a NOTE file. 
 
 cmake_minimum_required(VERSION 2.8.2)
 
 #
 # Dashboard properties
 #
 
 set(MY_COMPILER "g++4.4.5")
 # For Windows, e.g.
 #set(MY_COMPILER "VC9.0")
 
 set(CTEST_CMAKE_COMMAND "/usr/bin/cmake")
 set(CTEST_CMAKE_GENERATOR "Unix Makefiles")
 set(CTEST_DASHBOARD_ROOT "/opt/dartclients")
 # For Windows, e.g.
 #set(CTEST_CMAKE_COMMAND "cmake")
 #set(CTEST_CMAKE_GENERATOR "Visual Studio 9 2008 Win64")
 #set(CTEST_DASHBOARD_ROOT "C:/dartclients")
 
 # The directory containing the Qt binaries
 set(QT_BINARY_DIR "/usr/bin/")
 # For Windows, e.g.
 #set(QT_BINARY_DIR "V:/windows/x64/QT-4.7.0_VC9.0_Bin/bin")
 
 #
 # Dashboard options
 #
 set(WITH_KWSTYLE FALSE)
 set(WITH_MEMCHECK FALSE)
 set(WITH_COVERAGE FALSE)
 set(WITH_DOCUMENTATION FALSE)
 #set(DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY ) # for example: $ENV{HOME}/Projects/Doxygen
 set(CTEST_BUILD_CONFIGURATION "Release")
 set(CTEST_TEST_TIMEOUT 500)
 if(UNIX OR MINGW)
   set(CTEST_BUILD_FLAGS "-j4") # Use multiple CPU cores to build
 else()
   set(CTEST_BUILD_FLAGS "")
 endif()
 
 # experimental: 
 #     - run_ctest() macro will be called *ONE* time
 #     - binary directory will *NOT* be cleaned
 # continuous: 
 #     - run_ctest() macro will be called EVERY 5 minutes ... 
 #     - binary directory will *NOT* be cleaned
 #     - configure/build will be executed *ONLY* if the repository has been updated
 # nightly: 
 #     - run_ctest() macro will be called *ONE* time
 #     - binary directory *WILL BE* cleaned
 set(SCRIPT_MODE "experimental") # "experimental", "continuous", "nightly"
 
 #
 # Project specific properties
 #
 set(CTEST_SOURCE_DIRECTORY "${CTEST_DASHBOARD_ROOT}/MITK")
 set(CTEST_BINARY_DIRECTORY "${CTEST_DASHBOARD_ROOT}/MITK-Superbuild-${CTEST_BUILD_CONFIGURATION}-${SCRIPT_MODE}")
 
 set(ADDITIONNAL_CMAKECACHE_OPTION "
 MITK_USE_Boost:BOOL=ON
 ")
 
 # List of test that should be explicitly disabled on this machine
 set(TEST_TO_EXCLUDE_REGEX "")
 
 # set any extra environment variables here
 set(ENV{DISPLAY} ":0")
 
 find_program(CTEST_COVERAGE_COMMAND NAMES gcov)
 find_program(CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
 find_program(CTEST_GIT_COMMAND NAMES git)
 
 #
 # Git repository - Overwrite the default value provided by the driver script
 #
 # The git repository containing MITK code
 #set(GIT_REPOSITORY "/home/username/MITK")
 # The branch of the MITK git repository to check out
 #set(GIT_BRANCH "bug-xxx-label")
 
 ##########################################
 # WARNING: DO NOT EDIT BEYOND THIS POINT #
 ##########################################
 
-set(CTEST_NOTES_FILES "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-
-#
-# Automatically determined properties
-#
-set(MY_OPERATING_SYSTEM "${CMAKE_HOST_SYSTEM}") # Windows 7, Linux-2.6.32, Darwin... 
-site_name(CTEST_SITE)
-
-if(QT_BINARY_DIR)
-  set(QT_QMAKE_EXECUTABLE "${QT_BINARY_DIR}/qmake")
-else()
-  set(QT_QMAKE_EXECUTABLE "qmake")
-endif()
-
-execute_process(COMMAND ${QT_QMAKE_EXECUTABLE} --version
-                OUTPUT_VARIABLE MY_QT_VERSION
-                RESULT_VARIABLE qmake_error)
-if(qmake_error)
-  message(FATAL_ERROR "Error when executing ${QT_QMAKE_EXECUTABLE} --version\n${qmake_error}")
-endif()
-
-string(REGEX REPLACE ".*Qt version ([0-9.]+) .*" "\\1" MY_QT_VERSION ${MY_QT_VERSION})
-
-#
-# Project specific properties
-#
-set(CTEST_BUILD_NAME "${MY_OPERATING_SYSTEM}-${MY_COMPILER}-Qt-${MY_QT_VERSION}-${CTEST_BUILD_CONFIGURATION}")
-set(PROJECT_BUILD_DIR "MITK-build")
-
-set(CTEST_PATH "$ENV{PATH}")
-if(WIN32)
-  set(VTK_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/VTK-build/bin/${CTEST_BUILD_CONFIGURATION}")
-  set(ITK_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/ITK-build/bin/${CTEST_BUILD_CONFIGURATION}")
-  set(GDCM_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/GDCM-build/bin/${CTEST_BUILD_CONFIGURATION}")
-  set(BLUEBERRY_OSGI_DIR "${CTEST_BINARY_DIRECTORY}/MITK-build/bin/BlueBerry/org.blueberry.osgi/bin/${CTEST_BUILD_CONFIGURATION}")
-  set(CTEST_PATH "${CTEST_PATH};${QT_BINARY_DIR};${VTK_BINARY_DIR};${ITK_BINARY_DIR};${GDCM_BINARY_DIR};${BLUEBERRY_OSGI_DIR}")
-endif()
-set(ENV{PATH} "${CTEST_PATH}")
-
-set(SUPERBUILD_TARGETS "")
-
-#
-# Display build info
-#
-message("Site name: ${CTEST_SITE}")
-message("Build name: ${CTEST_BUILD_NAME}")
-message("Script Mode: ${SCRIPT_MODE}")
-message("Coverage: ${WITH_COVERAGE}, MemCheck: ${WITH_MEMCHECK}")
-
 #
 # 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()
+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()
 
 #
-# Download and include dashboard driver script 
+# Download and include setup script
 #
 if(NOT DEFINED GIT_BRANCH OR GIT_BRANCH STREQUAL "")
   set(hb "HEAD")
 else()
   set(hb "refs/heads/${GIT_BRANCH}")
 endif()
-set(url "http://mbits/git/?p=MITK.git;a=blob_plain;f=CMake/MITKDashboardDriverScript.cmake;hb=${hb}")
-set(dest ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}.driver)
+set(url "http://mbits/git/?p=MITK.git;a=blob_plain;f=CMake/MITKDashboardSetup.cmake;hb=${hb}")
+set(dest ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}_setup.cmake)
 downloadFile("${url}" "${dest}")
-INCLUDE(${dest})
+include(${dest})
 
 
diff --git a/CMake/MITKDashboardSetup.cmake b/CMake/MITKDashboardSetup.cmake
new file mode 100644
index 0000000000..61f435159e
--- /dev/null
+++ b/CMake/MITKDashboardSetup.cmake
@@ -0,0 +1,73 @@
+# This file is intended to be included at the end of a custom MITKDashboardScript.TEMPLATE.cmake file
+
+list(APPEND CTEST_NOTES_FILES "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
+
+#
+# Automatically determined properties
+#
+set(MY_OPERATING_SYSTEM "${CMAKE_HOST_SYSTEM}") # Windows 7, Linux-2.6.32, Darwin... 
+site_name(CTEST_SITE)
+
+if(QT_BINARY_DIR)
+  set(QT_QMAKE_EXECUTABLE "${QT_BINARY_DIR}/qmake")
+else()
+  set(QT_QMAKE_EXECUTABLE "qmake")
+endif()
+
+execute_process(COMMAND ${QT_QMAKE_EXECUTABLE} --version
+                OUTPUT_VARIABLE MY_QT_VERSION
+                RESULT_VARIABLE qmake_error)
+if(qmake_error)
+  message(FATAL_ERROR "Error when executing ${QT_QMAKE_EXECUTABLE} --version\n${qmake_error}")
+endif()
+
+string(REGEX REPLACE ".*Qt version ([0-9.]+) .*" "\\1" MY_QT_VERSION ${MY_QT_VERSION})
+
+#
+# Project specific properties
+#
+if(NOT CTEST_BUILD_NAME)
+  set(CTEST_BUILD_NAME "${MY_OPERATING_SYSTEM}-${MY_COMPILER}-Qt-${MY_QT_VERSION}-${CTEST_BUILD_CONFIGURATION}")
+endif()
+set(PROJECT_BUILD_DIR "MITK-build")
+
+set(CTEST_PATH "$ENV{PATH}")
+if(WIN32)
+  set(VTK_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/VTK-build/bin/${CTEST_BUILD_CONFIGURATION}")
+  set(ITK_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/ITK-build/bin/${CTEST_BUILD_CONFIGURATION}")
+  set(GDCM_BINARY_DIR "${CTEST_BINARY_DIRECTORY}/GDCM-build/bin/${CTEST_BUILD_CONFIGURATION}")
+  set(BLUEBERRY_OSGI_DIR "${CTEST_BINARY_DIRECTORY}/MITK-build/bin/BlueBerry/org.blueberry.osgi/bin/${CTEST_BUILD_CONFIGURATION}")
+  set(CTEST_PATH "${CTEST_PATH};${QT_BINARY_DIR};${VTK_BINARY_DIR};${ITK_BINARY_DIR};${GDCM_BINARY_DIR};${BLUEBERRY_OSGI_DIR}")
+endif()
+set(ENV{PATH} "${CTEST_PATH}")
+
+set(SUPERBUILD_TARGETS "")
+
+# 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 "http://mbits/git/MITK.git")
+endif()
+
+#
+# Display build info
+#
+message("Site name: ${CTEST_SITE}")
+message("Build name: ${CTEST_BUILD_NAME}")
+message("Script Mode: ${SCRIPT_MODE}")
+message("Coverage: ${WITH_COVERAGE}, MemCheck: ${WITH_MEMCHECK}")
+
+
+#
+# Download and include dashboard driver script 
+#
+if(NOT DEFINED GIT_BRANCH OR GIT_BRANCH STREQUAL "")
+  set(hb "HEAD")
+else()
+  set(hb "refs/heads/${GIT_BRANCH}")
+endif()
+set(url "http://mbits/git/?p=MITK.git;a=blob_plain;f=CMake/MITKDashboardDriverScript.cmake;hb=${hb}")
+set(dest ${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}.driver)
+downloadFile("${url}" "${dest}")
+include(${dest})
+
+