diff --git a/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake b/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake
index a9373c97ee..b94443ee30 100644
--- a/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake
+++ b/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake
@@ -1,222 +1,225 @@
 #-----------------------------------------------------------------------------
 # MITK
 #-----------------------------------------------------------------------------
 
 set(MITK_DEPENDS)
 set(proj_DEPENDENCIES)
 set(proj MITK)
 
 if(NOT MITK_DIR)
 
   #-----------------------------------------------------------------------------
   # Create CMake options to customize the MITK build
   #-----------------------------------------------------------------------------
 
   option(MITK_USE_SUPERBUILD "Use superbuild for MITK" ON)
   option(MITK_USE_BLUEBERRY "Build the BlueBerry platform in MITK" ON)
   option(MITK_BUILD_EXAMPLES "Build the MITK examples" OFF)
   option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
   option(MITK_BUILD_TESTING "Build the MITK unit tests" OFF)
   option(MITK_USE_ACVD "Use Approximated Centroidal Voronoi Diagrams" OFF)
   option(MITK_USE_CTK "Use CTK in MITK" ${MITK_USE_BLUEBERRY})
   option(MITK_USE_DCMTK "Use DCMTK in MITK" ON)
   option(MITK_USE_QT "Use Nokia's Qt library in MITK" ON)
   option(MITK_USE_Boost "Use the Boost library in MITK" OFF)
   option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
   option(MITK_USE_SOFA "Use Simulation Open Framework Architecture" OFF)
   option(MITK_USE_Python "Enable Python wrapping in MITK" OFF)
 
   if(MITK_USE_BLUEBERRY AND NOT MITK_USE_CTK)
     message("Forcing MITK_USE_CTK to ON because of MITK_USE_BLUEBERRY")
     set(MITK_USE_CTK ON CACHE BOOL "Use CTK in MITK" FORCE)
   endif()
 
   if(MITK_USE_CTK AND NOT MITK_USE_QT)
     message("Forcing MITK_USE_QT to ON because of MITK_USE_CTK")
     set(MITK_USE_QT ON CACHE BOOL "Use Nokia's Qt library in MITK" FORCE)
   endif()
 
   set(MITK_USE_CableSwig ${MITK_USE_Python})
   set(MITK_USE_GDCM 1)
   set(MITK_USE_ITK 1)
   set(MITK_USE_VTK 1)
 
   mark_as_advanced(MITK_USE_SUPERBUILD
                    MITK_BUILD_ALL_PLUGINS
                    MITK_BUILD_TESTING
                    )
 
   set(mitk_cmake_boolean_args
     MITK_USE_SUPERBUILD
     MITK_USE_BLUEBERRY
     MITK_BUILD_EXAMPLES
     MITK_BUILD_ALL_PLUGINS
     MITK_USE_ACVD
     MITK_USE_CTK
     MITK_USE_DCMTK
     MITK_USE_QT
     MITK_USE_Boost
     MITK_USE_OpenCV
     MITK_USE_SOFA
     MITK_USE_Python
    )
 
   if(MITK_USE_Qt4)
     # Look for Qt at the superbuild level, to catch missing Qt libs early
     find_package(Qt4 4.7 REQUIRED)
   endif()
 
   set(additional_mitk_cmakevars )
 
   # Configure the set of default pixel types
   set(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
       "int, unsigned int, short, unsigned short, char, unsigned char"
       CACHE STRING "List of integral pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
   set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
       "double, float"
       CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
   set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
       ""
       CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros")
 
   set(MITK_ACCESSBYITK_DIMENSIONS
       "2,3"
       CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 
   foreach(_arg MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
                MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES MITK_ACCESSBYITK_DIMENSIONS)
     mark_as_advanced(${_arg})
     list(APPEND additional_mitk_cmakevars "-D${_arg}:STRING=${${_arg}}")
   endforeach()
 
   #-----------------------------------------------------------------------------
   # Create options to inject pre-build dependencies
   #-----------------------------------------------------------------------------
 
   foreach(proj CTK DCMTK GDCM VTK ACVD ITK OpenCV SOFA CableSwig)
     if(MITK_USE_${proj})
       set(MITK_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory")
       mark_as_advanced(MITK_${proj}_DIR)
       if(MITK_${proj}_DIR)
         list(APPEND additional_mitk_cmakevars "-D${proj}_DIR:PATH=${MITK_${proj}_DIR}")
       endif()
     endif()
   endforeach()
 
   if(MITK_USE_Boost)
     set(MITK_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory")
     mark_as_advanced(MITK_BOOST_ROOT)
     if(MITK_BOOST_ROOT)
       list(APPEND additional_mitk_cmakevars "-DBOOST_ROOT:PATH=${MITK_BOOST_ROOT}")
     endif()
   endif()
 
   set(MITK_SOURCE_DIR "" CACHE PATH "MITK source code location. If empty, MITK will be cloned from MITK_GIT_REPOSITORY")
   set(MITK_GIT_REPOSITORY "http://git.mitk.org/MITK.git" CACHE STRING "The git repository for cloning MITK")
   set(MITK_GIT_TAG "releases/master" CACHE STRING "The git tag/hash to be used when cloning from MITK_GIT_REPOSITORY")
   mark_as_advanced(MITK_SOURCE_DIR MITK_GIT_REPOSITORY MITK_GIT_TAG)
 
   #-----------------------------------------------------------------------------
   # Create the final variable containing superbuild boolean args
   #-----------------------------------------------------------------------------
 
   set(mitk_boolean_args)
   foreach(mitk_cmake_arg ${mitk_cmake_boolean_args})
     list(APPEND mitk_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
   endforeach()
 
   #-----------------------------------------------------------------------------
   # Additional MITK CMake variables
   #-----------------------------------------------------------------------------
 
   if(MITK_USE_Qt4 AND QT_QMAKE_EXECUTABLE)
     list(APPEND additional_mitk_cmakevars "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}")
+  elseif(MITK_USE_Qt5)
+    list(APPEND additional_mitk_cmakevars "-DDESIRED_QT_VERSION:STRING=5")
+    list(APPEND additional_mitk_cmakevars "-DCMAKE_PREFIX_PATH:PATH=${CMAKE_PREFIX_PATH}")
   endif()
 
   if(MITK_USE_CTK)
     list(APPEND additional_mitk_cmakevars "-DGIT_EXECUTABLE:FILEPATH=${GIT_EXECUTABLE}")
   endif()
 
   if(MITK_INITIAL_CACHE_FILE)
     list(APPEND additional_mitk_cmakevars "-DMITK_INITIAL_CACHE_FILE:INTERNAL=${MITK_INITIAL_CACHE_FILE}")
   endif()
 
   if(MITK_USE_SUPERBUILD)
     set(MITK_BINARY_DIR ${proj}-superbuild)
   else()
     set(MITK_BINARY_DIR ${proj}-build)
   endif()
 
   set(proj_DEPENDENCIES)
   set(MITK_DEPENDS ${proj})
 
   # Configure the MITK souce code location
 
   if(NOT MITK_SOURCE_DIR)
     set(mitk_source_location
         SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
         GIT_REPOSITORY ${MITK_GIT_REPOSITORY}
         GIT_TAG ${MITK_GIT_TAG}
         )
   else()
     set(mitk_source_location
         SOURCE_DIR ${MITK_SOURCE_DIR}
        )
   endif()
 
   ExternalProject_Add(${proj}
     ${mitk_source_location}
     BINARY_DIR ${MITK_BINARY_DIR}
     PREFIX ${proj}${ep_suffix}
     INSTALL_COMMAND ""
     CMAKE_GENERATOR ${gen}
     CMAKE_ARGS
       ${ep_common_args}
       ${mitk_boolean_args}
       ${additional_mitk_cmakevars}
       -DBUILD_SHARED_LIBS:BOOL=ON
       -DBUILD_TESTING:BOOL=${MITK_BUILD_TESTING}
     DEPENDS
       ${proj_DEPENDENCIES}
     )
 
   if(MITK_USE_SUPERBUILD)
     set(MITK_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MITK_BINARY_DIR}/MITK-build")
   else()
     set(MITK_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MITK_BINARY_DIR}")
   endif()
 
 else()
 
   # The project is provided using MITK_DIR, nevertheless since other
   # projects may depend on MITK, let's add an 'empty' one
   MacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   # Further, do some sanity checks in the case of a pre-built MITK
   set(my_itk_dir ${ITK_DIR})
   set(my_vtk_dir ${VTK_DIR})
 
   find_package(MITK REQUIRED)
 
   if(my_itk_dir AND NOT my_itk_dir STREQUAL ${ITK_DIR})
     message(FATAL_ERROR "ITK packages do not match:\n   ${MY_PROJECT_NAME}: ${my_itk_dir}\n  MITK: ${ITK_DIR}")
   endif()
 
   if(my_vtk_dir AND NOT my_vtk_dir STREQUAL ${VTK_DIR})
     message(FATAL_ERROR "VTK packages do not match:\n   ${MY_PROJECT_NAME}: ${my_vtk_dir}\n  MITK: ${VTK_DIR}")
   endif()
 
   if(MITK_USE_Qt4)
     set(my_qmake_executable ${QT_QMAKE_EXECUTABLE})
 
     if(my_qmake_executable AND MITK_QMAKE_EXECUTABLE)
       if(NOT my_qmake_executable STREQUAL ${MITK_QMAKE_EXECUTABLE})
         message(FATAL_ERROR "Qt qmake does not match:\n   ${MY_PROJECT_NAME}: ${my_qmake_executable}\n  MITK: ${MITK_QMAKE_EXECUTABLE}")
       endif()
     endif()
   endif()
 
 endif()
 
diff --git a/MITKConfig.cmake.in b/MITKConfig.cmake.in
index fbc7fe174d..42195ab08e 100644
--- a/MITKConfig.cmake.in
+++ b/MITKConfig.cmake.in
@@ -1,214 +1,216 @@
 
 # Update the CMake module path
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "@MITK_SOURCE_DIR@/CMake")
 
 set(CppMicroServices_DIR "@CppMicroServices_DIR@")
 
 # Include MITK macros
 include(MacroParseArguments)
 include(mitkFunctionCheckMitkCompatibility)
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionCreateWindowsBatchScript)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionInstallAutoLoadModules)
 include(mitkFunctionGetLibrarySearchPaths)
 include(mitkFunctionUseModules)
 include(mitkMacroCreateModuleConf)
 include(mitkFunctionCheckModuleDependencies)
 include(mitkFunctionCreateModule)
 include(mitkMacroCreateExecutable)
 include(mitkMacroCheckModule)
 include(mitkMacroCreateModuleTests)
 include(mitkFunctionAddCustomModuleTest)
 include(mitkMacroUseModule)
 include(mitkMacroMultiplexPicType)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroCreateCTKPlugin)
 include(mitkMacroGetPMDPlatformString)
 
 # Standard CMake macros
 include(FeatureSummary)
 
 # 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@")
 set(MITK_VERSION_STRING "@MITK_VERSION_STRING@")
 
 # MITK compiler flags
 set(MITK_C_FLAGS "@MITK_C_FLAGS@")
 set(MTTK_C_FLAGS_DEBUG "@MITK_C_FLAGS_DEBUG@")
 set(MITK_C_FLAGS_RELEASE "@MITK_C_FLAGS_RELEASE@")
 set(MITK_CXX_FLAGS "@MITK_CXX_FLAGS@")
 set(MTTK_CXX_FLAGS_DEBUG "@MITK_CXX_FLAGS_DEBUG@")
 set(MITK_CXX_FLAGS_RELEASE "@MITK_CXX_FLAGS_RELEASE@")
 
 set(MITK_EXE_LINKER_FLAGS "@MITK_EXE_LINKER_FLAGS@")
 set(MITK_SHARED_LINKER_FLAGS "@MITK_SHARED_LINKER_FLAGS@")
 set(MITK_MODULE_LINKER_FLAGS "@MITK_MODULE_LINKER_FLAGS@")
 
 # Internal version numbers, used for approximate compatibility checks
 # of a MITK development version (non-release).
 set(MITK_VERSION_PLUGIN_SYSTEM 2) # dropped legacy BlueBerry plug-in CMake support
 
 # MITK specific variables
 set(MITK_SOURCE_DIR "@MITK_SOURCE_DIR@")
 set(MITK_BINARY_DIR "@MITK_BINARY_DIR@")
 set(MITK_CMAKE_DIR "@MITK_CMAKE_DIR@")
 set(UTILITIES_DIR "@UTILITIES_DIR@")
 set(REGISTER_QFUNCTIONALITY_CPP_IN "@REGISTER_QFUNCTIONALITY_CPP_IN@")
 set(MITK_DOXYGEN_TAGFILE_NAME "@MITK_DOXYGEN_TAGFILE_NAME@")
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR "@MITK_MODULES_PACKAGE_DEPENDS_DIR@")
 if(MODULES_PACKAGE_DEPENDS_DIRS)
   list(APPEND MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
   list(REMOVE_DUPLICATES MODULES_PACKAGE_DEPENDS_DIRS)
 else()
   set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 endif()
 
 if(MODULES_CONF_DIRS)
   list(APPEND MODULES_CONF_DIRS "@MODULES_CONF_DIRS@")
   list(REMOVE_DUPLICATES MODULES_CONF_DIRS)
 else()
   set(MODULES_CONF_DIRS "@MODULES_CONF_DIRS@")
 endif()
 
 set(MODULES_CONF_DIRNAME "@MODULES_CONF_DIRNAME@")
 
 foreach(_module @MITK_MODULE_NAMES@)
   set(${_module}_CONFIG_FILE "@MITK_BINARY_DIR@/@MODULES_CONF_DIRNAME@/${_module}Config.cmake")
 endforeach()
 
 # External projects
 set(CTK_DIR "@CTK_DIR@")
 set(ANN_DIR "@ANN_DIR@")
 set(CppUnit_DIR "@CppUnit_DIR@")
 set(Eigen_DIR "@Eigen_DIR@")
 set(GLEW_DIR "@GLEW_DIR@")
 set(tinyxml_DIR "@tinyxml_DIR@")
 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(Poco_DIR "@Poco_DIR@")
 set(SOFA_DIR "@SOFA_DIR@")
 set(Qwt_DIR "@Qwt_DIR@")
 set(Qxt_DIR "@Qxt_DIR@")
 set(ACVD_DIR "@ACVD_DIR@")
 set(MITK_DATA_DIR "@MITK_DATA_DIR@")
 set(SimpleITK_DIR "@SimpleITK_DIR@")
 set(Python_DIR "@Python_DIR@")
 
 # External SDK directories
 set(MITK_PMD_SDK_DIR @MITK_PMD_SDK_DIR@)
 
 # MITK use variables
 set(MITK_USE_QT @MITK_USE_QT@)
 set(MITK_USE_Qt4 @MITK_USE_Qt4@)
 set(MITK_USE_Qt5 @MITK_USE_Qt5@)
-set(MITK_DESIRED_QT_VERSION @DESIRED_QT_VERSION@)
 set(MITK_USE_BLUEBERRY @MITK_USE_BLUEBERRY@)
 set(MITK_USE_SYSTEM_Boost @MITK_USE_SYSTEM_Boost@)
 set(MITK_USE_Boost @MITK_USE_Boost@)
 set(MITK_USE_Boost_LIBRARIES @MITK_USE_Boost_LIBRARIES@)
 set(MITK_USE_CTK @MITK_USE_CTK@)
 set(MITK_USE_DCMTK @MITK_USE_DCMTK@)
 set(MITK_USE_OpenCV @MITK_USE_OpenCV@)
 set(MITK_USE_SOFA @MITK_USE_SOFA@)
 set(MITK_USE_Python @MITK_USE_Python@)
 set(MITK_USE_SimpleITK @MITK_USE_SimpleITK@)
 set(MITK_USE_ACVD @MITK_USE_ACVD@)
 
+set(DESIRED_QT_VERSION @DESIRED_QT_VERSION@)
+
 if(MITK_USE_Qt4)
   set(MITK_QMAKE_EXECUTABLE "@QT_QMAKE_EXECUTABLE@")
   set(MITK_QT4_MINIMUM_VERSION @MITK_QT4_MINIMUM_VERSION@)
   find_package(Qt4 ${MITK_QT4_MINIMUM_VERSION} REQUIRED)
 elseif(MITK_USE_Qt5)
+  set(CMAKE_PREFIX_PATH @CMAKE_PREFIX_PATH@)
   set(MITK_QT5_MINIMUM_VERSION @MITK_QT5_MINIMUM_VERSION@)
   find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED)
 endif()
 
 # MITK ToF use variables
 
 set(MITK_TOF_PMDCAMCUBE_AVAILABLE @MITK_USE_TOF_PMDCAMCUBE@)
 if(MITK_TOF_PMDCAMCUBE_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDCAMCUBE "Enable support for PMD Cam Cube" @MITK_USE_TOF_PMDCAMCUBE@)
   mark_as_advanced(MITK_USE_TOF_PMDCAMCUBE)
 endif()
 
 set(MITK_TOF_PMDCAMBOARD_AVAILABLE @MITK_USE_TOF_PMDCAMBOARD@)
 if(MITK_TOF_PMDCAMBOARD_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDCAMBOARD "Enable support for PMD Cam Board" @MITK_USE_TOF_PMDCAMBOARD@)
   mark_as_advanced(MITK_USE_TOF_PMDCAMBOARD)
 endif()
 
 set(MITK_TOF_PMDO3_AVAILABLE @MITK_USE_TOF_PMDO3@)
 if(MITK_TOF_PMDO3_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_PMDO3 "Enable support for PMD =3" @MITK_USE_TOF_PMDO3@)
   mark_as_advanced(MITK_USE_TOF_PMDO3)
 endif()
 
 set(MITK_TOF_KINECT_AVAILABLE @MITK_USE_TOF_KINECT@)
 if(MITK_TOF_KINECT_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_KINECT "Enable support for Kinect" @MITK_USE_TOF_KINECT@)
   mark_as_advanced(MITK_USE_TOF_KINECT)
 endif()
 
 set(MITK_TOF_MESASR4000_AVAILABLE @MITK_USE_TOF_MESASR4000@)
 if(MITK_TOF_MESASR4000_AVAILABLE AND NOT ${PROJECT_NAME} STREQUAL "MITK")
   option(MITK_USE_TOF_MESASR4000 "Enable support for MESA SR4000" @MITK_USE_TOF_MESASR4000@)
   mark_as_advanced(MITK_USE_TOF_MESASR4000)
 endif()
 
 if(MITK_USE_IGT)
   #include("${MITK_DIR}/mitkIGTConfig.cmake")
 endif()
 
 # Install rules for ToF libraries loaded at runtime
 if(EXISTS "@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
   include("@MITK_BINARY_DIR@/mitkToFHardwareInstallRules.cmake")
 endif()
 
 if(NOT MITK_EXPORTS_FILE_INCLUDED)
   if(EXISTS "@MITK_EXPORTS_FILE@")
     set(MITK_EXPORTS_FILE_INCLUDED 1)
     include("@MITK_EXPORTS_FILE@")
   endif()
 endif()
 
 # BlueBerry support
 if(MITK_USE_BLUEBERRY)
 
   set(BlueBerry_DIR "@MITK_BINARY_DIR@/BlueBerry")
 
   # 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()
 
   set(MITK_PLUGIN_USE_FILE "@MITK_PLUGIN_USE_FILE@")
   if(MITK_PLUGIN_USE_FILE)
     if(EXISTS "${MITK_PLUGIN_USE_FILE}")
       include("${MITK_PLUGIN_USE_FILE}")
     endif()
   endif()
 
   set(MITK_PLUGIN_PROVISIONING_FILE "@MITK_EXTAPP_PROVISIONING_FILE@")
   set(MITK_PROVISIONING_FILES
       "${BLUEBERRY_PLUGIN_PROVISIONING_FILE}"
       "${MITK_PLUGIN_PROVISIONING_FILE}")
 
 endif()
 
 # Set properties on exported targets
 @MITK_EXPORTED_TARGET_PROPERTIES@