diff --git a/Applications/Diffusion/CMakeLists.txt b/Applications/Diffusion/CMakeLists.txt
index 21e5280206..feb99aa6a8 100644
--- a/Applications/Diffusion/CMakeLists.txt
+++ b/Applications/Diffusion/CMakeLists.txt
@@ -1,96 +1,96 @@
 project(MitkDiffusion)
 
 set(DIFFUSIONAPP_NAME MitkDiffusion)
 
 set(_app_options)
 if(MITK_SHOW_CONSOLE_WINDOW)
   list(APPEND _app_options SHOW_CONSOLE)
 endif()
 
 # Create a cache entry for the provisioning file which is used to export
 # the file name in the MITKConfig.cmake file. This will keep external projects
 # which rely on this file happy.
 set(DIFFUSIONIMAGINGAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${DIFFUSIONAPP_NAME}.provisioning" CACHE INTERNAL "${DIFFUSIONAPP_NAME} provisioning file" FORCE)
 
 # should be identical to the list in /CMake/mitkBuildConfigurationmitkDiffusion.cmake
 # remember to set plugins which should be automatically toggled in target_libraries.cmake
 set(_plugins
   org.commontk.configadmin
   org.commontk.eventadmin
   org.blueberry.osgi
   org.blueberry.compat
   org.blueberry.core.runtime
   org.blueberry.core.expressions
   org.blueberry.solstice.common
   org.blueberry.core.commands
   org.blueberry.ui
   org.blueberry.ui.qt
   org.blueberry.ui.qt.log
   org.blueberry.ui.qt.help
   org.mitk.core.services
   org.mitk.gui.common
   org.mitk.planarfigure
   org.mitk.core.ext
   org.mitk.diffusionimaging
   org.mitk.gui.qt.application
   org.mitk.gui.qt.ext
   org.mitk.gui.qt.diffusionimagingapp
   org.mitk.gui.qt.common
   org.mitk.gui.qt.stdmultiwidgeteditor
   org.mitk.gui.qt.common.legacy
   org.mitk.gui.qt.datamanager
   org.mitk.gui.qt.measurementtoolbox
   org.mitk.gui.qt.segmentation
   org.mitk.gui.qt.volumevisualization
   org.mitk.gui.qt.diffusionimaging
   org.mitk.gui.qt.imagenavigator
   org.mitk.gui.qt.moviemaker
   org.mitk.gui.qt.basicimageprocessing
   org.mitk.gui.qt.registration
   org.mitk.gui.qt.properties
   org.mitk.gui.qt.viewnavigator
   org.mitk.gui.qt.cmdlinemodules
 )
 
 # Plug-ins listed below will not be
 #  - added as a build-time dependency to the executable
 #  - listed in the provisioning file for the executable
 #  - installed if they are external plug-ins
 
 set(_exclude_plugins
   org.blueberry.test
   org.blueberry.uitest
   org.mitk.gui.qt.coreapplication
   org.mitk.gui.qt.extapplication
 )
 
 set(_src_files
   MitkDiffusion.cpp
 )
 
 if(MITK_USE_Qt4)
   qt4_add_resources(_src_files splashscreen.qrc)
 else()
   qt5_add_resources(_src_files splashscreen.qrc)
 endif()
 
 FunctionCreateBlueBerryApplication(
   NAME ${DIFFUSIONAPP_NAME}
   DESCRIPTION "MITK Diffusion"
   PLUGINS ${_plugins}
   EXCLUDE_PLUGINS ${_exclude_plugins}
   SOURCES ${_src_files}
   ${_app_options}
 )
 
 mitk_use_modules(TARGET ${DIFFUSIONAPP_NAME} MODULES qtsingleapplication)
 
 # Add meta dependencies (e.g. on auto-load modules from depending modules)
-if(ALL_META_DEPENDENCIES)
-  add_dependencies(${DIFFUSIONAPP_NAME} ${ALL_META_DEPENDENCIES})
+if(TARGET ${CMAKE_PROJECT_NAME}-autoload)
+  add_dependencies(${DIFFUSIONAPP_NAME} ${CMAKE_PROJECT_NAME}-autoload)
 endif()
 
 # Add a build time dependency to legacy BlueBerry bundles.
 if(MITK_MODULES_ENABLED_PLUGINS)
   add_dependencies(${DIFFUSIONAPP_NAME} ${MITK_MODULES_ENABLED_PLUGINS})
 endif()
diff --git a/Applications/Workbench/CMakeLists.txt b/Applications/Workbench/CMakeLists.txt
index 7b4f05e9e3..8062a68538 100644
--- a/Applications/Workbench/CMakeLists.txt
+++ b/Applications/Workbench/CMakeLists.txt
@@ -1,48 +1,48 @@
 project(Workbench)
 
 set(_app_options)
 if(MITK_SHOW_CONSOLE_WINDOW)
   list(APPEND _app_options SHOW_CONSOLE)
 endif()
 
 # Create a cache entry for the provisioning file which is used to export
 # the file name in the MITKConfig.cmake file. This will keep external projects
 # which rely on this file happy.
 set(MITK_EXTAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/MitkWorkbench.provisioning" CACHE INTERNAL "MitkWorkbench provisioning file" FORCE)
 
 # Plug-ins listed below will not be
 #  - added as a build-time dependency to the executable
 #  - listed in the provisioning file for the executable
 #  - installed if they are external plug-ins
 
 set(_exclude_plugins
   org.blueberry.test
   org.blueberry.uitest
   org.mitk.gui.qt.coreapplication
   org.mitk.gui.qt.diffusionimagingapp
 )
 
 FunctionCreateBlueBerryApplication(
   NAME MitkWorkbench
   DESCRIPTION "MITK Workbench"
   EXCLUDE_PLUGINS ${_exclude_plugins}
   ${_app_options}
 )
 mitk_use_modules(TARGET MitkWorkbench MODULES qtsingleapplication MitkCore)
 
 # Add meta dependencies (e.g. on auto-load modules from depending modules)
-if(ALL_META_DEPENDENCIES)
-  add_dependencies(MitkWorkbench ${ALL_META_DEPENDENCIES})
+if(TARGET ${CMAKE_PROJECT_NAME}-autoload)
+  add_dependencies(MitkWorkbench ${CMAKE_PROJECT_NAME}-autoload)
 endif()
 
 #Setting application icon for mac os x systems
 set_target_properties(MitkWorkbench PROPERTIES MACOSX_BUNDLE_ICON_FILE "icon.icns")
 
 if(APPLE)
   install(FILES "icons/icon.icns" DESTINATION "MitkWorkbench.app/Contents/Resources")
 endif(APPLE)
 
 # Add a build time dependency to legacy BlueBerry bundles.
 if(MITK_MODULES_ENABLED_PLUGINS)
   add_dependencies(MitkWorkbench ${MITK_MODULES_ENABLED_PLUGINS})
 endif()
diff --git a/CMake/mitkFunctionCreateModule.cmake b/CMake/mitkFunctionCreateModule.cmake
index a69cad312b..4b0d3cc11a 100644
--- a/CMake/mitkFunctionCreateModule.cmake
+++ b/CMake/mitkFunctionCreateModule.cmake
@@ -1,654 +1,649 @@
 ##################################################################
 #
 # mitk_create_module
 #
 #! Creates a module for the automatic module dependency system within MITK.
 #!
 #! Example:
 #!
 #! \code
 #! mitk_create_module(
 #!     DEPENDS PUBLIC MitkCore
 #!     PACKAGE_DEPENDS
 #!       PRIVATE Qt5|Xml+Networking
 #!       PUBLIC  ITK|Watershed
 #!     WARNINGS_AS_ERRORS
 #! \endcode
 #!
 #! The <moduleName> parameter specifies the name of the module which is used
 #! to create a logical target name. The parameter is optional in case the
 #! MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME variable evaluates to TRUE. The
 #! module name will then be derived from the directory name in which this
 #! function is called.
 #!
 #! If set, the following variables will be used to validate the module name:
 #!
 #!   MITK_MODULE_NAME_REGEX_MATCH The module name must match this regular expression.
 #!   MITK_MODULE_NAME_REGEX_NOT_MATCH The module name must not match this regular expression.
 #!
 #! If the MITK_MODULE_NAME_PREFIX variable is set, the module name will be prefixed
 #! with its contents.
 #!
 #! A modules source files are specified in a separate CMake file usually
 #! called files.cmake, located in the module root directory. The
 #! mitk_create_module() macro evaluates the following CMake variables
 #! from the files.cmake file:
 #!
 #! - CPP_FILES A list of .cpp files
 #! - H_FILES A list of .h files without a corresponding .cpp file
 #! - TXX_FILES A list of .txx files
 #! - RESOURCE_FILES A list of files (resources) which are embedded into the module
 #! - MOC_H_FILES A list of Qt header files which should be processed by the MOC
 #! - UI_FILES A list of .ui Qt UI files
 #! - QRC_FILES A list of .qrc Qt resource files
 #! - DOX_FILES A list of .dox Doxygen files
 #!
 #! List of variables available after the function is called:
 #! - MODULE_NAME
 #! - MODULE_TARGET
 #! - MODULE_IS_ENABLED
 #! - MODULE_SUBPROJECTS
-#! - ALL_META_DEPENDENCIES
 #!
 #! \sa mitk_create_executable
 #!
 #! Parameters (all optional):
 #!
 #! \param <moduleName> The module name (also used as target name)
 #! \param FILES_CMAKE File name of a CMake file setting source list variables
 #!        (defaults to files.cmake)
 #! \param VERSION Module version number, e.g. "1.2.0"
 #! \param AUTOLOAD_WITH A module target name identifying the module which will
 #!        trigger the automatic loading of this module
 #! \param DEPRECATED_SINCE Marks this modules as deprecated since <arg>
 #! \param DESCRIPTION A description for this module
 #!
 #! Multi-value Parameters (all optional):
 #!
 #! \param SUBPROJECTS List of CDash labels
 #! \param INCLUDE_DIRS Include directories for this module:
 #!        \verbatim
 #! [[PUBLIC|PRIVATE|INTERFACE] <dir1>...]...
 #! \endverbatim
 #!        The default scope for include directories is PUBLIC.
 #! \param DEPENDS List of module dependencies:
 #!        \verbatim
 #! [[PUBLIC|PRIVATE|INTERFACE] <module1>...]...
 #! \endverbatim
 #!        The default scope for module dependencies is PUBLIC.
 #! \param PACKAGE_DEPENDS List of public packages dependencies (e.g. Qt, VTK, etc.).
 #!        Package dependencies have the following syntax:
 #!        \verbatim
 #! [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
 #! \endverbatim
 #!        The default scope for package dependencies is PRIVATE.
 #! \param ADDITIONAL_LIBS List of addidtional private libraries linked to this module.
 #!        The folder containing the library will be added to the global list of library search paths.
 #! \param CPP_FILES List of source files for this module. If the list is non-empty,
 #!        the module does not need to provide a files.cmake file or FILES_CMAKE argument.
 #! \param H_FILES List of public header files for this module. It is recommended to use
 #!        a files.cmake file instead.
 #!
 #! Options (optional)
 #!
 #! \param FORCE_STATIC Force building this module as a static library
 #! \param GCC_DEFAULT_VISIBILITY Do not use gcc visibility flags - all
 #!        symbols will be exported
 #! \param NO_INIT Do not create CppMicroServices initialization code
 #! \param NO_FEATURE_INFO Do not create a feature info by calling add_feature_info()
 #! \param WARNINGS_AS_ERRORS Treat compiler warnings as errors
 #
 ##################################################################
 function(mitk_create_module)
 
   set(_macro_params
       VERSION                # module version number, e.g. "1.2.0"
       EXPORT_DEFINE          # export macro name for public symbols of this module (DEPRECATED)
       AUTOLOAD_WITH          # a module target name identifying the module which will trigger the
                              # automatic loading of this module
       FILES_CMAKE            # file name of a CMake file setting source list variables
                              # (defaults to files.cmake)
       DEPRECATED_SINCE       # marks this modules as deprecated
       DESCRIPTION            # a description for this module
      )
 
   set(_macro_multiparams
       SUBPROJECTS            # list of CDash labels
       INCLUDE_DIRS           # include directories: [PUBLIC|PRIVATE|INTERFACE] <list>
       INTERNAL_INCLUDE_DIRS  # include dirs internal to this module (DEPRECATED)
       DEPENDS                # list of modules this module depends on: [PUBLIC|PRIVATE|INTERFACE] <list>
       DEPENDS_INTERNAL       # list of modules this module internally depends on (DEPRECATED)
       PACKAGE_DEPENDS        # list of "packages this module depends on (e.g. Qt, VTK, etc.): [PUBLIC|PRIVATE|INTERFACE] <package-list>
       TARGET_DEPENDS         # list of CMake targets this module should depend on
       ADDITIONAL_LIBS        # list of addidtional private libraries linked to this module.
       CPP_FILES              # list of cpp files
       H_FILES                # list of header files: [PUBLIC|PRIVATE] <list>
      )
 
   set(_macro_options
       FORCE_STATIC           # force building this module as a static library
       HEADERS_ONLY           # this module is a headers-only library
       GCC_DEFAULT_VISIBILITY # do not use gcc visibility flags - all symbols will be exported
       NO_DEFAULT_INCLUDE_DIRS # do not add default include directories like "include" or "."
       NO_INIT                # do not create CppMicroServices initialization code
       NO_FEATURE_INFO        # do not create a feature info by calling add_feature_info()
       WARNINGS_AS_ERRORS     # treat all compiler warnings as errors
       EXECUTABLE             # create an executable; do not use directly, use mitk_create_executable() instead
       C_MODULE               # compile all source files as C sources
       CXX_MODULE             # compile all source files as C++ sources
      )
 
   cmake_parse_arguments(MODULE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
 
   set(MODULE_NAME ${MODULE_UNPARSED_ARGUMENTS})
 
   if(NOT MODULE_NAME)
     if(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME)
       get_filename_component(MODULE_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
     else()
       message(SEND_ERROR "The module name must not be empty")
     endif()
   endif()
 
   set(_deprecated_args INTERNAL_INCLUDE_DIRS DEPENDS_INTERNAL EXPORT_DEFINE TARGET_DEPENDS HEADERS_ONLY)
   foreach(_deprecated_arg ${_deprecated_args})
     if(MODULE_${_deprecated_arg})
       message(WARNING "The ${_deprecated_arg} argument is deprecated")
     endif()
   endforeach()
 
   set(_module_type module)
   set(_Module_type Module)
   if(MODULE_EXECUTABLE)
     set(_module_type executable)
     set(_Module_type Executable)
   endif()
 
   if(MITK_MODULE_NAME_REGEX_MATCH)
     if(NOT ${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_MATCH})
       message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" does not match the regular expression \"${MITK_MODULE_NAME_REGEX_MATCH}\".")
     endif()
   endif()
   if(MITK_MODULE_NAME_REGEX_NOT_MATCH)
     if(${MODULE_NAME} MATCHES ${MITK_MODULE_NAME_REGEX_NOT_MATCH})
       message(SEND_ERROR "The ${_module_type} name \"${MODULE_NAME}\" must not match the regular expression \"${MITK_MODULE_NAME_REGEX_NOT_MATCH}\".")
     endif()
   endif()
 
   if(MITK_MODULE_NAME_PREFIX AND NOT MODULE_NAME MATCHES "^${MITK_MODULE_NAME_PREFIX}.*$")
     set(MODULE_NAME "${MITK_MODULE_NAME_PREFIX}${MODULE_NAME}")
   endif()
 
   if(NOT MODULE_FILES_CMAKE)
     set(MODULE_FILES_CMAKE files.cmake)
   endif()
   if(NOT IS_ABSOLUTE ${MODULE_FILES_CMAKE})
     set(MODULE_FILES_CMAKE ${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_FILES_CMAKE})
   endif()
 
   if(MODULE_HEADERS_ONLY)
     set(MODULE_TARGET )
     if(MODULE_AUTOLOAD_WITH)
       message(SEND_ERROR "A headers only module cannot be auto-loaded")
     endif()
   else()
     set(MODULE_TARGET ${MODULE_NAME})
   endif()
 
   if(NOT MODULE_SUBPROJECTS)
     if(MITK_DEFAULT_SUBPROJECTS)
       set(MODULE_SUBPROJECTS ${MITK_DEFAULT_SUBPROJECTS})
     endif()
   endif()
 
   # check if the subprojects exist as targets
   if(MODULE_SUBPROJECTS)
     foreach(subproject ${MODULE_SUBPROJECTS})
       if(NOT TARGET ${subproject})
         message(SEND_ERROR "The subproject ${subproject} does not have a corresponding target")
       endif()
     endforeach()
   endif()
 
   # assume worst case
   set(MODULE_IS_ENABLED 0)
   # first we check if we have an explicit module build list
   if(MITK_MODULES_TO_BUILD)
     list(FIND MITK_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
     if(_MOD_INDEX EQUAL -1)
       set(MODULE_IS_EXCLUDED 1)
     endif()
   endif()
 
   if(NOT MODULE_IS_EXCLUDED)
     # first of all we check for the dependencies
     _mitk_parse_package_args(${MODULE_PACKAGE_DEPENDS})
     mitk_check_module_dependencies(MODULES ${MODULE_DEPENDS}
                                    PACKAGES ${PACKAGE_NAMES}
                                    MISSING_DEPENDENCIES_VAR _MISSING_DEP
                                    PACKAGE_DEPENDENCIES_VAR PACKAGE_NAMES)
 
     if(_MISSING_DEP)
       if(MODULE_NO_FEATURE_INFO)
         message("${_Module_type} ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}")
       endif()
       set(MODULE_IS_ENABLED 0)
     else()
       set(MODULE_IS_ENABLED 1)
       # now check for every package if it is enabled. This overlaps a bit with
       # MITK_CHECK_MODULE ...
       foreach(_package ${PACKAGE_NAMES})
         if((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package}))
           message("${_Module_type} ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.")
           set(MODULE_IS_ENABLED 0)
           break()
         endif()
       endforeach()
 
       if(MODULE_IS_ENABLED)
 
         # clear variables defined in files.cmake
         set(RESOURCE_FILES )
         set(CPP_FILES )
         set(H_FILES )
         set(TXX_FILES )
         set(DOX_FILES )
         set(UI_FILES )
         set(MOC_H_FILES )
         set(QRC_FILES )
 
         # clear other variables
         set(Q${KITNAME}_GENERATED_CPP )
         set(Q${KITNAME}_GENERATED_MOC_CPP )
         set(Q${KITNAME}_GENERATED_QRC_CPP )
         set(Q${KITNAME}_GENERATED_UI_CPP )
 
         # check and set-up auto-loading
         if(MODULE_AUTOLOAD_WITH)
           if(NOT TARGET "${MODULE_AUTOLOAD_WITH}")
             message(SEND_ERROR "The module target \"${MODULE_AUTOLOAD_WITH}\" specified as the auto-loading module for \"${MODULE_NAME}\" does not exist")
           endif()
-          set(_module_autoload_meta_target "${MODULE_AUTOLOAD_WITH}-autoload")
-          # create a meta-target if it does not already exist
-          if(NOT TARGET ${_module_autoload_meta_target})
-            add_custom_target(${_module_autoload_meta_target})
-          endif()
+        endif()
+        set(_module_autoload_meta_target "${CMAKE_PROJECT_NAME}-autoload")
+        # create a meta-target if it does not already exist
+        if(NOT TARGET ${_module_autoload_meta_target})
+          add_custom_target(${_module_autoload_meta_target})
         endif()
 
         if(NOT MODULE_EXPORT_DEFINE)
           set(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT)
         endif()
 
         if(MITK_GENERATE_MODULE_DOT)
           message("MODULEDOTNAME ${MODULE_NAME}")
           foreach(dep ${MODULE_DEPENDS})
             message("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ")
           endforeach(dep)
         endif(MITK_GENERATE_MODULE_DOT)
 
         # ok, now create the module itself
         if (EXISTS ${MODULE_FILES_CMAKE})
           include(${MODULE_FILES_CMAKE})
         elseif(NOT MODULE_CPP_FILES AND NOT MODULE_HEADERS_ONLY)
           message("WARNING No cmake file found AND no cpp files specified... ")
         endif()
 
         if(MODULE_CPP_FILES)
           list(APPEND CPP_FILES ${MODULE_CPP_FILES})
         endif()
 
         if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src")
           # Preprend the "src" directory to the cpp file list
           set(_cpp_files ${CPP_FILES})
           set(CPP_FILES )
           foreach(_cpp_file ${_cpp_files})
             list(APPEND CPP_FILES "src/${_cpp_file}")
           endforeach()
         endif()
 
         if(CPP_FILES)
           set(MODULE_HEADERS_ONLY 0)
           if(MODULE_C_MODULE)
             set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE C)
           elseif(MODULE_CXX_MODULE)
             set_source_files_properties(${CPP_FILES} PROPERTIES LANGUAGE CXX)
           endif()
         else()
           set(MODULE_HEADERS_ONLY 1)
         endif()
 
         set(module_c_flags )
         set(module_c_flags_debug )
         set(module_c_flags_release )
         set(module_cxx_flags )
         set(module_cxx_flags_debug )
         set(module_cxx_flags_release )
 
         if(MODULE_GCC_DEFAULT_VISIBILITY)
           set(CMAKE_CXX_VISIBILITY_PRESET default)
           set(CMAKE_VISIBILITY_INLINES_HIDDEN 0)
         else()
           set(CMAKE_CXX_VISIBILITY_PRESET hidden)
           set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
         endif()
 
         if(MODULE_WARNINGS_AS_ERRORS)
           if(MSVC_VERSION)
             mitkFunctionCheckCAndCXXCompilerFlags("/WX" module_c_flags module_cxx_flags)
           else()
             mitkFunctionCheckCAndCXXCompilerFlags(-Werror module_c_flags module_cxx_flags)
 
             # The flag "c++0x-static-nonintegral-init" has been renamed in newer Clang
             # versions to "static-member-init", see
             # http://clang-developers.42468.n3.nabble.com/Wc-0x-static-nonintegral-init-gone-td3999651.html
             #
             # Also, older Clang and seemingly all gcc versions do not warn if unknown
             # "-no-*" flags are used, so CMake will happily append any -Wno-* flag to the
             # command line. This may get confusing if unrelated compiler errors happen and
             # the error output then additionally contains errors about unknown flags (which
             # is not the case if there were no compile errors).
             #
             # So instead of using -Wno-* we use -Wno-error=*, which will be properly rejected by
             # the compiler and if applicable, prints the specific warning as a real warning and
             # not as an error (although -Werror was given).
 
             mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=c++0x-static-nonintegral-init" module_c_flags module_cxx_flags)
             mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=static-member-init" module_c_flags module_cxx_flags)
             mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=unknown-warning" module_c_flags module_cxx_flags)
             mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=gnu" module_c_flags module_cxx_flags)
           endif()
         endif(MODULE_WARNINGS_AS_ERRORS)
 
         if(MODULE_FORCE_STATIC)
           set(_STATIC STATIC)
         else()
           set(_STATIC )
         endif(MODULE_FORCE_STATIC)
 
-        # create a meta-target for auto-loaded modules
-        add_custom_target(${MODULE_NAME}-autoload)
-
         if(NOT MODULE_HEADERS_ONLY)
           if(NOT MODULE_NO_INIT OR RESOURCE_FILES)
             find_package(CppMicroServices QUIET NO_MODULE REQUIRED)
           endif()
           if(NOT MODULE_NO_INIT)
             usFunctionGenerateModuleInit(CPP_FILES)
           endif()
 
           set(binary_res_files )
           set(source_res_files )
           if(RESOURCE_FILES)
             if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/resources")
               set(res_dir resources)
             elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/Resources")
               set(res_dir Resources)
             else()
               message(SEND_ERROR "Resources specified but ${CMAKE_CURRENT_SOURCE_DIR}/resources directory not found.")
             endif()
             foreach(res_file ${RESOURCE_FILES})
               if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}/${res_file})
                 list(APPEND binary_res_files "${res_file}")
               else()
                 list(APPEND source_res_files "${res_file}")
               endif()
             endforeach()
 
             # Add a source level dependencies on resource files
             usFunctionGetResourceSource(TARGET ${MODULE_TARGET} OUT CPP_FILES)
           endif()
         endif()
 
         # Qt 4 case
         if(MITK_USE_Qt4)
           if(UI_FILES)
             qt4_wrap_ui(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES})
           endif()
           if(MOC_H_FILES)
             qt4_wrap_cpp(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES} OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
           endif()
           if(QRC_FILES)
             qt4_add_resources(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES})
           endif()
         endif()
 
         # all the same for Qt 5
         if(MITK_USE_Qt5)
           if(UI_FILES)
             qt5_wrap_ui(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES})
           endif()
           if(MOC_H_FILES)
             qt5_wrap_cpp(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES} OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
           endif()
           if(QRC_FILES)
             qt5_add_resources(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES})
           endif()
         endif()
 
         set(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP})
 
         ORGANIZE_SOURCES(SOURCE ${CPP_FILES}
                          HEADER ${H_FILES}
                          TXX ${TXX_FILES}
                          DOC ${DOX_FILES}
                          UI ${UI_FILES}
                          QRC ${QRC_FILES}
                          MOC ${Q${KITNAME}_GENERATED_MOC_CPP}
                          GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP}
                          GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP})
 
         set(coverage_sources
             ${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES}
             ${TOOL_CPPS} ${TOOL_GUI_CPPS})
 
         if(MODULE_SUBPROJECTS)
           set_property(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
         endif()
 
         if(NOT MODULE_HEADERS_ONLY)
 
           if(MODULE_EXECUTABLE)
             add_executable(${MODULE_TARGET}
                            ${MODULE_CPP_FILES} ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
                            ${DOX_FILES} ${UI_FILES} ${QRC_FILES})
             set(_us_module_name main)
           else()
             add_library(${MODULE_TARGET} ${_STATIC}
                         ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP}
                         ${DOX_FILES} ${UI_FILES} ${QRC_FILES})
             set(_us_module_name ${MODULE_TARGET})
           endif()
 
           # Apply properties to the module target.
           target_compile_definitions(${MODULE_TARGET} PRIVATE US_MODULE_NAME=${_us_module_name})
           if(MODULE_C_MODULE)
             if(module_c_flags)
               string(REPLACE " " ";" module_c_flags "${module_c_flags}")
               target_compile_options(${MODULE_TARGET} PRIVATE ${module_c_flags})
             endif()
             if(module_c_flags_debug)
               string(REPLACE " " ";" module_c_flags_debug "${module_c_flags_debug}")
               target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_c_flags_debug}>)
             endif()
             if(module_c_flags_release)
               string(REPLACE " " ";" module_c_flags_release "${module_c_flags_release}")
               target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_c_flags_release}>)
             endif()
           else()
             if(module_cxx_flags)
               string(REPLACE " " ";" module_cxx_flags "${module_cxx_flags}")
               target_compile_options(${MODULE_TARGET} PRIVATE ${module_cxx_flags})
             endif()
             if(module_cxx_flags_debug)
               string(REPLACE " " ";" module_cxx_flags_debug "${module_cxx_flags_debug}")
               target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Debug>:${module_cxx_flags_debug}>)
             endif()
             if(module_cxx_flags_release)
               string(REPLACE " " ";" module_cxx_flags_release "${module_cxx_flags_release}")
               target_compile_options(${MODULE_TARGET} PRIVATE $<$<CONFIG:Release>:${module_cxx_flags_release}>)
             endif()
           endif()
 
           set_property(TARGET ${MODULE_TARGET} PROPERTY US_MODULE_NAME ${_us_module_name})
           if(MODULE_DEPRECATED_SINCE)
             set_property(TARGET ${MODULE_TARGET} PROPERTY MITK_MODULE_DEPRECATED_SINCE ${MODULE_DEPRECATED_SINCE})
           endif()
 
           if(MODULE_TARGET_DEPENDS)
             add_dependencies(${MODULE_TARGET} ${MODULE_TARGET_DEPENDS})
           endif()
 
           if(MODULE_SUBPROJECTS)
             set_property(TARGET ${MODULE_TARGET} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
             foreach(subproject ${MODULE_SUBPROJECTS})
               add_dependencies(${subproject} ${MODULE_TARGET})
             endforeach()
           endif()
 
           set(DEPENDS "${MODULE_DEPENDS}")
           if(NOT MODULE_NO_INIT)
             # Add a CppMicroServices dependency implicitly, since it is
             # needed for the generated "module initialization" code.
             set(DEPENDS "CppMicroServices;${DEPENDS}")
           endif()
           if(DEPENDS OR MODULE_PACKAGE_DEPENDS)
             mitk_use_modules(TARGET ${MODULE_TARGET}
                              MODULES ${DEPENDS}
                              PACKAGES ${MODULE_PACKAGE_DEPENDS}
                             )
           endif()
 
           if(MINGW)
             target_link_libraries(${MODULE_TARGET} ssp) # add stack smash protection lib
           endif()
 
           # Add additional library search directories to a global property which
           # can be evaluated by other CMake macros, e.g. our install scripts.
           if(MODULE_ADDITIONAL_LIBS)
             target_link_libraries(${MODULE_TARGET} PRIVATE ${MODULE_ADDITIONAL_LIBS})
             get_property(_mitk_additional_library_search_paths GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
             foreach(_lib_filepath ${MODULE_ADDITIONAL_LIBS})
               get_filename_component(_search_path "${_lib_filepath}" PATH)
               if(_search_path)
                 list(APPEND _mitk_additional_library_search_paths "${_search_path}")
               endif()
             endforeach()
             if(_mitk_additional_library_search_paths)
               list(REMOVE_DUPLICATES _mitk_additional_library_search_paths)
               set_property(GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS ${_mitk_additional_library_search_paths})
             endif()
           endif()
 
           # add the target name to a global property which is used in the top-level
           # CMakeLists.txt file to export the target
           set_property(GLOBAL APPEND PROPERTY MITK_MODULE_TARGETS ${MODULE_TARGET})
           if(MODULE_AUTOLOAD_WITH)
             # for auto-loaded modules, adapt the output directory
             add_dependencies(${_module_autoload_meta_target} ${MODULE_TARGET})
             if(WIN32)
               set(_module_output_prop RUNTIME_OUTPUT_DIRECTORY)
             else()
               set(_module_output_prop LIBRARY_OUTPUT_DIRECTORY)
             endif()
             set(_module_output_dir ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
             get_target_property(_module_is_imported ${MODULE_AUTOLOAD_WITH} IMPORTED)
             if(NOT _module_is_imported)
               # if the auto-loading module is not imported, get its location
               # and put the auto-load module relative to it.
               get_target_property(_module_output_dir ${MODULE_AUTOLOAD_WITH} ${_module_output_prop})
               set_target_properties(${MODULE_TARGET} PROPERTIES
                                     ${_module_output_prop} ${_module_output_dir}/${MODULE_AUTOLOAD_WITH})
             else()
               set_target_properties(${MODULE_TARGET} PROPERTIES
                                     ${_module_output_prop} ${CMAKE_${_module_output_prop}}/${MODULE_AUTOLOAD_WITH})
             endif()
             set_target_properties(${MODULE_TARGET} PROPERTIES
                                   MITK_AUTOLOAD_DIRECTORY ${MODULE_AUTOLOAD_WITH})
 
             # add the auto-load module name as a property
             set_property(TARGET ${MODULE_AUTOLOAD_WITH} APPEND PROPERTY MITK_AUTOLOAD_TARGETS ${MODULE_TARGET})
           endif()
 
           if(binary_res_files)
             usFunctionAddResources(TARGET ${MODULE_TARGET}
                                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${res_dir}
                                    FILES ${binary_res_files})
           endif()
           if(source_res_files)
             usFunctionAddResources(TARGET ${MODULE_TARGET}
                                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${res_dir}
                                    FILES ${source_res_files})
           endif()
           if(binary_res_files OR source_res_files)
             usFunctionEmbedResources(TARGET ${MODULE_TARGET})
           endif()
 
         endif()
 
         if(NOT MODULE_C_MODULE)
           # Add required compile features, currently works only for GNU (gcc) and Clang (not AppleClang).
           # For all other cases, MITKConfig.cmake prints an error if CMAKE_CXX_STANDARD is not set to C++11
           if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR
              CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
             target_compile_features(${MODULE_TARGET} PUBLIC ${MITK_CXX_FEATURES})
           endif()
         endif()
 
         # create export macros for all modules (also header-only)
         if (NOT MODULE_EXECUTABLE)
           set(_export_macro_name )
           if(MITK_LEGACY_EXPORT_MACRO_NAME)
             set(_export_macro_names
               EXPORT_MACRO_NAME ${MODULE_EXPORT_DEFINE}
               NO_EXPORT_MACRO_NAME ${MODULE_NAME}_NO_EXPORT
               DEPRECATED_MACRO_NAME ${MODULE_NAME}_DEPRECATED
               NO_DEPRECATED_MACRO_NAME ${MODULE_NAME}_NO_DEPRECATED
             )
           endif()
           generate_export_header(${MODULE_NAME}
             ${_export_macro_names}
             EXPORT_FILE_NAME ${MODULE_NAME}Exports.h
           )
         endif()
 
         # add include directories
         if(MODULE_INTERNAL_INCLUDE_DIRS)
           target_include_directories(${MODULE_TARGET} PRIVATE ${MODULE_INTERNAL_INCLUDE_DIRS})
         endif()
         if(NOT MODULE_NO_DEFAULT_INCDLUE_DIRS)
           if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include)
             target_include_directories(${MODULE_TARGET} PUBLIC include)
           else()
             target_include_directories(${MODULE_TARGET} PUBLIC .)
           endif()
           if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/src)
             target_include_directories(${MODULE_TARGET} PRIVATE src)
           endif()
         endif()
         target_include_directories(${MODULE_TARGET}
           PUBLIC ${MODULE_INCLUDE_DIRS}
           PUBLIC ${CMAKE_CURRENT_BINARY_DIR}
         )
 
       endif()
     endif()
   endif()
 
   if(_MISSING_DEP)
     if(MODULE_DESCRIPTION)
       set(MODULE_DESCRIPTION "${MODULE_DESCRIPTION} (missing dependencies: ${_MISSING_DEP})")
     else()
       set(MODULE_DESCRIPTION "(missing dependencies: ${_MISSING_DEP})")
     endif()
   endif()
   if(NOT MODULE_NO_FEATURE_INFO)
     add_feature_info(${MODULE_NAME} MODULE_IS_ENABLED "${MODULE_DESCRIPTION}")
   endif()
 
   set(MODULE_NAME ${MODULE_NAME} PARENT_SCOPE)
   set(MODULE_TARGET ${MODULE_TARGET} PARENT_SCOPE)
   set(MODULE_IS_ENABLED ${MODULE_IS_ENABLED} PARENT_SCOPE)
   set(MODULE_SUBPROJECTS ${MODULE_SUBPROJECTS} PARENT_SCOPE)
-  set(ALL_META_DEPENDENCIES ${ALL_META_DEPENDENCIES} PARENT_SCOPE)
 
 endfunction()
diff --git a/CMake/mitkFunctionUseModules.cmake b/CMake/mitkFunctionUseModules.cmake
index b8fde7f5e3..be36082d71 100644
--- a/CMake/mitkFunctionUseModules.cmake
+++ b/CMake/mitkFunctionUseModules.cmake
@@ -1,200 +1,199 @@
 macro(_mitk_normalize_package_names _package_names_var)
   set(_package_names_var ${_package_names_var})
   if(${_package_names_var})
     set(package_names_normalized )
     list(REMOVE_DUPLICATES ${_package_names_var})
     if(NOT DEFINED _has_qt4_dep OR _has_qt4_dep EQUAL -1)
       list(FIND ${_package_names_var} Qt4 _has_qt4_dep)
     endif()
     if(NOT DEFINED _has_qt5_dep OR _has_qt5_dep EQUAL -1)
       list(FIND ${_package_names_var} Qt5 _has_qt5_dep)
     endif()
     foreach(_package_name ${${_package_names_var}})
       set(${_package_name}_REQUIRED_COMPONENTS )
       # Special filter for exclusive OR Qt4 / Qt5 dependency
       if(_package_name STREQUAL "Qt4")
         if(MITK_USE_Qt4 OR NOT MITK_USE_Qt5)
           # MITK_USE_Qt4 is ON or both MITK_USE_Qt4 and MITK_USE_Qt5
           # are OFF. So list Qt4 as a dependency.
           list(APPEND package_names_normalized ${_package_name})
         elseif(MITK_USE_Qt5 AND _has_qt5_dep EQUAL -1)
             # List Qt4 as a dependency only if there is no Qt5 dependency
             # so the module will not be build because of the missing
             # MITK_USE_Qt4
             list(APPEND package_names_normalized ${_package_name})
         endif()
       elseif(_package_name STREQUAL "Qt5")
         if(MITK_USE_Qt5 OR NOT MITK_USE_Qt4)
           list(APPEND package_names_normalized ${_package_name})
         elseif(MITK_USE_Qt4 AND _has_qt4_dep EQUAL -1)
           list(APPEND package_names_normalized ${_package_name})
         endif()
       else()
         list(APPEND package_names_normalized ${_package_name})
       endif()
     endforeach()
     set(${_package_names_var} ${package_names_normalized})
   endif()
 endmacro()
 
 function(_mitk_parse_package_args)
   set(package_list ${ARGN})
 
   set(PUBLIC_PACKAGE_NAMES )
   set(PRIVATE_PACKAGE_NAMES )
   set(INTERFACE_PACKAGE_NAMES )
 
   set(_package_visibility PRIVATE)
   foreach(_package ${package_list})
     if(_package STREQUAL "PUBLIC" OR _package STREQUAL "PRIVATE" OR _package STREQUAL "INTERFACE")
       set(_package_visibility ${_package})
     else()
       list(APPEND packages ${_package})
       set(_package_name )
       set(_package_components_list )
       string(REPLACE "|" ";" _package_list ${_package})
       if("${_package_list}" STREQUAL "${_package}")
         set(_package_name ${_package})
       else()
         list(GET _package_list 0 _package_name)
         list(GET _package_list 1 _package_components)
         string(REPLACE "+" ";" _package_components_list "${_package_components}")
         if(NOT _package_name OR NOT _package_components)
           message(SEND_ERROR "PACKAGE argument syntax wrong. ${_package} is not of the form PACKAGE[|COMPONENT1[+COMPONENT2]...]")
         endif()
       endif()
       list(APPEND ${_package_visibility}_PACKAGE_NAMES ${_package_name})
       list(APPEND ${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS ${_package_components_list})
     endif()
   endforeach()
 
   # Check if both Qt4 and Qt5 packages are specified in one of the
   # public/private/interface lists
   set(_package_names ${PUBLIC_PACKAGE_NAMES} ${PRIVATE_PACKAGE_NAMES} ${INTERFACE_PACKAGE_NAMES})
   list(FIND _package_names Qt4 _has_qt4_dep)
   list(FIND _package_names Qt5 _has_qt5_dep)
 
   _mitk_normalize_package_names(PUBLIC_PACKAGE_NAMES)
   _mitk_normalize_package_names(PRIVATE_PACKAGE_NAMES)
   _mitk_normalize_package_names(INTERFACE_PACKAGE_NAMES)
 
   # remove duplicates and set package components in parent scope
   foreach(_package_visibility PUBLIC PRIVATE INTERFACE)
     foreach(_package_name ${${_package_visibility}_PACKAGE_NAMES})
       if(${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS)
         list(REMOVE_DUPLICATES ${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS)
       endif()
       set(${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS ${${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS} PARENT_SCOPE)
     endforeach()
   endforeach()
 
   set(PUBLIC_PACKAGE_NAMES ${PUBLIC_PACKAGE_NAMES} PARENT_SCOPE)
   set(PRIVATE_PACKAGE_NAMES ${PRIVATE_PACKAGE_NAMES} PARENT_SCOPE)
   set(INTERFACE_PACKAGE_NAMES ${INTERFACE_PACKAGE_NAMES} PARENT_SCOPE)
   set(PACKAGE_NAMES ${PUBLIC_PACKAGE_NAMES} ${PRIVATE_PACKAGE_NAMES} ${INTERFACE_PACKAGE_NAMES} PARENT_SCOPE)
 endfunction()
 
 function(_include_package_config pkg_config_file)
   # wrap the inclusion of the MITK_<pkg>_Config.cmake file in a
   # function to create a scope for its variables; this allows
   # multiple inclusions of the file in the parent scope
   include(${pkg_config_file})
   set(ALL_INCLUDE_DIRECTORIES ${ALL_INCLUDE_DIRECTORIES} PARENT_SCOPE)
   set(ALL_LIBRARIES ${ALL_LIBRARIES} PARENT_SCOPE)
   set(ALL_COMPILE_DEFINITIONS ${ALL_COMPILE_DEFINITIONS} PARENT_SCOPE)
 endfunction()
 
 #! This CMake function sets up the necessary include directories,
 #! linker dependencies, and compile flags for a given target which
 #! depends on a set of MITK modules or packages.
 #!
 #! A package argument is of the form
 #!
 #!   [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
 #!
 #! where PACKAGE is the package name (e.g. VTK) and components are
 #! the names of required package components or libraries.
 #!
 #! If a dependency is not available, an error is thrown.
 function(mitk_use_modules)
 
   set(_macro_params
       TARGET           # The target name (required)
      )
 
   set(_macro_multiparams
       MODULES          # MITK modules which the given TARGET uses
       PACKAGES         # MITK packages which the given TARGET uses
      )
 
   set(_macro_options )
 
   cmake_parse_arguments(USE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
 
   # Sanity checks
   if(NOT USE_TARGET)
     message(SEND_ERROR "Required TARGET argument missing.")
   elseif(NOT TARGET ${USE_TARGET})
     message(SEND_ERROR "The given TARGET argument ${USE_TARGET} is not a valid target")
   endif()
 
   set(depends ${USE_MODULES})
   set(package_depends ${USE_PACKAGES})
 
   if(depends)
     # Iterate over all module dependencies
     foreach(dependency ${depends})
       if(TARGET ${dependency} AND NOT MODULE_IS_DEPRECATED)
         get_target_property(_dependency_deprecated_since ${dependency} MITK_MODULE_DEPRECATED_SINCE)
         if(_dependency_deprecated_since)
           message(WARNING "Module ${dependency} is deprecated since ${_dependency_deprecated_since}")
         endif()
       endif()
     endforeach()
     target_link_libraries(${USE_TARGET} PUBLIC ${depends})
   endif()
 
   # Parse package dependencies
   if(package_depends)
     _mitk_parse_package_args(${package_depends})
 
     # Some package config files like MITK_Qt5_Config.cmake rely on a
     # properly set "MODULE_NAME" variable for the current target.
     set(MODULE_NAME ${USE_TARGET})
     # Read all package information
     foreach(_package_visibility INTERFACE PUBLIC PRIVATE)
     foreach(_package ${${_package_visibility}_PACKAGE_NAMES})
       set(ALL_INCLUDE_DIRECTORIES)
       set(ALL_LIBRARIES)
       set(ALL_COMPILE_DEFINITIONS)
-      set(ALL_META_DEPENDENCIES)
 
       set(${_package}_REQUIRED_COMPONENTS_BY_MODULE ${${_package_visibility}_${_package}_REQUIRED_COMPONENTS})
       set(_package_found 0)
       foreach(dir ${MODULES_PACKAGE_DEPENDS_DIRS})
         if((NOT DEFINED MITK_USE_${_package} OR MITK_USE_${_package}) AND EXISTS "${dir}/MITK_${_package}_Config.cmake")
           _include_package_config("${dir}/MITK_${_package}_Config.cmake")
           set(_package_found 1)
           break()
         endif()
       endforeach()
       if(_package_found)
         if(ALL_INCLUDE_DIRECTORIES)
           target_include_directories(${USE_TARGET} SYSTEM ${_package_visibility} ${ALL_INCLUDE_DIRECTORIES})
         endif()
         if(ALL_LIBRARIES)
           target_link_libraries(${USE_TARGET} ${_package_visibility} ${ALL_LIBRARIES})
         endif()
         if(ALL_COMPILE_DEFINITIONS)
           # we consider all compile definitions from external projects as "private",
           # meaning they are only needed for the implementation and not when using
           # this the header files from the MITK module
           target_compile_definitions(${USE_TARGET} PRIVATE ${ALL_COMPILE_DEFINITIONS})
         endif()
       else()
         message(SEND_ERROR "Missing package: ${_package}")
       endif()
     endforeach()
     endforeach()
   endif()
 endfunction()
diff --git a/CMake/mitkMacroCreateCTKPlugin.cmake b/CMake/mitkMacroCreateCTKPlugin.cmake
index ec00ecdf8f..ad22f58361 100644
--- a/CMake/mitkMacroCreateCTKPlugin.cmake
+++ b/CMake/mitkMacroCreateCTKPlugin.cmake
@@ -1,88 +1,84 @@
 macro(MACRO_CREATE_MITK_CTK_PLUGIN)
 
   cmake_parse_arguments(_PLUGIN "TEST_PLUGIN;NO_INSTALL" "EXPORT_DIRECTIVE" "EXPORTED_INCLUDE_SUFFIXES;MODULE_DEPENDENCIES;MODULE_DEPENDS;PACKAGE_DEPENDS;SUBPROJECTS" ${ARGN})
 
   mitk_check_module_dependencies(MODULES MitkCore ${_PLUGIN_MODULE_DEPENDENCIES} ${_PLUGIN_MODULE_DEPENDS}
                                  PACKAGES ${_PLUGIN_PACKAGE_DEPENDS}
                                  MISSING_DEPENDENCIES_VAR _missing_deps
                                  MODULE_DEPENDENCIES_VAR _module_deps
                                  PACKAGE_DEPENDENCIES_VAR _package_deps)
 
   if(_PLUGIN_MODULE_DEPENDENCIES)
     message(WARNING "The MODULE_DEPENDENCIES argument is deprecated since 2014.03. Please use MODULE_DEPENDS instead.")
   endif()
 
   if(NOT _missing_deps)
 
     if(_PLUGIN_TEST_PLUGIN)
       set(is_test_plugin "TEST_PLUGIN")
       set(_PLUGIN_NO_INSTALL 1)
     else()
       set(is_test_plugin)
     endif()
 
     if(_PLUGIN_NO_INSTALL)
       set(plugin_no_install "NO_INSTALL")
     else()
       set(plugin_no_install)
     endif()
 
     MACRO_CREATE_CTK_PLUGIN(EXPORT_DIRECTIVE ${_PLUGIN_EXPORT_DIRECTIVE}
                             EXPORTED_INCLUDE_SUFFIXES ${_PLUGIN_EXPORTED_INCLUDE_SUFFIXES}
                             DOXYGEN_TAGFILES ${_PLUGIN_DOXYGEN_TAGFILES}
                             MOC_OPTIONS -DBOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED
                             ${is_test_plugin} ${plugin_no_install})
 
     mitk_use_modules(TARGET ${PLUGIN_TARGET}
       MODULES MitkCore ${_PLUGIN_MODULE_DEPENDENCIES} ${_PLUGIN_MODULE_DEPENDS}
       PACKAGES ${_PLUGIN_PACKAGE_DEPENDS}
      )
 
     set_property(TARGET ${PLUGIN_TARGET} APPEND PROPERTY COMPILE_DEFINITIONS US_MODULE_NAME=${PLUGIN_TARGET})
     set_property(TARGET ${PLUGIN_TARGET} PROPERTY US_MODULE_NAME ${PLUGIN_TARGET})
 
-    if(ALL_META_DEPENDENCIES)
-      add_dependencies(${PLUGIN_TARGET} ${ALL_META_DEPENDENCIES})
-    endif()
-
     if(MITK_DEFAULT_SUBPROJECTS AND NOT MY_SUBPROJECTS)
       set(MY_SUBPROJECTS ${MITK_DEFAULT_SUBPROJECTS})
     endif()
 
     if(MY_SUBPROJECTS)
       set_property(TARGET ${PLUGIN_TARGET} PROPERTY LABELS ${MY_SUBPROJECTS})
       foreach(subproject ${MY_SUBPROJECTS})
         add_dependencies(${subproject} ${PLUGIN_TARGET})
       endforeach()
     endif()
 
     #------------------------------------------------------------#
     #------------------ Installer support -----------------------#
     if(NOT _PLUGIN_NO_INSTALL)
 
       set(_autoload_targets )
       foreach(_dependency ${_module_deps})
         get_target_property(_dep_autoloads ${_dependency} MITK_AUTOLOAD_TARGETS)
         if (_dep_autoloads)
           list(APPEND _autoload_targets ${_dep_autoloads})
         endif()
       endforeach()
 
       # The MITK_AUTOLOAD_TARGETS property is used in the mitkFunctionInstallAutoLoadModules
       # macro which expects a list of plug-in targets.
       if (_autoload_targets)
         list(REMOVE_DUPLICATES _autoload_targets)
         set_target_properties(${PLUGIN_TARGET} PROPERTIES MITK_AUTOLOAD_TARGETS "${_autoload_targets}")
       endif()
 
     endif()
 
   else()
     if(NOT MITK_BUILD_ALL_PLUGINS)
       message(SEND_ERROR "${PROJECT_NAME} is missing requirements and won't be built. Missing: ${_missing_deps}")
     else()
       message(STATUS "${PROJECT_NAME} is missing requirements and won't be built. Missing: ${_missing_deps}")
     endif()
   endif()
 endmacro()
 
diff --git a/CMake/mitkMacroCreateExecutable.cmake b/CMake/mitkMacroCreateExecutable.cmake
index 2d8a213296..3c55ff268c 100644
--- a/CMake/mitkMacroCreateExecutable.cmake
+++ b/CMake/mitkMacroCreateExecutable.cmake
@@ -1,104 +1,104 @@
 ##################################################################
 #
 # MITK_CREATE_EXECUTABLE
 #
 #! Creates an executable with MITK dependencies and batch files
 #! for proper application start-up.
 #!
 #! USAGE:
 #!
 #! \code
 #! MITK_CREATE_EXECUTABLE( [<exectuableName>]
 #!     [DEPENDS <modules we need>]
 #!     [PACKAGE_DEPENDS <packages we need, like ITK, VTK, QT>]
 #!     [INCLUDE_DIRS <list of additional include directories>]
 #!     [TARGET_DEPENDS <list of additional dependencies>
 #!     [WARNINGS_AS_ERRORS]
 #! \endcode
 #!
 #! \param EXECUTABLE_NAME The name for the new executable target
 ##################################################################
 macro(mitk_create_executable)
 
   set(_macro_params
       VERSION                # version number, e.g. "1.2.0"
       FILES_CMAKE            # file name of a CMake file setting source list variables
                              # (defaults to files.cmake)
       DESCRIPTION            # a description for the executable
      )
 
   set(_macro_multiparams
       SUBPROJECTS            # list of CDash labels
       INCLUDE_DIRS           # additional include dirs
       DEPENDS                # list of modules this module depends on
       PACKAGE_DEPENDS        # list of "packages" this module depends on (e.g. Qt, VTK, etc.)
       TARGET_DEPENDS         # list of CMake targets this executable should depend on
       ADDITIONAL_LIBS        # list of additional libraries linked to this executable
       CPP_FILES              # (optional) list of cpp files
      )
 
   set(_macro_options
       NO_INIT                # do not create CppMicroServices initialization code
       NO_FEATURE_INFO        # do not create a feature info by calling add_feature_info()
       NO_BATCH_FILE          # do not create batch files on Windows
       WARNINGS_AS_ERRORS     # treat all compiler warnings as errors
      )
 
   cmake_parse_arguments(EXEC "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
 
   set(_EXEC_OPTIONS EXECUTABLE)
   if(EXEC_NO_INIT)
     list(APPEND _EXEC_OPTIONS NO_INIT)
   endif()
   if(EXEC_WARNINGS_AS_ERRORS)
     list(APPEND _EXEC_OPTIONS WARNINGS_AS_ERRORS)
   endif()
   if(EXEC_NO_FEATURE_INFO)
     list(APPEND _EXEC_OPTIONS NO_FEATURE_INFO)
   endif()
 
   mitk_create_module(${EXEC_UNPARSED_ARGUMENTS}
                      SUBPROJECTS ${EXEC_SUBPROJECTS}
                      VERSION ${EXEC_VERSION}
                      INCLUDE_DIRS ${EXEC_INCLUDE_DIRS}
                      DEPENDS ${EXEC_DEPENDS}
                      PACKAGE_DEPENDS ${EXEC_PACKAGE_DEPENDS}
                      TARGET_DEPENDS ${EXEC_TARGET_DEPENDS}
                      ADDITIONAL_LIBS ${EXEC_ADDITIONAL_LIBS}
                      FILES_CMAKE ${EXEC_FILES_CMAKE}
                      CPP_FILES ${EXEC_CPP_FILES}
                      DESCRIPTION "${DESCRIPTION}"
                      ${_EXEC_OPTIONS}
                     )
 
   set(EXECUTABLE_IS_ENABLED ${MODULE_IS_ENABLED})
   set(EXECUTABLE_TARGET ${MODULE_TARGET})
   if(MODULE_IS_ENABLED)
     # Add meta dependencies (e.g. on auto-load modules from depending modules)
-    if(ALL_META_DEPENDENCIES)
-      add_dependencies(${MODULE_TARGET} ${ALL_META_DEPENDENCIES})
+    if(TARGET ${CMAKE_PROJECT_NAME}-autoload)
+      add_dependencies(${MODULE_TARGET} ${CMAKE_PROJECT_NAME}-autoload)
     endif()
 
     # Create batch files for Windows platforms
     if(WIN32)
       set(_batch_file_in "${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_TARGET}.bat.in")
       if(NOT EXISTS "${_batch_file_in}")
         set(_batch_file_in "${MITK_CMAKE_DIR}/StartApp.bat.in")
       endif()
       if(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
         set(_batch_file_out_dir "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
       else()
         set(_batch_file_out_dir "${CMAKE_CURRENT_BINARY_DIR}")
       endif()
       if(NOT EXEC_NO_BATCH_FILE)
         foreach(BUILD_TYPE debug release)
           mitkFunctionCreateWindowsBatchScript(
               ${_batch_file_in} ${_batch_file_out_dir}/${MODULE_TARGET}_${BUILD_TYPE}.bat
               ${BUILD_TYPE}
              )
         endforeach()
       endif()
     endif()
   endif()
 
 endmacro()