diff --git a/Applications/CoreApp/startCoreApp.bat.in b/Applications/CoreApp/startCoreApp.bat.in
index 360ec3e3f7..67f373f6c8 100644
--- a/Applications/CoreApp/startCoreApp.bat.in
+++ b/Applications/CoreApp/startCoreApp.bat.in
@@ -1,2 +1,2 @@
-PATH=@CTK_RUNTIME_LIBRARY_DIRS@\@COREAPP_BUILD_TYPE@;@VTK_LIBRARY_DIRS@\@COREAPP_BUILD_TYPE@;@ITK_LIBRARY_DIRS@\@COREAPP_BUILD_TYPE@;@GDCM_BIN_DIR@;@QT_LIBRARY_DIR@\..\bin;@CMAKE_RUNTIME_OUTPUT_DIRECTORY@\plugins\@COREAPP_BUILD_TYPE@
+PATH=@MITK_RUNTIME_PATH@;%PATH%
 @COREAPP_BUILD_TYPE@\CoreApp.exe
diff --git a/Applications/ExtApp/startExtApp.bat.in b/Applications/ExtApp/startExtApp.bat.in
index a2c8118b9f..3cb5835ce4 100644
--- a/Applications/ExtApp/startExtApp.bat.in
+++ b/Applications/ExtApp/startExtApp.bat.in
@@ -1,2 +1,2 @@
-PATH=@CTK_RUNTIME_LIBRARY_DIRS@\@EXTAPP_BUILD_TYPE@;@VTK_LIBRARY_DIRS@\@EXTAPP_BUILD_TYPE@;@ITK_LIBRARY_DIRS@\@EXTAPP_BUILD_TYPE@;@GDCM_BIN_DIR@;@OpenCV_BIN_DIR@;@QT_LIBRARY_DIR@\..\bin;@CMAKE_RUNTIME_OUTPUT_DIRECTORY@\plugins\@EXTAPP_BUILD_TYPE@
+PATH=@MITK_RUNTIME_PATH@;%PATH%
 @EXTAPP_BUILD_TYPE@\ExtApp.exe
diff --git a/BlueBerry/Build/BundleGenerator/CMakeLists.txt b/BlueBerry/Build/BundleGenerator/CMakeLists.txt
index 4d8ece7c7a..221ca83f1c 100644
--- a/BlueBerry/Build/BundleGenerator/CMakeLists.txt
+++ b/BlueBerry/Build/BundleGenerator/CMakeLists.txt
@@ -1,302 +1,302 @@
 PROJECT(BlueBerryPluginGenerator)
 
 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 MARK_AS_ADVANCED(
 CMAKE_BACKWARDS_COMPATIBILITY CMAKE_INSTALL_PREFIX CMAKE_BUILD_TYPE)
 
 FIND_FILE(PLUGIN_TEMPLATE BundleTemplate
           ${PROJECT_SOURCE_DIR}/../../CMake
           DOC "Path to the plugin templates")
 
 IF(BUNDLE_DEFAULTS_FILE)
   IF(EXISTS "${BUNDLE_DEFAULTS_FILE}")
     INCLUDE(${BUNDLE_DEFAULTS_FILE})
   ELSE(EXISTS "${BUNDLE_DEFAULTS_FILE}")
     MESSAGE(SEND_ERROR "cannot find supplied defaults file: ${BUNDLE_DEFAULTS_FILE}")
   ENDIF(EXISTS "${BUNDLE_DEFAULTS_FILE}")
 ELSE(BUNDLE_DEFAULTS_FILE)
   INCLUDE(${PLUGIN_TEMPLATE}/BundleDefaults.cmake)
 ENDIF(BUNDLE_DEFAULTS_FILE)
 
 SET(PLUGIN_ID "${DEFAULT_PLUGIN_ID}" CACHE STRING "unique plugin id (i.e. your.domain.pluginid) (required)")
 SET(PLUGIN_NAME "" CACHE STRING "a human-readable description of your plugin (required)")
 SET(CUSTOM_PROJECT_NAME "" CACHE STRING "Your project name (optional)")
 OPTION(GUI_SUPPORT "enable this if your plugin contributes to the UI" ON)
 
 STRING(REPLACE " " "" CUSTOM_PROJECT_NAME_NOWS "${CUSTOM_PROJECT_NAME}")
 SET(CUSTOM_PROJECT_NAME "${CUSTOM_PROJECT_NAME_NOWS}" CACHE STRING "Your project name (optional)" FORCE)
 
 
 IF(PLUGIN_ID AND PLUGIN_NAME)
 
 SET(PLUGIN_VERSION "${DEFAULT_PLUGIN_VERSION}" CACHE STRING "plugin version (required)")
 SET(PLUGIN_VENDOR "${DEFAULT_PLUGIN_VENDOR}" CACHE STRING "plugin vendor (optional)")
 
 SET(ACTIVATOR_CLASS "" CACHE STRING "class name for your plugin activator (optional)")
 
 IF(GUI_SUPPORT)
 
   STRING(REGEX REPLACE "[^a-zA-Z_]" "" _view_baseid "${PLUGIN_NAME}")
   STRING(TOLOWER ${_view_baseid} _lview_baseid)
 
   SET(_default_view_class_name "${DEFAULT_VIEW_CLASS_BEGIN}${_view_baseid}View")
 
   SET(VIEW_NAME "${PLUGIN_NAME}" CACHE STRING "a human-readable name of your view (required)")
   SET(VIEW_CLASS "${_default_view_class_name}" CACHE STRING "class name of the view")
   IF(VIEW_CLASS)
     STRING(TOUPPER ${VIEW_CLASS} UVIEW_CLASS)
   ENDIF(VIEW_CLASS)
   SET(VIEW_BASE_CLASS ${DEFAULT_VIEW_BASE_CLASS} CACHE STRING "base class of your new view class (required)")
   SET(VIEW_BASE_CLASS_H ${DEFAULT_VIEW_BASE_CLASS_H} CACHE STRING "base class header (required)")
 
   SET(VIEW_ID "${DEFAULT_VIEW_BASEID}${_lview_baseid}" CACHE STRING "unique view id (i.e. your.domain.viewid) (required)")
 
   #SET(EDITOR_CLASS "" CACHE STRING "")
   #SET(EDITOR_TYPE "" CACHE STRING "")
 ENDIF(GUI_SUPPORT)
 
 #SET(GENERATE_SERVICE "" CACHE STRING "")
 #SET(GENERATE_SERVICE_CLASS "" CACHE STRING "")
 
 SET(_required_bundles ${DEFAULT_REQUIRED_BUNDLES})
 IF(GUI_SUPPORT)
   SET(_required_bundles ${DEFAULT_REQUIRED_BUNDLES_FOR_GUI})
 ENDIF(GUI_SUPPORT)
 SET(REQUIRED_PLUGINS ${_required_bundles} CACHE STRING "a semicolon-separated list of required plugins (optional)")
 
 IF(ACTIVATOR_CLASS)
   SET(FULLY_QUALIFIED_ACTIVATOR "${BUNDLE_NAMESPACE}::${ACTIVATOR_CLASS}")
     STRING(TOUPPER ${ACTIVATOR_CLASS} UACTIVATOR_CLASS)
     IF(GUI_SUPPORT)
       SET(ACTIVATOR_BASE_CLASS "berry::AbstractUIPlugin")
       SET(ACTIVATOR_BASE_CLASS_H "berryAbstractUIPlugin.h")
     ELSE()
       SET(ACTIVATOR_BASE_CLASS "berry::Plugin")
       SET(ACTIVATOR_BASE_CLASS_H "berryPlugin.h")
     ENDIF()
 ELSE(ACTIVATOR_CLASS)
   SET(FULLY_QUALIFIED_ACTIVATOR "")
 ENDIF(ACTIVATOR_CLASS)
 
 SET(PROJECT_DIR "${CMAKE_CURRENT_BINARY_DIR}/${CUSTOM_PROJECT_NAME}")
 IF(CUSTOM_PROJECT_NAME)
   SET(PLUGIN_DIR "${PROJECT_DIR}/Bundles/${PLUGIN_ID}")
 ELSE(CUSTOM_PROJECT_NAME)
   SET(PLUGIN_DIR "${PROJECT_DIR}/${PLUGIN_ID}")
 ENDIF(CUSTOM_PROJECT_NAME)
 
 IF(NOT EXISTS "${PLUGIN_TEMPLATE}/META-INF/MANIFEST_TEMPLATE.MF")
   MESSAGE(FATAL_ERROR "Could not find ${PLUGIN_TEMPLATE}/META-INF/MANIFEST_TEMPLATE.MF!")
 ENDIF(NOT EXISTS "${PLUGIN_TEMPLATE}/META-INF/MANIFEST_TEMPLATE.MF")
 
 # ====================== PROJECT FILES ===============================
 
 IF(CUSTOM_PROJECT_NAME AND EXISTS "${PLUGIN_TEMPLATE}/project/CMakeListsTemplate.txt")
 
     SET(CUSTOM_PROJECT_EXECUTABLE ${CUSTOM_PROJECT_NAME} CACHE STRING "the name of your project's executable")
 
     IF(GUI_SUPPORT)
       SET(FIND_PACKAGE_QT4 "FIND_PACKAGE(Qt4 REQUIRED)")
     ENDIF(GUI_SUPPORT)
 
     SET(BLUEBERRY_BINARY_DIR "@BLUEBERRY_BINARY_DIR@")
     SET(BLUEBERRY_PLUGINS_OUTPUT_DIR "@BLUEBERRY_PLUGINS_OUTPUT_DIR@")
     SET(PLUGIN_CACHE_DIR "@PLUGIN_CACHE_DIR@")
     SET(PLUGIN_BINARY_DIRS "@PLUGIN_BINARY_DIRS@")
     SET(MITK_PLUGIN_BINARY_DIRS "@MITK_PLUGIN_BINARY_DIRS@")
 
-    SET(BATCH_FILE_PATH "@CTK_RUNTIME_LIBRARY_DIRS@\\@APP_BUILD_TYPE@;@MITK_LIBRARY_DIRS_WITH_BUILD_TYPE@;@MITK_VTK_LIBRARY_DIRS@\\@APP_BUILD_TYPE@;@MITK_ITK_LIBRARY_DIRS@\\@APP_BUILD_TYPE@;@GDCM_BIN_DIR@;@OpenCV_BIN_DIR@;@QT_LIBRARY_DIR@\\..\\bin")
+    SET(BATCH_FILE_PATH "@MITK_RUNTIME_PATH@;@CMAKE_RUNTIME_OUTPUT_DIRECTORY@/@VS_BUILD_TYPE@")
     SET(BATCH_FILE_VS_PATH ${BATCH_FILE_PATH})
     SET(BATCH_FILE_EXEC_CMD "@APP_BUILD_TYPE@\\${CUSTOM_PROJECT_EXECUTABLE}.exe")
     SET(BATCH_FILE_VS_EXEC_CMD "\@PROJECT_BINARY_DIR\@/${CUSTOM_PROJECT_NAME}.sln")
 
     CONFIGURE_FILE("${PLUGIN_TEMPLATE}/project/CMakeListsTemplate.txt"
                    "${PROJECT_DIR}/CMakeLists.txt" @ONLY)
                    
     CONFIGURE_FILE("${PLUGIN_TEMPLATE}/project/Bundles/CMakeListsTemplate.txt"
                    "${PROJECT_DIR}/Bundles/CMakeLists.txt" @ONLY)
 
     CONFIGURE_FILE("${PLUGIN_TEMPLATE}/project/AppTemplate.cpp"
                    "${PROJECT_DIR}/${CUSTOM_PROJECT_EXECUTABLE}.cpp" @ONLY)
 
     CONFIGURE_FILE("${PLUGIN_TEMPLATE}/project/AppTemplate.ini"
                    "${PROJECT_DIR}/${CUSTOM_PROJECT_EXECUTABLE}.ini" COPYONLY)
 
     CONFIGURE_FILE("${PLUGIN_TEMPLATE}/project/startAppTemplate.bat"
                    "${PROJECT_DIR}/start${CUSTOM_PROJECT_EXECUTABLE}.bat.in" @ONLY)
                    
     CONFIGURE_FILE("${PLUGIN_TEMPLATE}/project/startVS2008Template.bat"
                    "${PROJECT_DIR}/startVS2008.bat.in" @ONLY)
 
 ENDIF()
 
 
 # ====================== END PROJECT FILES ===========================
 
 
 STRING(REPLACE . _ NormalizedPluginID ${PLUGIN_ID})
 STRING(TOUPPER ${NormalizedPluginID} UNormalizedPluginID)
 
 # ----- START cut plugin_ID from last '.' till end ------------
 SET(LAST_PART_PLUGIN_ID ${PLUGIN_ID})
 STRING(REGEX MATCH "\\.[^\\.]*$" LAST_PART_PLUGIN_ID ${LAST_PART_PLUGIN_ID})
 STRING(LENGTH ${LAST_PART_PLUGIN_ID} LengthStr)
 MATH(EXPR LengthStr "${LengthStr}-1")
 STRING(SUBSTRING ${LAST_PART_PLUGIN_ID} 1 ${LengthStr} LAST_PART_PLUGIN_ID)
 MATH(EXPR LengthStr "${LengthStr}-1")
 STRING(SUBSTRING ${LAST_PART_PLUGIN_ID} 0 1 LAST_PART_PLUGIN_ID_FIRST_LETTER)
 STRING(TOUPPER ${LAST_PART_PLUGIN_ID_FIRST_LETTER} LAST_PART_PLUGIN_ID_FIRST_LETTER)
 STRING(SUBSTRING ${LAST_PART_PLUGIN_ID} 1 ${LengthStr} LAST_PART_PLUGIN_ID_REST)
 SET(LAST_PART_PLUGIN_ID ${LAST_PART_PLUGIN_ID_FIRST_LETTER}${LAST_PART_PLUGIN_ID_REST})
 STRING(TOUPPER ${LAST_PART_PLUGIN_ID} ULAST_PART_PLUGIN_ID)
 # ------ END --------------------------------------------------
 
 
 # --------------------- META-INF/MANIFEST_TEMPLATE.MF ---------------------
 SET(REQUIRED_PLUGINS_MF "${REQUIRED_PLUGINS}")
 STRING(REPLACE ";" "," REQUIRED_PLUGINS_MF "${REQUIRED_PLUGINS_MF}" )
 CONFIGURE_FILE(${PLUGIN_TEMPLATE}/META-INF/MANIFEST_TEMPLATE.MF ${PLUGIN_DIR}/META-INF/MANIFEST.MF @ONLY)
 
 # ----------------- documentation/doxygen/modulesTemplate.dox ------------
 IF(DOXYGEN_INGROUP)
   SET(DOXYGEN_INGROUP_CMD "\\ingroup ${DOXYGEN_INGROUP}")
 ENDIF(DOXYGEN_INGROUP)
 CONFIGURE_FILE(${PLUGIN_TEMPLATE}/documentation/doxygen/modulesTemplate.dox
                ${PLUGIN_DIR}/documentation/doxygen/modules.dox @ONLY)
 
 # ----------------- documentation/Manual/Manual.dox ------------
 CONFIGURE_FILE(${PLUGIN_TEMPLATE}/documentation/Manual/Manual.dox
                ${PLUGIN_DIR}/documentation/Manual/Manual.dox @ONLY)
 CONFIGURE_FILE(${PLUGIN_TEMPLATE}/documentation/Manual/icon.png 
                ${PLUGIN_DIR}/documentation/Manual/icon.png @ONLY)
 
 # ----------------- resources directory ---------------------------------
 IF(GUI_SUPPORT)
   FILE(MAKE_DIRECTORY ${PLUGIN_DIR}/resources)
   IF(EXISTS ${PLUGIN_TEMPLATE}/resources/qtresources.qrc)
     CONFIGURE_FILE(${PLUGIN_TEMPLATE}/resources/qtresources.qrc ${PLUGIN_DIR}/resources/${VIEW_CLASS}.qrc @ONLY)
   ENDIF(EXISTS ${PLUGIN_TEMPLATE}/resources/qtresources.qrc)
 
   IF(EXISTS ${PLUGIN_TEMPLATE}/resources/icon.xpm)
     CONFIGURE_FILE(${PLUGIN_TEMPLATE}/resources/icon.xpm ${PLUGIN_DIR}/resources/icon.xpm @ONLY)
   ENDIF(EXISTS ${PLUGIN_TEMPLATE}/resources/icon.xpm)
 ENDIF()
 
 
 # -------------------- BundleDllTemplate.h -------------------------------
 IF(EXISTS ${PLUGIN_TEMPLATE}/src/BundleDllTemplate.h)
   IF(BUNDLE_NAMESPACE)
     STRING(TOUPPER ${BUNDLE_NAMESPACE} UBUNDLE_NAMESPACE)
   ENDIF(BUNDLE_NAMESPACE)
   IF(UBUNDLE_NAMESPACE)
     SET(DLL_DEFINE "${UBUNDLE_NAMESPACE}_${ULAST_PART_PLUGIN_ID}_EXPORT")
   ELSE(UBUNDLE_NAMESPACE)
     SET(DLL_DEFINE "${ULAST_PART_PLUGIN_ID}_EXPORT")
   ENDIF(UBUNDLE_NAMESPACE)
 
 
   SET(Dll_HEADER ${BUNDLE_NAMESPACE}${LAST_PART_PLUGIN_ID}Dll.h)
   CONFIGURE_FILE(${PLUGIN_TEMPLATE}/src/BundleDllTemplate.h ${PLUGIN_DIR}/src/${Dll_HEADER} @ONLY)
 ENDIF(EXISTS ${PLUGIN_TEMPLATE}/src/BundleDllTemplate.h)
 
 
 # --------------------- src/internal/ViewTemplateControls.ui ----------------------------
 IF (GUI_SUPPORT)
   IF(EXISTS ${PLUGIN_TEMPLATE}/src/internal/ControlsTemplate.ui)
     SET(VIEW_CONTROLS "${VIEW_CLASS}Controls")
     SET(VIEW_CONTROLS_UI "${VIEW_CONTROLS}.ui")
     SET(VIEW_CONTROLS_FILE "ui_${VIEW_CONTROLS}.h")
     SET(VIEW_CONTROLS_CLASS "${VIEW_CONTROLS}")
 
     CONFIGURE_FILE(${PLUGIN_TEMPLATE}/src/internal/ControlsTemplate.ui ${PLUGIN_DIR}/src/internal/${VIEW_CONTROLS_UI} @ONLY)
   ENDIF(EXISTS ${PLUGIN_TEMPLATE}/src/internal/ControlsTemplate.ui)
 ENDIF()
 
 # --------------------- src/internal/ViewTemplate[.h,.cpp] ----------------------------
 IF(VIEW_CLASS)
   SET(VIEW_CLASS_H "${BUNDLE_NAMESPACE}${VIEW_CLASS}.h")
   SET(VIEW_CLASS_CPP "${BUNDLE_NAMESPACE}${VIEW_CLASS}.cpp")
 
   IF(BUNDLE_NAMESPACE)
     SET(BEGIN_NAMESPACE "namespace ${BUNDLE_NAMESPACE} {")
     SET(END_NAMESPACE "} //namespace ${BUNDLE_NAMESPACE}")
   ENDIF(BUNDLE_NAMESPACE)
   CONFIGURE_FILE(${PLUGIN_TEMPLATE}/src/internal/ViewTemplate.h ${PLUGIN_DIR}/src/internal/${VIEW_CLASS_H} @ONLY)
   CONFIGURE_FILE(${PLUGIN_TEMPLATE}/src/internal/ViewTemplate.cpp ${PLUGIN_DIR}/src/internal/${VIEW_CLASS_CPP} @ONLY)
 ENDIF(VIEW_CLASS)
 
 # ---------------------- pluginTemplate.xml ---------------------------------
 IF(VIEW_CLASS)
   SET(XP_VIEW "  <extension point=\"org.blueberry.ui.views\">
     <view id=\"${VIEW_ID}\"
           name=\"${VIEW_NAME}\"
           class=\"${BUNDLE_NAMESPACE}::${VIEW_CLASS}\" 
           icon=\"resources/icon.xpm\" />
   </extension>"
 )
 ENDIF(VIEW_CLASS)
 CONFIGURE_FILE(${PLUGIN_TEMPLATE}/pluginTemplate.xml ${PLUGIN_DIR}/plugin.xml @ONLY)
 
 # ----------------------- ActivatorTemplate[.h,.cpp] ------------------------
 IF(ACTIVATOR_CLASS)
   SET(ACTIVATOR_CLASS_H "${BUNDLE_NAMESPACE}${ACTIVATOR_CLASS}.h")
   SET(ACTIVATOR_CLASS_CPP "${BUNDLE_NAMESPACE}${ACTIVATOR_CLASS}.cpp")
   
   IF(BUNDLE_NAMESPACE)
     SET(BEGIN_NAMESPACE "namespace ${BUNDLE_NAMESPACE} {")
     SET(END_NAMESPACE "} //namespace ${BUNDLE_NAMESPACE}")
   ENDIF(BUNDLE_NAMESPACE)
   CONFIGURE_FILE(${PLUGIN_TEMPLATE}/src/internal/ActivatorTemplate.h ${PLUGIN_DIR}/src/internal/${ACTIVATOR_CLASS_H} @ONLY)
   CONFIGURE_FILE(${PLUGIN_TEMPLATE}/src/internal/ActivatorTemplate.cpp ${PLUGIN_DIR}/src/internal/${ACTIVATOR_CLASS_CPP} @ONLY)
 ENDIF()
 
 # ----------------------- manifestTemplate.cpp ----------------------------
 IF(VIEW_CLASS)
   SET(SET_MANIFEST_SRC "SET(CPP_FILES manifest.cpp)")
   SET(MANIFEST_VIEW_ENTRY "#include \"src/internal/${VIEW_CLASS_H}\"
 
 POCO_BEGIN_NAMED_MANIFEST(berryIViewPart, berry::IViewPart)
   POCO_EXPORT_CLASS(${BUNDLE_NAMESPACE}::${VIEW_CLASS})
 POCO_END_MANIFEST")
 ENDIF(VIEW_CLASS)
 
 IF(ACTIVATOR_CLASS)
   SET(SET_MANIFEST_SRC "SET(CPP_FILES manifest.cpp)")
   SET(MANIFEST_ACTIVATOR_ENTRY "#include \"src/internal/${ACTIVATOR_CLASS_H}\"
 
 POCO_BEGIN_MANIFEST(berry::IBundleActivator)
   POCO_EXPORT_CLASS(${BUNDLE_NAMESPACE}::${ACTIVATOR_CLASS})
 POCO_END_MANIFEST")
 ENDIF()
 
 IF(VIEW_CLASS OR ACTIVATOR_CLASS)
   CONFIGURE_FILE(${PLUGIN_TEMPLATE}/manifestTemplate.cpp ${PLUGIN_DIR}/manifest.cpp @ONLY)
 ENDIF()
 
 # ---------------------- CMakeListsTemplate.txt -----------------------------
 SET(CREATE_PLUGIN_MACRO "${DEFAULT_CREATE_PLUGIN_MACRO}")
 IF(GUI_SUPPORT)
   SET(CREATE_PLUGIN_MACRO "${DEFAULT_CREATE_GUI_PLUGIN_MACRO}")
 ENDIF(GUI_SUPPORT)
 
 CONFIGURE_FILE(${PLUGIN_TEMPLATE}/CMakeListsTemplate.txt ${PLUGIN_DIR}/CMakeLists.txt @ONLY)
 
 # ---------------------- filesTemplate.cmake ------------------------------
 SET(PLUGIN_SOURCES "")
 SET(PLUGIN_INTERNAL_SOURCES "")
 IF(VIEW_CLASS)
   SET(PLUGIN_INTERNAL_SOURCES "${PLUGIN_INTERNAL_SOURCES}${VIEW_CLASS_CPP}\n")
 ENDIF(VIEW_CLASS)
 IF(ACTIVATOR_CLASS)
   SET(PLUGIN_INTERNAL_SOURCES "${PLUGIN_INTERNAL_SOURCES}${ACTIVATOR_CLASS_CPP}\n")
 ENDIF(ACTIVATOR_CLASS)
 IF(GUI_SUPPORT AND EXISTS ${PLUGIN_TEMPLATE}/src/internal/ControlsTemplate.ui)
   SET(PLUGIN_RESOURCE_FILES "resources/icon.xpm")
   SET(PLUGIN_RES_FILES "resources/${VIEW_CLASS}.qrc")
   SET(PLUGIN_UI_FILES "src/internal/${VIEW_CONTROLS_UI}")
   SET(PLUGIN_MOC_H_FILES "src/internal/${VIEW_CLASS}.h")
 ENDIF()
 
 CONFIGURE_FILE(${PLUGIN_TEMPLATE}/filesTemplate.cmake ${PLUGIN_DIR}/files.cmake @ONLY)
 
 ENDIF(PLUGIN_ID AND PLUGIN_NAME)
diff --git a/CMake/StartVS.bat.in b/CMake/StartVS.bat.in
new file mode 100644
index 0000000000..917ba96dfe
--- /dev/null
+++ b/CMake/StartVS.bat.in
@@ -0,0 +1,6 @@
+@set CL=/D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE
+@set LINK=/LARGEADDRESSAWARE
+
+PATH=@MITK_RUNTIME_PATH@;%PATH%
+"@VS_SOLUTION_FILE@"
+
diff --git a/CMake/mitkFunctionCreateWindowsBatchScript.cmake b/CMake/mitkFunctionCreateWindowsBatchScript.cmake
index 4adf776e33..e6cd16f279 100644
--- a/CMake/mitkFunctionCreateWindowsBatchScript.cmake
+++ b/CMake/mitkFunctionCreateWindowsBatchScript.cmake
@@ -1,22 +1,25 @@
 function(mitkFunctionCreateWindowsBatchScript in out build_type)
   if(GDCM_DIR)
     set(GDCM_BIN_DIR "${GDCM_DIR}/bin/${build_type}")
   else()
     set(GDCM_BIN_DIR)
   endif()
   
   if(OpenCV_DIR)
     set(OpenCV_BIN_DIR "${OpenCV_DIR}/bin/${build_type}")
   else()
     set(OpenCV_BIN_DIR)
   endif()
   
   set(MITK_LIBRARY_DIRS_WITH_BUILD_TYPE)
   if(MITK_LIBRARY_DIRS)
     foreach(lib_dir ${MITK_LIBRARY_DIRS})
       list(APPEND MITK_LIBRARY_DIRS_WITH_BUILD_TYPE "${lib_dir}/${build_type}")
     endforeach()
   endif()
   
+  set(VS_BUILD_TYPE ${build_type})
   configure_file(${in} ${out} @ONLY)
+  # substitute again
+  configure_file(${out} ${out} @ONLY)
 endfunction()
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b117d32e3f..6efefe8e65 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,571 +1,607 @@
 cmake_minimum_required(VERSION 2.8.2)
 
 #-----------------------------------------------------------------------------
 # Superbuild Option - Enabled by default
 #-----------------------------------------------------------------------------
 
 option(MITK_USE_SUPERBUILD "Build MITK and the projects it depends on via SuperBuild.cmake." ON)
 
 if(MITK_USE_SUPERBUILD)
   project(MITK-superbuild)
   set(MITK_SOURCE_DIR ${PROJECT_SOURCE_DIR})
   set(MITK_BINARY_DIR ${PROJECT_BINARY_DIR})
 else()
   project(MITK)
 endif()
 
 #-----------------------------------------------------------------------------
 # 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)
 
 #-----------------------------------------------------------------------------
 # 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("Creating directory MITK_CMAKE_${type}_OUTPUT_DIRECTORY: ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY}")
     file(MAKE_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_BLUEBERRY "Build the BlueBerry platform" ON)
 option(MITK_USE_CTK "Use CTK in MITK" ${MITK_USE_BLUEBERRY})
 option(MITK_USE_DCMTK "EXEPERIMENTAL, superbuild only: Use DCMTK in MITK" OFF)
 option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
   
 mark_as_advanced(MITK_INSTALL_RPATH_RELATIVE
                  MITK_BUILD_ALL_PLUGINS
                  MITK_USE_CTK
                  MITK_USE_DCMTK
                  )
                  
 # consistency checks
 if(MITK_USE_BLUEBERRY AND NOT MITK_USE_CTK)
   MESSAGE(FATAL_ERROR "BlueBerry depends on CTK. Please set MITK_USE_CTK to ON.")
 endif()
 
 #-----------------------------------------------------------------------------
 # 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)
 if(MITK_USE_BLUEBERRY)
   list(APPEND CTEST_PROJECT_SUBPROJECTS BlueBerry)
 endif()
 
 list(APPEND CTEST_PROJECT_SUBPROJECTS
   MITK-Core
   MITK-CoreUI
   MITK-IGT
   MITK-ToF
   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)
                
 if(CTEST_PROJECT_ADDITIONAL_TARGETS)
   # those targets will be executed at the end of the ctest driver script
   # and they also get their own subproject label
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS};${CTEST_PROJECT_ADDITIONAL_TARGETS}")
 else()
   set(subproject_list "${CTEST_PROJECT_SUBPROJECTS}")
 endif()
 
 # Generate Project.xml file expected by the CTest driver script
 mitkFunctionGenerateProjectXml(${MITK_BINARY_DIR} ${PROJECT_NAME} "${subproject_list}" ${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(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroGetLinuxDistribution)
 
 #-----------------------------------------------------------------------------
 # 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)
 
 #-----------------------------------------------------------------------------
 # Installation preparation
 #
 # These should be set before any MITK install macros are used
 #-----------------------------------------------------------------------------
 
 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 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 "${COVERAGE_C_FLAGS} ${ADDITIONAL_C_FLAGS}")
 set(MITK_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 <stdexcept>")
   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()
 endif()
 
 configure_file(mitkTestingConfig.h.in ${MITK_BINARY_DIR}/mitkTestingConfig.h)
 
 #-----------------------------------------------------------------------------
 # 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 "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}")
 set(CMAKE_C_FLAGS "${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})
   if(NOT TARGET ${subproject})
     add_custom_target(${subproject})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 link_directories(${MITK_LINK_DIRECTORIES})
 
 add_subdirectory(Core)
 
 if(MITK_USE_QT AND QT4_FOUND)
   add_subdirectory(CoreUI/Qmitk)
 endif()
 
 add_subdirectory(Modules)
 
 if(MITK_USE_BLUEBERRY)
 
   set(MITK_DEFAULT_SUBPROJECTS MITK-Plugins)
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/CoreUI/Bundles/PluginList.cmake")
   set(mitk_core_plugins_fullpath )
   foreach(core_plugin ${MITK_CORE_PLUGINS})
     list(APPEND mitk_core_plugins_fullpath CoreUI/Bundles/${core_plugin})
   endforeach()
 
   if(BUILD_TESTING)
     include(berryTestingHelpers)
 
     include("${CMAKE_CURRENT_SOURCE_DIR}/CoreUI/BundleTesting/PluginList.cmake")
     set(mitk_core_test_plugins_fullpath )
     foreach(core_test_plugin ${MITK_CORE_TEST_PLUGINS})
       list(APPEND mitk_core_test_plugins_fullpath CoreUI/BundleTesting/${core_test_plugin})
     endforeach()
 
     set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp")
     get_target_property(_is_macosx_bundle CoreApp MACOSX_BUNDLE)
     if(APPLE AND _is_macosx_bundle)
       set(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.app/Contents/MacOS/CoreApp")
     endif()
 
     set(BLUEBERRY_TEST_APP_ID "org.mitk.qt.application")
   endif()
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Modules/Bundles/PluginList.cmake")
   set(mitk_ext_plugins_fullpath )
   foreach(ext_plugin ${MITK_EXT_PLUGINS})
     list(APPEND mitk_ext_plugins_fullpath Modules/Bundles/${ext_plugin})
   endforeach()
 
   ctkMacroSetupExternalPlugins(${mitk_core_plugins_fullpath} ${mitk_core_test_plugins_fullpath} ${mitk_ext_plugins_fullpath}
                                BUILD_OPTION_PREFIX MITK_BUILD_
                                BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
                                COMPACT_OPTIONS)
 
   ctkFunctionExtractPluginTargets("${mitk_core_plugins_fullpath}" ON MITK_CORE_ENABLED_PLUGINS)
   ctkFunctionExtractPluginTargets("${mitk_ext_plugins_fullpath}" ON MITK_EXT_ENABLED_PLUGINS)
   list(APPEND MITK_EXT_ENABLED_PLUGINS ${MITK_CORE_ENABLED_PLUGINS})
 
   set(MITK_COREAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/CoreApp.provisioning")
   FunctionCreateProvisioningInfo(
     OUTPUT prov_info
     INCLUDE "${BLUEBERRY_PLUGIN_PROVISIONING_FILE}"
     PLUGIN_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins"
     PLUGINS ${mitk_core_plugins_fullpath}
   )
   file(WRITE "${MITK_COREAPP_PROVISIONING_FILE}" "${prov_info}")
 
   set(MITK_EXTAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ExtApp.provisioning")
   FunctionCreateProvisioningInfo(
     OUTPUT prov_info
     INCLUDE "${MITK_COREAPP_PROVISIONING_FILE}"
     PLUGIN_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins"
     PLUGINS ${mitk_ext_plugins_fullpath}
   )
   file(WRITE "${MITK_EXTAPP_PROVISIONING_FILE}" "${prov_info}")
 
   set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake")
   ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE})
 
   # Used in the export command further below
   GetMyTargetLibraries("${CTK_PLUGIN_LIBRARIES}" MITK_PLUGIN_TARGETS)
 
   # add legacy BlueBerry bundles
   add_subdirectory(Modules/Bundles)
 endif()
 
+# Construct a list of paths containing runtime directories
+# for MITK applications on Windows
+set(MITK_RUNTIME_PATH 
+    "${VTK_LIBRARY_DIRS}/@VS_BUILD_TYPE@;${ITK_LIBRARY_DIRS}/@VS_BUILD_TYPE@;${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/@VS_BUILD_TYPE@"
+    )
+if(QT4_FOUND)
+  set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${QT_LIBRARY_DIR}/../bin")
+endif()
+if(MITK_USE_BLUEBERRY)
+  set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${CTK_RUNTIME_LIBRARY_DIRS}/@VS_BUILD_TYPE@;${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins/@VS_BUILD_TYPE@")
+endif()
+if(GDCM_DIR)
+  set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${GDCM_DIR}/bin/@VS_BUILD_TYPE@")
+endif()
+if(OpenCV_DIR)
+  set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${OpenCV_DIR}/bin/@VS_BUILD_TYPE@")
+endif()
+# DCMTK is statically build
+#if(DCMTK_DIR)
+#  set(MITK_RUNTIME_PATH "${MITK_RUNTIME_PATH};${DCMTK_DIR}/bin/@VS_BUILD_TYPE@")
+#endif()
+
+# Add applications directory
 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
 #-----------------------------------------------------------------------------
 
 
 # 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
 #-----------------------------------------------------------------------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 if(MITK_USE_BLUEBERRY)
   set(enabled_plugins
     ${BLUEBERRY_PLUGIN_TARGETS}
     ${MITK_PLUGIN_TARGETS}
     ${MITK_MODULES_ENABLED_PLUGINS}
     )
 
   # This is for installation support of external projects depending on
   # MITK plugins. The export file should not be used for linking to MITK
   # libraries without using LINK_DIRECTORIES, since the exports are incomplete
   # yet(depending libraries are not exported).
   foreach(plugin ${enabled_plugins})
     string(REPLACE "." "_" plugin_target ${plugin})
     export(TARGETS ${plugin_target}
            APPEND
            FILE ${MITK_EXPORTS_FILE})
   endforeach()
 endif()
 
 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)
 
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 configure_file(MITKConfig.cmake.in ${MITK_BINARY_DIR}/MITKConfig.cmake @ONLY)
+
+# If we are under Windows, create two batch files which correctly
+# set up the environment for the application and for Visual Studio
+if(WIN32)
+  include(mitkFunctionCreateWindowsBatchScript)
+  
+  set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln")
+  foreach(VS_BUILD_TYPE debug release)
+    mitkFunctionCreateWindowsBatchScript("${MITK_SOURCE_DIR}/CMake/StartVS.bat.in"
+      ${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat
+      ${VS_BUILD_TYPE})
+  endforeach()
+endif(WIN32)
diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in
index 8c56c577ef..55201d4460 100644
--- a/MITKConfig.cmake.in
+++ b/MITKConfig.cmake.in
@@ -1,123 +1,125 @@
 
 # Update the CMake module path
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "@MITK_SOURCE_DIR@/CMake")
 
 # Include MITK macros
 include(MacroParseArguments)
 include(mitkFunctionOrganizeSources)
+include(mitkFunctionCreateWindowsBatchScript)
 include(mitkMacroCreateModuleConf)
 include(mitkMacroCreateModule)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 
 # The MITK version number
 SET(MITK_VERSION_MAJOR "@MITK_VERSION_MAJOR@")
 SET(MITK_VERSION_MINOR "@MITK_VERSION_MINOR@")
 SET(MITK_VERSION_PATCH "@MITK_VERSION_PATCH@")
 
 # MITK specific variables
 SET(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@")
 SET(UTILITIES_DIR "@UTILITIES_DIR@")
 SET(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@")
 SET(MITK_MODULES_CONF_DIR "@MITK_MODULES_CONF_DIR@")
 SET(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@")
 SET(MODULES_PACKAGE_DEPENDS_DIRS "@MODULES_PACKAGE_DEPENDS_DIRS@")
 SET(MITK_DOXYGEN_TAGFILE_NAME "@MITK_DOXYGEN_TAGFILE_NAME@")
 
 # Include directory variables
 SET(MITK_INCLUDE_DIRS "@MITK_INCLUDE_DIRS@")
 SET(QMITK_INCLUDE_DIRS "@QMITK_INCLUDE_DIRS@")
 SET(ANN_INCLUDE_DIR "@ANN_INCLUDE_DIR@")
 SET(IPSEGMENTATION_INCLUDE_DIR "@IPSEGMENTATION_INCLUDE_DIR@")
 SET(VECMATH_INCLUDE_DIR "@VECMATH_INCLUDE_DIR@")
 SET(IPFUNC_INCLUDE_DIR "@IPFUNC_INCLUDE_DIR@")
 SET(MITK_IGT_INCLUDE_DIRS "@MITK_IGT_INCLUDE_DIRS@")
 
 # Library variables
 SET(MITK_LIBRARIES "@MITK_LIBRARIES@")
 SET(QMITK_LIBRARIES "@QMITK_LIBRARIES@")
 
 # Link directory variables
 SET(MITK_LINK_DIRECTORIES "@MITK_LINK_DIRECTORIES@")
 SET(QMITK_LINK_DIRECTORIES "@QMITK_LINK_DIRECTORIES@")
 SET(MITK_LIBRARY_DIRS "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@" "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@/plugins")
 SET(MITK_VTK_LIBRARY_DIRS "@VTK_LIBRARY_DIRS@")
 SET(MITK_ITK_LIBRARY_DIRS "@ITK_LIBRARY_DIRS@")
 
 # External projects
 SET(ITK_DIR "@ITK_DIR@")
 SET(VTK_DIR "@VTK_DIR@")
 SET(DCMTK_DIR "@DCMTK_DIR@")
 SET(GDCM_DIR "@GDCM_DIR@")
 SET(BOOST_ROOT "@BOOST_ROOT@")
 SET(OpenCV_DIR "@OpenCV_DIR@")
 SET(MITK_QMAKE_EXECUTABLE "@QT_QMAKE_EXECUTABLE@")
 SET(MITK_INSTALL_RPATH_RELATIVE @MITK_INSTALL_RPATH_RELATIVE@)
 SET(MITK_DATA_DIR "@MITK_DATA_DIR@")
+SET(MITK_RUNTIME_PATH "@MITK_RUNTIME_PATH@")
 
 # MITK use variables
 SET(MITK_USE_QT @MITK_USE_QT@)
 SET(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@)
 SET(MITK_USE_Boost @MITK_USE_Boost@)
 SET(MITK_USE_CTK @MITK_USE_CTK@)
 SET(MITK_USE_DCMTK @MITK_USE_DCMTK@)
 SET(MITK_USE_OpenCV @MITK_USE_OpenCV@)
 
 # There is no PocoConfig.cmake, so we set Poco specific CMake variables
 # here. This way the call to FIND_PACKAGE(Poco) in BlueBerryConfig.cmake
 # finds the Poco distribution supplied by MITK
 SET(Poco_INCLUDE_DIR "@MITK_SOURCE_DIR@/Utilities/Poco")
 SET(Poco_LIBRARY_DIR "@MITK_BINARY_DIR@/bin")
 
 IF(MITK_USE_IGT)
   #INCLUDE(${MITK_DIR}/mitkIGTConfig.cmake)
 ENDIF()
 
 IF(NOT MITK_EXPORTS_FILE_INCLUDED)
   SET(MITK_EXPORTS_FILE_INCLUDED 1)
   INCLUDE("@MITK_EXPORTS_FILE@")
 ENDIF()
 
 # BlueBerry support
 IF(MITK_USE_BLUEBERRY)
 
   SET(BlueBerry_DIR "@MITK_BINARY_DIR@/BlueBerry")
 
   INCLUDE(mitkMacroCreatePlugin)
 
   IF(NOT MITK_SKIP_BUNDLELIST)
     IF(MITK_USE_EXT)
       INCLUDE("@MITK_BINARY_DIR@/Bundles/MITKModulesBundleList.cmake")
     ENDIF()
   ENDIF(NOT MITK_SKIP_BUNDLELIST)
   
   # Don't include the BlueBerry exports file, since the targets are
   # also exported in the MITK exports file
   SET(BB_PLUGIN_EXPORTS_FILE_INCLUDED 1)
   FIND_PACKAGE(BlueBerry)
 
   IF(NOT BlueBerry_FOUND)
     MESSAGE(SEND_ERROR "MITK does not seem to be configured with BlueBerry support. Set MITK_USE_BLUEBERRY to ON in your MITK build configuration.")
   ENDIF(NOT BlueBerry_FOUND)
 
   SET(MITK_PLUGIN_SOURCE_DIRS "@MITK_SOURCE_DIR@/Bundles")
   
   SET(MITK_PLUGIN_OUTPUT_DIRS )
   IF(MITK_USE_EXT)
     LIST(APPEND MITK_PLUGIN_OUTPUT_DIRS @MITK_MODULES_PLUGIN_OUTPUT_DIRS@)
   ENDIF()
 
   INCLUDE("@MITK_PLUGIN_USE_FILE@")
 
   #SET(CTK_PLUGIN_LIBRARIES ${CTK_PLUGIN_LIBRARIES} @MITK_PLUGIN_TARGETS@)
 
   SET(MITK_PLUGIN_PROVISIONING_FILE "@MITK_EXTAPP_PROVISIONING_FILE@")
 
 ENDIF(MITK_USE_BLUEBERRY)