diff --git a/Applications/PluginGenerator/PluginTemplate/documentation/UserManual/icon.xpm b/Applications/PluginGenerator/PluginTemplate/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Applications/PluginGenerator/PluginTemplate/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/CMake/FindAnt.cmake b/CMake/FindAnt.cmake
deleted file mode 100644
index b96ef5e74e..0000000000
--- a/CMake/FindAnt.cmake
+++ /dev/null
@@ -1,16 +0,0 @@
-# - Find Ant (a java build tool)
-# This module defines
-# ANT_VERSION version string of ant if found
-# ANT_FOUND, If false, do not try to use ant
-
-exec_program(ant ARGS -version OUTPUT_VARIABLE ANT_VERSION
-             RETURN_VALUE ANT_RETURN)
-
-if(ANT_RETURN STREQUAL "0")
-  set(ANT_FOUND TRUE)
-  if(NOT ANT_FIND_QUIETLY)
-    message(STATUS "Found Ant: ${ANT_VERSION}")
-  endif(NOT ANT_FIND_QUIETLY)
-else(ANT_RETURN STREQUAL "0")
-  set(ANT_FOUND FALSE)
-endif(ANT_RETURN STREQUAL "0")
\ No newline at end of file
diff --git a/CMake/mitkFunctionConvertXPSchema.cmake b/CMake/mitkFunctionConvertXPSchema.cmake
deleted file mode 100644
index 681e31bee5..0000000000
--- a/CMake/mitkFunctionConvertXPSchema.cmake
+++ /dev/null
@@ -1,47 +0,0 @@
-# mitkFunctionConvertXPSchema(INPUT plugin.xml ...
-#                      OUTPUT_DIR output_dir
-#                      TARGET_NAME target_name
-#                      [DEPENDS depends]
-#                      [WORKING_DIR working_dir]
-#                     )
-function(mitkFunctionConvertXPSchema)
-
-  set(_macro_options
-  )
-
-  set(_macro_params
-    OUTPUT_DIR
-    TARGET_NAME
-    WORKING_DIR
-  )
-
-  set(_macro_multiparams
-   INPUT
-   DEPENDS
-  )
-
-  cmake_parse_arguments(_SCHEMA "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
-
-  set(XP_ANT_TASKS)
-  foreach(_file ${_SCHEMA_INPUT})
-    set(XP_ANT_TASKS "${XP_ANT_TASKS}
-      <pde.convertSchemaToHTML manifest=\"${_file}\" destination=\"\${dest}\" />"
-      )
-  endforeach()
-
-  set(XP_DOC_DESTINATION "${_SCHEMA_OUTPUT_DIR}")
-
-  if(NOT _SCHEMA_WORKING_DIR)
-    set(_SCHEMA_WORKING_DIR ${CMAKE_CURRENT_BINARY_DIR})
-  endif()
-
-  configure_file("${CMAKE_CURRENT_LIST_DIR}/buildExtPointDoc.xml.in"
-                 "${_SCHEMA_WORKING_DIR}/buildExtPointDoc.xml" @ONLY)
-
-  add_custom_target(${_SCHEMA_TARGET_NAME}
-                    ant -f ${_SCHEMA_WORKING_DIR}/buildExtPointDoc.xml
-                    DEPENDS ${_SCHEMA_DEPENDS}
-                    WORKING_DIRECTORY ${_SCHEMA_WORKING_DIR}
-                    VERBATIM)
-
-endfunction()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 007d516d5f..9b48f04793 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,1414 +1,1413 @@
 set(MITK_CMAKE_MINIMUM_REQUIRED_VERSION 3.14.5)
 cmake_minimum_required(VERSION ${MITK_CMAKE_MINIMUM_REQUIRED_VERSION})
 
 #-----------------------------------------------------------------------------
 # See https://cmake.org/cmake/help/v3.14/manual/cmake-policies.7.html for details
 #-----------------------------------------------------------------------------
 
 set(project_policies )
 foreach(policy ${project_policies})
   if(POLICY ${policy})
     cmake_policy(SET ${policy} NEW)
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # 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 VERSION 2018.04.99)
   include_directories(SYSTEM ${MITK_SUPERBUILD_BINARY_DIR})
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK Extension Feature
 #-----------------------------------------------------------------------------
 
 set(MITK_EXTENSION_DIRS "" CACHE STRING "")
 
 unset(MITK_ABSOLUTE_EXTENSION_DIRS)
 
 foreach(MITK_EXTENSION_DIR ${MITK_EXTENSION_DIRS})
   get_filename_component(MITK_ABSOLUTE_EXTENSION_DIR "${MITK_EXTENSION_DIR}" ABSOLUTE)
   list(APPEND MITK_ABSOLUTE_EXTENSION_DIRS "${MITK_ABSOLUTE_EXTENSION_DIR}")
 endforeach()
 
 set(MITK_DIR_PLUS_EXTENSION_DIRS "${MITK_SOURCE_DIR}" ${MITK_ABSOLUTE_EXTENSION_DIRS})
 
 #-----------------------------------------------------------------------------
 # Update CMake module path
 #-----------------------------------------------------------------------------
 
 set(MITK_CMAKE_DIR ${MITK_SOURCE_DIR}/CMake)
 
 set(CMAKE_MODULE_PATH ${MITK_CMAKE_DIR})
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   set(MITK_CMAKE_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMake")
   if(EXISTS "${MITK_CMAKE_EXTENSION_DIR}")
     list(APPEND CMAKE_MODULE_PATH "${MITK_CMAKE_EXTENSION_DIR}")
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 # Standard CMake macros
 include(FeatureSummary)
 include(CTest)
 include(CMakeParseArguments)
 include(FindPackageHandleStandardArgs)
 
 # MITK macros
 include(mitkFunctionGetGccVersion)
 include(mitkFunctionCheckCompilerFlags)
 include(mitkFunctionSuppressWarnings) # includes several functions
 include(mitkMacroEmptyExternalProject)
 include(mitkFunctionEnableBuildConfiguration)
 include(mitkFunctionWhitelists)
 include(mitkFunctionAddExternalProject)
 include(mitkFunctionAddLibrarySearchPaths)
 
 SUPPRESS_VC_DEPRECATED_WARNINGS()
 
 #-----------------------------------------------------------------------------
 # Set a default build type if none was specified
 #-----------------------------------------------------------------------------
 
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to 'Debug' as none was specified.")
   set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
 
   # Set the possible values of build type for cmake-gui
   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
                STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
 endif()
 
 #-----------------------------------------------------------------------------
 # Check miminum macOS version
 #-----------------------------------------------------------------------------
 # The minimum supported macOS version is 10.13. If you use a version less than 10.13, there is no guarantee that the build still works.
 if(APPLE)
   exec_program(sw_vers ARGS -productVersion OUTPUT_VARIABLE macos_version)
   if (macos_version VERSION_LESS "10.13")
     message(WARNING "Detected macOS version \"${macos_version}\" is not supported anymore. Minimum required macOS version is at least 10.13.")
   endif()
   if (CMAKE_OSX_DEPLOYMENT_TARGET AND CMAKE_OSX_DEPLOYMENT_TARGET VERSION_LESS 10.13)
     message(WARNING "Detected macOS deployment target \"${CMAKE_OSX_DEPLOYMENT_TARGET}\" is not supported anymore. Minimum required macOS version is at least 10.13.")
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Check miminum compiler versions
 #-----------------------------------------------------------------------------
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
   # require at least gcc 4.9 as provided by ppa:ubuntu-toolchain-r/test for Ubuntu 14.04
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
     message(FATAL_ERROR "GCC version must be at least 4.9
 If you are using Ubuntu 14.04, you can easily install gcc and g++ 4.9 (or any later version available) in addition to your version ${CMAKE_CXX_COMPILER_VERSION}:
   sudo add-apt-repository ppa:ubuntu-toolchain-r/test
   sudo apt-get update
   sudo apt-get install gcc-4.9 g++-4.9
 Make sure to explicitly specify these compilers when configuring MITK:
   CMAKE_C_COMPILER:FILEPATH=/usr/bin/gcc-4.9
   CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/g++-4.9
 For more information on the proposed PPA see the Toolchain Updates section of https://wiki.ubuntu.com/ToolChain.")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
   # require at least clang 3.4
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
     message(FATAL_ERROR "Clang version must be at least 3.4")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
   # require at least clang 5.0
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
     message(FATAL_ERROR "Apple Clang version must be at least 5.0")
   endif()
 elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
   # require at least Visual Studio 2017
   if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10)
     message(FATAL_ERROR "Microsoft Visual Studio 2017 or newer required")
   endif()
 else()
   message(WARNING "You are using an unsupported compiler! Compilation has only been tested with Clang (Linux or Apple), GCC and MSVC.")
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
 else()
   set(GCC_VERSION 0)
 endif()
 
 set(MITK_CXX_STANDARD 14)
 
 set(CMAKE_CXX_EXTENSIONS 0)
 set(CMAKE_CXX_STANDARD ${MITK_CXX_STANDARD})
 set(CMAKE_CXX_STANDARD_REQUIRED 1)
 
 # This is necessary to avoid problems with compile feature checks.
 # CMAKE_CXX_STANDARD seems to only set the -std=c++14 flag for targets.
 # However, compile flag checks also need to be done with -std=c++14.
 # The MITK_CXX14_FLAG variable is also used for external projects
 # build during the MITK super-build.
 mitkFunctionCheckCompilerFlags("-std=c++14" MITK_CXX14_FLAG)
 
 #-----------------------------------------------------------------------------
 # Warn if source or build path is too long
 #-----------------------------------------------------------------------------
 
 if(WIN32)
   set(_src_dir_length_max 50)
   set(_bin_dir_length_max 50)
   if(MITK_USE_SUPERBUILD)
     set(_src_dir_length_max 34) # _src_dir_length_max - strlen(ep/src/ITK-build)
     set(_bin_dir_length_max 40) # _bin_dir_length_max - strlen(MITK-build)
   endif()
 
   string(LENGTH "${MITK_SOURCE_DIR}" _src_n)
   string(LENGTH "${MITK_BINARY_DIR}" _bin_n)
 
   # The warnings should be converted to errors
   if(_src_n GREATER _src_dir_length_max)
     message(WARNING "MITK source code directory path length is too long (${_src_n} > ${_src_dir_length_max})."
                     "Please move the MITK source code directory to a directory with a shorter path." )
   endif()
   if(_bin_n GREATER _bin_dir_length_max)
     message(WARNING "MITK build directory path length is too long (${_bin_n} > ${_bin_dir_length_max})."
                     "Please move the MITK build directory to a directory with a shorter path." )
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Additional MITK Options (also shown during superbuild)
 #-----------------------------------------------------------------------------
 
 # -----------------------------------------
 # General build options
 option(BUILD_SHARED_LIBS "Build MITK with shared libraries" ON)
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 option(BUILD_TESTING "Test the project" ON)
 option(MITK_FAST_TESTING "Disable long-running tests like packaging" OFF)
 option(MITK_XVFB_TESTING "Execute test drivers through xvfb-run" OFF)
 
 option(MITK_BUILD_ALL_APPS "Build all MITK applications" OFF)
 option(MITK_BUILD_EXAMPLES "Build the MITK Examples" OFF)
 option(MITK_ENABLE_PIC_READER "Enable support for reading the DKFZ pic file format." ON)
 
 mark_as_advanced(
   MITK_XVFB_TESTING
   MITK_FAST_TESTING
   MITK_BUILD_ALL_APPS
   MITK_ENABLE_PIC_READER
 )
 
 #-----------------------------------------------------------------------------
 # Set UI testing flags
 #-----------------------------------------------------------------------------
 if(MITK_XVFB_TESTING)
   set(MITK_XVFB_TESTING_COMMAND "xvfb-run" "--auto-servernum" CACHE STRING "Command and options to test through Xvfb")
   mark_as_advanced(MITK_XVFB_TESTING_COMMAND)
 endif(MITK_XVFB_TESTING)
 
 # -----------------------------------------
 # Other options
 set(MITK_CUSTOM_REVISION_DESC "" CACHE STRING "Override MITK revision description")
 mark_as_advanced(MITK_CUSTOM_REVISION_DESC)
 
 set_property(GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS "")
 
 include(CMakeExternals/ExternalProjectList.cmake)
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   set(MITK_CMAKE_EXTERNALS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMakeExternals")
   if(EXISTS "${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/ExternalProjectList.cmake")
     include("${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/ExternalProjectList.cmake")
   endif()
 endforeach()
 
 # -----------------------------------------
 # Other MITK_USE_* options not related to
 # external projects build via the
 # MITK superbuild
 
 option(MITK_USE_BLUEBERRY "Build the BlueBerry platform" ON)
 option(MITK_USE_OpenCL "Use OpenCL GPU-Computing library" OFF)
 option(MITK_USE_OpenMP "Use OpenMP" OFF)
 option(MITK_USE_Python3 "Use Python 3" OFF)
 
 #-----------------------------------------------------------------------------
 # Build configurations
 #-----------------------------------------------------------------------------
 
 set(_buildConfigs "Custom")
 
 file(GLOB _buildConfigFiles CMake/BuildConfigurations/*.cmake)
 
 foreach(_buildConfigFile ${_buildConfigFiles})
   get_filename_component(_buildConfigFile ${_buildConfigFile} NAME_WE)
   list(APPEND _buildConfigs ${_buildConfigFile})
 endforeach()
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   file(GLOB _extBuildConfigFiles "${MITK_EXTENSION_DIR}/CMake/BuildConfigurations/*.cmake")
 
   foreach(_extBuildConfigFile ${_extBuildConfigFiles})
     get_filename_component(_extBuildConfigFile "${_extBuildConfigFile}" NAME_WE)
     list(APPEND _buildConfigs "${_extBuildConfigFile}")
   endforeach()
 
   list(REMOVE_DUPLICATES _buildConfigs)
 endforeach()
 
 set(MITK_BUILD_CONFIGURATION "Custom" CACHE STRING "Use pre-defined MITK configurations")
 set_property(CACHE MITK_BUILD_CONFIGURATION PROPERTY STRINGS ${_buildConfigs})
 
 mitkFunctionEnableBuildConfiguration()
 
 mitkFunctionCreateWhitelistPaths(MITK)
 mitkFunctionFindWhitelists(MITK)
 
 # -----------------------------------------
 # Qt version related variables
 
 option(MITK_USE_Qt5 "Use Qt 5 library" ON)
 
 if(MITK_USE_Qt5)
   set(MITK_QT5_MINIMUM_VERSION 5.12)
   set(MITK_QT5_COMPONENTS Concurrent OpenGL PrintSupport Script Sql Svg Widgets Xml XmlPatterns WebEngineWidgets UiTools Help LinguistTools)
   if(APPLE)
     list(APPEND MITK_QT5_COMPONENTS DBus)
   elseif(UNIX)
     list(APPEND MITK_QT5_COMPONENTS X11Extras)
   endif()
 
   # Hint at default install locations of Qt
   if(NOT Qt5_DIR)
     if(MSVC)
       set(_dir_candidates "C:/Qt")
 
       if(CMAKE_GENERATOR MATCHES "^Visual Studio [0-9]+ ([0-9]+)")
         set(_compilers "msvc${CMAKE_MATCH_1}")
       elseif(CMAKE_GENERATOR MATCHES "Ninja")
         include(mitkFunctionGetMSVCVersion)
         mitkFunctionGetMSVCVersion()
         if(VISUAL_STUDIO_PRODUCT_NAME MATCHES "^Visual Studio ([0-9]+)")
           set(_compilers "msvc${CMAKE_MATCH_1}")
         endif()
       endif()
 
       if(_compilers MATCHES "[0-9]+")
         if (CMAKE_MATCH_0 EQUAL 2019)
           list(APPEND _compilers "msvc2017") # Binary compatible to 2019
         endif()
       endif()
     else()
       set(_dir_candidates ~/Qt)
 
       if(APPLE)
         set(_compilers clang)
       else()
         list(APPEND _dir_candidates /opt/Qt)
         set(_compilers gcc)
       endif()
     endif()
 
     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
       foreach(_compiler ${_compilers})
         list(APPEND _compilers64 "${_compiler}_64")
       endforeach()
       set(_compilers ${_compilers64})
     endif()
 
     foreach(_dir_candidate ${_dir_candidates})
       get_filename_component(_dir_candidate ${_dir_candidate} REALPATH)
       foreach(_compiler ${_compilers})
         set(_glob_expression "${_dir_candidate}/5.*/${_compiler}")
         file(GLOB _hints ${_glob_expression})
         list(SORT _hints)
         list(APPEND MITK_QT5_HINTS ${_hints})
       endforeach()
     endforeach()
   endif()
 
   find_package(Qt5 ${MITK_QT5_MINIMUM_VERSION} COMPONENTS ${MITK_QT5_COMPONENTS} REQUIRED HINTS ${MITK_QT5_HINTS})
 
   if(${Qt5_VERSION} VERSION_GREATER_EQUAL 5.13)
     message(WARNING "Qt version ${Qt5_VERSION_MAJOR}.${Qt5_VERSION_MINOR} is not yet supported. We recommend using version 5.12.x.")
   endif()
 endif()
 
 # -----------------------------------------
 # Custom dependency logic
 
 option(MITK_USE_SYSTEM_Boost "Use the system Boost" OFF)
 
 set(MITK_USE_Boost_LIBRARIES "" CACHE STRING "A semi-colon separated list of required Boost libraries")
 
 if(MITK_USE_cpprestsdk)
   find_package(OpenSSL QUIET)
   if(NOT OpenSSL_FOUND)
     set(openssl_message "Could not find OpenSSL (dependency of C++ REST SDK).\n")
     if(UNIX)
       if(APPLE)
         set(openssl_message "${openssl_message}Please install it using your favorite package management "
                             "system (i.e. Homebrew or MacPorts).\n")
       else()
         set(openssl_message "${openssl_message}Please install the dev package of OpenSSL (i.e. libssl-dev).\n")
       endif()
     else()
       set(openssl_message "${openssl_message}Please install Win32 OpenSSL:\n"
                           "  https://slproweb.com/products/Win32OpenSSL.html\n")
     endif()
     set(openssl_message "${openssl_message}If it still cannot be found, you can hint CMake to find OpenSSL by "
                         "adding/setting the OPENSSL_ROOT_DIR variable to the root directory of an "
                         "OpenSSL installation. Make sure to clear variables of partly found "
                         "versions of OpenSSL before, or they will be mixed up.")
     message(FATAL_ERROR ${openssl_message})
   endif()
 
   list(APPEND MITK_USE_Boost_LIBRARIES date_time regex system)
   if(UNIX)
     list(APPEND MITK_USE_Boost_LIBRARIES atomic chrono filesystem random thread)
   endif()
   list(REMOVE_DUPLICATES MITK_USE_Boost_LIBRARIES)
   set(MITK_USE_Boost_LIBRARIES ${MITK_USE_Boost_LIBRARIES} CACHE STRING "A semi-colon separated list of required Boost libraries" FORCE)
 endif()
 
 if(MITK_USE_Python3)
   set(MITK_USE_ZLIB ON CACHE BOOL "" FORCE)
 
   if(APPLE AND CMAKE_FRAMEWORK_PATH AND CMAKE_FRAMEWORK_PATH MATCHES "python3\\.?([0-9]+)")
     find_package(Python3 3.${CMAKE_MATCH_1} EXACT REQUIRED COMPONENTS Interpreter Development NumPy)
   else()
     find_package(Python3 REQUIRED COMPONENTS Interpreter Development NumPy)
   endif()
 
   if(WIN32)
     string(REPLACE "\\" "/" Python3_STDARCH "${Python3_STDARCH}")
     string(REPLACE "\\" "/" Python3_STDLIB "${Python3_STDLIB}")
     string(REPLACE "\\" "/" Python3_SITELIB "${Python3_SITELIB}")
   endif()
 endif()
 
 if(BUILD_TESTING AND NOT MITK_USE_CppUnit)
   message("> Forcing MITK_USE_CppUnit to ON because BUILD_TESTING=ON")
   set(MITK_USE_CppUnit ON CACHE BOOL "Use CppUnit for unit tests" FORCE)
 endif()
 
 if(MITK_USE_BLUEBERRY)
   option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
   mark_as_advanced(MITK_BUILD_ALL_PLUGINS)
 
   if(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()
 endif()
 
 #-----------------------------------------------------------------------------
 # Pixel type multiplexing
 #-----------------------------------------------------------------------------
 
 # Customize the default pixel types for multiplex macros
 
 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
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     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")
 
 mark_as_advanced(MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES
                  MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
                  MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
                  MITK_ACCESSBYITK_DIMENSIONS
                 )
 
 # consistency checks
 
 if(NOT MITK_ACCESSBYITK_INTEGRAL_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" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES
       "double, float"
       CACHE STRING "List of floating pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES
     "itk::RGBPixel<unsigned char>, itk::RGBAPixel<unsigned char>"
     CACHE STRING "List of composite pixel types used in AccessByItk and InstantiateAccessFunction macros" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
   string(REPLACE "," ";" _integral_types ${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES})
   string(REPLACE "," ";" _floating_types ${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES})
   foreach(_scalar_type ${_integral_types} ${_floating_types})
     set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES
         "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}itk::VariableLengthVector<${_scalar_type}>,")
   endforeach()
   string(LENGTH "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" _length)
   math(EXPR _length "${_length} - 1")
   string(SUBSTRING "${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}" 0 ${_length} MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES)
   set(MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES ${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
       CACHE STRING "List of vector pixel types used in AccessByItk and InstantiateAccessFunction macros for itk::VectorImage types" FORCE)
 endif()
 
 if(NOT MITK_ACCESSBYITK_DIMENSIONS)
   set(MITK_ACCESSBYITK_DIMENSIONS
       "2,3"
       CACHE STRING "List of dimensions used in AccessByItk and InstantiateAccessFunction macros")
 endif()
 
 find_package(Git REQUIRED)
 
 #-----------------------------------------------------------------------------
 # Superbuild script
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_SUPERBUILD)
   include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
 
   # Print configuration summary
   message("\n\n")
   feature_summary(
     DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
     WHAT ALL)
   return()
 endif()
 
 #*****************************************************************************
 #****************************  END OF SUPERBUILD  ****************************
 #*****************************************************************************
 
 #-----------------------------------------------------------------------------
 # Organize MITK targets in folders
 #-----------------------------------------------------------------------------
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 set(MITK_ROOT_FOLDER "MITK" CACHE STRING "")
 mark_as_advanced(MITK_ROOT_FOLDER)
 
 #-----------------------------------------------------------------------------
 # CMake function(s) and macro(s)
 #-----------------------------------------------------------------------------
 
 include(WriteBasicConfigVersionFile)
 include(CheckCXXSourceCompiles)
 include(GenerateExportHeader)
 
 include(mitkFunctionAddCustomModuleTest)
 include(mitkFunctionCheckModuleDependencies)
 include(mitkFunctionCompileSnippets)
 include(mitkFunctionConfigureVisualStudioUserProjectFile)
-include(mitkFunctionConvertXPSchema)
 include(mitkFunctionCreateBlueBerryApplication)
 include(mitkFunctionCreateCommandLineApp)
 include(mitkFunctionCreateModule)
 include(mitkFunctionCreatePlugin)
 include(mitkFunctionCreateProvisioningFile)
 include(mitkFunctionGetLibrarySearchPaths)
 include(mitkFunctionGetVersion)
 include(mitkFunctionGetVersionDescription)
 include(mitkFunctionInstallAutoLoadModules)
 include(mitkFunctionInstallCTKPlugin)
 include(mitkFunctionInstallProvisioningFiles)
 include(mitkFunctionInstallThirdPartyCTKPlugins)
 include(mitkFunctionOrganizeSources)
 include(mitkFunctionUseModules)
 if( ${MITK_USE_MatchPoint} )
   include(mitkFunctionCreateMatchPointDeployedAlgorithm)
 endif()
 include(mitkMacroConfigureItkPixelTypes)
 include(mitkMacroCreateExecutable)
 include(mitkMacroCreateModuleTests)
 include(mitkMacroGenerateToolsLibrary)
 include(mitkMacroGetLinuxDistribution)
 include(mitkMacroGetPMDPlatformString)
 include(mitkMacroInstall)
 include(mitkMacroInstallHelperApp)
 include(mitkMacroInstallTargets)
 include(mitkMacroMultiplexPicType)
 
 # Deprecated
 include(mitkMacroCreateCTKPlugin)
 
 #-----------------------------------------------------------------------------
 # Global CMake variables
 #-----------------------------------------------------------------------------
 
 # Required and enabled C++14 features for all MITK code.
 # These are added as PUBLIC compile features to all MITK modules.
 set(MITK_CXX_FEATURES
   cxx_auto_type
   cxx_decltype
   cxx_enum_forward_declarations
   cxx_extended_friend_declarations
   cxx_extern_templates
   cxx_final
   cxx_lambdas
   cxx_local_type_template_args
   cxx_long_long_type
   cxx_nullptr
   cxx_override
   cxx_range_for
   cxx_right_angle_brackets
   cxx_rvalue_references
   cxx_static_assert
   cxx_strong_enums
   cxx_template_template_parameters
   cxx_trailing_return_types
   cxx_variadic_macros
 )
 
 if(NOT DEFINED CMAKE_DEBUG_POSTFIX)
   # We can't do this yet because the CTK Plugin Framework
   # cannot cope with a postfix yet.
   #set(CMAKE_DEBUG_POSTFIX d)
 endif()
 
 #-----------------------------------------------------------------------------
 # Output directories.
 #-----------------------------------------------------------------------------
 
 set(_default_LIBRARY_output_dir lib)
 set(_default_RUNTIME_output_dir bin)
 set(_default_ARCHIVE_output_dir lib)
 
 foreach(type LIBRARY RUNTIME ARCHIVE)
   # Make sure the directory exists
   if(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_CMAKE_${type}_OUTPUT_DIRECTORY)
     set(CMAKE_${type}_OUTPUT_DIRECTORY ${MITK_CMAKE_${type}_OUTPUT_DIRECTORY})
   else()
     set(CMAKE_${type}_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${_default_${type}_output_dir})
     set(MITK_CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY})
   endif()
 
   set(CMAKE_${type}_OUTPUT_DIRECTORY ${CMAKE_${type}_OUTPUT_DIRECTORY} CACHE INTERNAL "Output directory for ${type} files.")
   mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Set MITK specific options and variables (NOT available during superbuild)
 #-----------------------------------------------------------------------------
 
 # Look for optional Doxygen package
 find_package(Doxygen)
 
 option(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF)
 mark_as_advanced(BLUEBERRY_DEBUG_SMARTPOINTER)
 
 # Ask the user to show the console window for applications
 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)
 
 if(NOT MITK_FAST_TESTING)
   if(MITK_CTEST_SCRIPT_MODE STREQUAL "Continuous" OR MITK_CTEST_SCRIPT_MODE STREQUAL "Experimental")
     set(MITK_FAST_TESTING ON)
   endif()
 endif()
 
 if(NOT UNIX)
   set(MITK_WIN32_FORCE_STATIC "STATIC" CACHE INTERNAL "Use this variable to always build static libraries on non-unix platforms")
 endif()
 
 if(MITK_BUILD_ALL_PLUGINS)
   set(MITK_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 endif()
 
 # Configure pixel types used for ITK image access multiplexing
 mitkMacroConfigureItkPixelTypes()
 
 # Configure module naming conventions
 set(MITK_MODULE_NAME_REGEX_MATCH "^[A-Z].*$")
 set(MITK_MODULE_NAME_REGEX_NOT_MATCH "^[Mm][Ii][Tt][Kk].*$")
 set(MITK_DEFAULT_MODULE_NAME_PREFIX "Mitk")
 set(MITK_MODULE_NAME_PREFIX ${MITK_DEFAULT_MODULE_NAME_PREFIX})
 set(MITK_MODULE_NAME_DEFAULTS_TO_DIRECTORY_NAME 1)
 
 #-----------------------------------------------------------------------------
 # Get MITK version info
 #-----------------------------------------------------------------------------
 
 mitkFunctionGetVersion(${MITK_SOURCE_DIR} MITK)
 mitkFunctionGetVersionDescription(${MITK_SOURCE_DIR} MITK)
 
 # MITK_VERSION
 set(MITK_VERSION_STRING "${MITK_VERSION_MAJOR}.${MITK_VERSION_MINOR}.${MITK_VERSION_PATCH}")
 if(MITK_VERSION_PATCH STREQUAL "99")
   set(MITK_VERSION_STRING "${MITK_VERSION_STRING}-${MITK_REVISION_SHORTID}")
 endif()
 
 #-----------------------------------------------------------------------------
 # Installation preparation
 #
 # These should be set before any MITK install macros are used
 #-----------------------------------------------------------------------------
 
 # on macOS all BlueBerry plugins get copied into every
 # application bundle (.app directory) specified here
 if(MITK_USE_BLUEBERRY AND APPLE)
 
   foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
     set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
     if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
       set(MITK_APPS "")
       include("${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
       foreach(mitk_app ${MITK_APPS})
         # extract option_name
         string(REPLACE "^^" "\\;" target_info ${mitk_app})
         set(target_info_list ${target_info})
         list(GET target_info_list 1 option_name)
         list(GET target_info_list 0 app_name)
         # check if the application is enabled
         if(${option_name} OR MITK_BUILD_ALL_APPS)
           set(MACOSX_BUNDLE_NAMES ${MACOSX_BUNDLE_NAMES} Mitk${app_name})
         endif()
       endforeach()
     endif()
   endforeach()
 
 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}")
 set(MITK_C_FLAGS_DEBUG )
 set(MITK_C_FLAGS_RELEASE )
 set(MITK_CXX_FLAGS "${COVERAGE_CXX_FLAGS} ${MITK_CXX14_FLAG}")
 set(MITK_CXX_FLAGS_DEBUG )
 set(MITK_CXX_FLAGS_RELEASE )
 
 set(MITK_EXE_LINKER_FLAGS )
 set(MITK_SHARED_LINKER_FLAGS )
 
 if(WIN32)
   set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN -DNOMINMAX")
   mitkFunctionCheckCompilerFlags("/wd4005" MITK_CXX_FLAGS) # warning C4005: macro redefinition
   mitkFunctionCheckCompilerFlags("/wd4231" MITK_CXX_FLAGS) # warning C4231: nonstandard extension used : 'extern' before template explicit instantiation
   # the following line should be removed after fixing bug 17637
   mitkFunctionCheckCompilerFlags("/wd4316" MITK_CXX_FLAGS) # warning C4316: object alignment on heap
   mitkFunctionCheckCompilerFlags("/wd4180" MITK_CXX_FLAGS) # warning C4180: qualifier applied to function type has no meaning
   mitkFunctionCheckCompilerFlags("/wd4251" MITK_CXX_FLAGS) # warning C4251: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
 endif()
 
 if(APPLE)
   set(MITK_CXX_FLAGS "${MITK_CXX_FLAGS} -DGL_SILENCE_DEPRECATION") # Apple deprecated OpenGL in macOS 10.14
 endif()
 
 if(NOT MSVC_VERSION)
   foreach(_flag
     -Wall
     -Wextra
     -Wpointer-arith
     -Winvalid-pch
     -Wcast-align
     -Wwrite-strings
     -Wno-error=gnu
     -Wno-error=unknown-pragmas
     # The strict-overflow warning is generated by ITK template code
     -Wno-error=strict-overflow
     -Woverloaded-virtual
     -Wstrict-null-sentinel
     #-Wold-style-cast
     #-Wsign-promo
     -Wno-error=deprecated-copy
     -Wno-array-bounds
 
     -fdiagnostics-show-option
     )
     mitkFunctionCheckCAndCXXCompilerFlags(${_flag} MITK_C_FLAGS MITK_CXX_FLAGS)
   endforeach()
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE)
   mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" MITK_SHARED_LINKER_FLAGS)
   mitkFunctionCheckCompilerFlags("-Wl,--as-needed" MITK_SHARED_LINKER_FLAGS)
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
   mitkFunctionCheckCAndCXXCompilerFlags("-fstack-protector-all" MITK_C_FLAGS MITK_CXX_FLAGS)
   set(MITK_CXX_FLAGS_RELEASE "-U_FORTIFY_SOURCES -D_FORTIFY_SOURCE=2 ${MITK_CXX_FLAGS_RELEASE}")
 endif()
 
 set(MITK_MODULE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 set(MITK_EXE_LINKER_FLAGS ${MITK_SHARED_LINKER_FLAGS})
 
 #-----------------------------------------------------------------------------
 # MITK Packages
 #-----------------------------------------------------------------------------
 
 set(MITK_MODULES_PACKAGE_DEPENDS_DIR ${MITK_SOURCE_DIR}/CMake/PackageDepends)
 set(MODULES_PACKAGE_DEPENDS_DIRS ${MITK_MODULES_PACKAGE_DEPENDS_DIR})
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   set(MITK_PACKAGE_DEPENDS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMake/PackageDepends")
   if(EXISTS "${MITK_PACKAGE_DEPENDS_EXTENSION_DIR}")
     list(APPEND MODULES_PACKAGE_DEPENDS_DIRS "${MITK_PACKAGE_DEPENDS_EXTENSION_DIR}")
   endif()
 endforeach()
 
 if(NOT MITK_USE_SYSTEM_Boost)
   set(Boost_NO_SYSTEM_PATHS 1)
 endif()
 
 set(Boost_USE_MULTITHREADED 1)
 set(Boost_USE_STATIC_LIBS 0)
 set(Boost_USE_STATIC_RUNTIME 0)
 set(Boost_ADDITIONAL_VERSIONS 1.68 1.68.0)
 
 # We need this later for a DCMTK workaround
 set(_dcmtk_dir_orig ${DCMTK_DIR})
 
 # This property is populated at the top half of this file
 get_property(MITK_EXTERNAL_PROJECTS GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE)
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   if(MITK_USE_${ep} AND _package)
     if(_components)
       find_package(${_package} COMPONENTS ${_components} REQUIRED CONFIG)
     else()
       # Prefer config mode first because it finds external
       # <proj>Config.cmake files pointed at by <proj>_DIR variables.
       # Otherwise, existing Find<proj>.cmake files could fail.
 
       if(DEFINED ${_package}_DIR)
         #we store the information because it will be overwritten by find_package
         #and would get lost for all EPs that use on Find<proj>.cmake instead of config
         #files.
         set(_temp_EP_${_package}_dir ${${_package}_DIR})
       endif(DEFINED ${_package}_DIR)
 
       find_package(${_package} QUIET CONFIG)
       string(TOUPPER "${_package}" _package_uc)
       if(NOT (${_package}_FOUND OR ${_package_uc}_FOUND))
         if(DEFINED _temp_EP_${_package}_dir)
             set(${_package}_DIR ${_temp_EP_${_package}_dir} CACHE PATH "externaly set dir of the package ${_package}" FORCE)
         endif(DEFINED _temp_EP_${_package}_dir)
 
         find_package(${_package} REQUIRED)
       endif()
     endif()
   endif()
 endforeach()
 
 # Ensure that the MITK CMake module path comes first
 set(CMAKE_MODULE_PATH
   ${MITK_CMAKE_DIR}
   ${CMAKE_MODULE_PATH}
   )
 
 if(MITK_USE_DCMTK)
   # Due to the preferred CONFIG mode in find_package calls above,
   # the DCMTKConfig.cmake file is read, which does not provide useful
   # package information. We explictly need MODULE mode to find DCMTK.
   if(${_dcmtk_dir_orig} MATCHES "${MITK_EXTERNAL_PROJECT_PREFIX}.*")
     # Help our FindDCMTK.cmake script find our super-build DCMTK
     set(DCMTK_DIR ${MITK_EXTERNAL_PROJECT_PREFIX})
   else()
     # Use the original value
     set(DCMTK_DIR ${_dcmtk_dir_orig})
   endif()
   find_package(DCMTK REQUIRED MODULE)
 endif()
 
 if(MITK_USE_DCMQI)
   # Due to the preferred CONFIG mode in find_package calls above,
   # the DCMQIConfig.cmake file is read, which does not provide useful
   # package information. We explictly need MODULE mode to find DCMQI.
     # Help our FindDCMQI.cmake script find our super-build DCMQI
   set(DCMQI_DIR ${MITK_EXTERNAL_PROJECT_PREFIX})
   find_package(DCMQI REQUIRED)
 endif()
 
 link_directories(${Boost_LIBRARY_DIRS})
 
 if(MITK_USE_OpenIGTLink)
   link_directories(${OpenIGTLink_LIBRARY_DIRS})
 endif()
 
 if(MITK_USE_OpenCL)
   find_package(OpenCL REQUIRED)
 endif()
 
 if(MITK_USE_OpenMP)
   find_package(OpenMP REQUIRED COMPONENTS CXX)
 else()
   find_package(OpenMP QUIET COMPONENTS CXX)
 
   if(OpenMP_FOUND)
     set(MITK_USE_OpenMP ON CACHE BOOL "" FORCE)
   elseif(APPLE AND OpenMP_libomp_LIBRARY AND NOT OpenMP_CXX_LIB_NAMES)
     set(OpenMP_CXX_LIB_NAMES libomp CACHE STRING "" FORCE)
     get_filename_component(openmp_lib_dir "${OpenMP_libomp_LIBRARY}" DIRECTORY)
     set(openmp_include_dir "${openmp_lib_dir}/../include")
     if(EXISTS "${openmp_include_dir}")
       get_filename_component(openmp_include_dir "${openmp_include_dir}" REALPATH)
       set(OpenMP_CXX_FLAGS "-Xpreprocessor -fopenmp -I${openmp_include_dir}" CACHE STRING "" FORCE)
       find_package(OpenMP QUIET COMPONENTS CXX)
       if(OpenMP_FOUND)
         set(MITK_USE_OpenMP ON CACHE BOOL "" FORCE)
       endif()
     endif()
   endif()
 endif()
 
 # Qt support
 if(MITK_USE_Qt5)
   find_package(Qt5Core ${MITK_QT5_MINIMUM_VERSION} REQUIRED) # at least Core required
   get_target_property(_qmake_exec Qt5::qmake LOCATION)
   execute_process(COMMAND ${_qmake_exec} -query QT_INSTALL_BINS
     RESULT_VARIABLE _result
      OUTPUT_VARIABLE QT_BINARY_DIR
     ERROR_VARIABLE _error
   )
   string(STRIP "${QT_BINARY_DIR}" QT_BINARY_DIR)
   if(_result OR NOT EXISTS "${QT_BINARY_DIR}")
     message(FATAL_ERROR "Could not determine Qt binary directory: ${_result} ${QT_BINARY_DIR} ${_error}")
   endif()
 
   find_program(QT_HELPGENERATOR_EXECUTABLE
     NAMES qhelpgenerator qhelpgenerator-qt5 qhelpgenerator5
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   find_program(QT_COLLECTIONGENERATOR_EXECUTABLE
     NAMES qcollectiongenerator qcollectiongenerator-qt5 qcollectiongenerator5
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   find_program(QT_ASSISTANT_EXECUTABLE
     NAMES assistant assistant-qt5 assistant5
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   find_program(QT_XMLPATTERNS_EXECUTABLE
     NAMES xmlpatterns
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   mark_as_advanced(QT_HELPGENERATOR_EXECUTABLE
                    QT_COLLECTIONGENERATOR_EXECUTABLE
                    QT_ASSISTANT_EXECUTABLE
                    QT_XMLPATTERNS_EXECUTABLE
                   )
 
   if(MITK_USE_BLUEBERRY)
     option(BLUEBERRY_USE_QT_HELP "Enable support for integrating plugin documentation into Qt Help" ${DOXYGEN_FOUND})
     mark_as_advanced(BLUEBERRY_USE_QT_HELP)
 
     # Sanity checks for in-application BlueBerry plug-in help generation
     if(BLUEBERRY_USE_QT_HELP)
       set(_force_blueberry_use_qt_help_to_off 0)
       if(NOT DOXYGEN_FOUND)
         message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because Doxygen was not found.")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
       if(DOXYGEN_FOUND AND DOXYGEN_VERSION VERSION_LESS 1.8.7)
         message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because Doxygen version 1.8.7 or newer not found.")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
 
       if(NOT QT_HELPGENERATOR_EXECUTABLE)
         message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because QT_HELPGENERATOR_EXECUTABLE is empty.")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
 
       if(NOT MITK_USE_Qt5)
         message("> Forcing BLUEBERRY_USE_QT_HELP to OFF because MITK_USE_Qt5 is OFF.")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
 
       if(NOT QT_XMLPATTERNS_EXECUTABLE)
         message("You have enabled Qt Help support, but QT_XMLPATTERNS_EXECUTABLE is empty")
         set(_force_blueberry_use_qt_help_to_off 1)
       endif()
 
       if(_force_blueberry_use_qt_help_to_off)
         set(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating plugin documentation into Qt Help" FORCE)
       endif()
     endif()
 
     if(BLUEBERRY_QT_HELP_REQUIRED AND NOT BLUEBERRY_USE_QT_HELP)
       message(FATAL_ERROR "BLUEBERRY_USE_QT_HELP is required to be set to ON")
     endif()
   endif()
 
 endif()
 
 #-----------------------------------------------------------------------------
 # Testing
 #-----------------------------------------------------------------------------
 
 if(BUILD_TESTING)
   #[[ See T27701
   # Initial cache for ProjectTemplate and PluginGenerator tests
   configure_file(
      CMake/mitkTestInitialCache.txt.in
      ${MITK_BINARY_DIR}/mitkTestInitialCache.txt
      @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 (const std::exception& e)
       {
         fprintf(stderr, \"%s\\n\", e.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()
 
   # Test the package target
   include(mitkPackageTest)
 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()
 
 #-----------------------------------------------------------------------------
 # Set C/CXX and linker flags for MITK code
 #-----------------------------------------------------------------------------
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MITK_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MITK_CXX_FLAGS_DEBUG}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MITK_CXX_FLAGS_RELEASE}")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MITK_C_FLAGS}")
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${MITK_C_FLAGS_DEBUG}")
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${MITK_C_FLAGS_RELEASE}")
 
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MITK_EXE_LINKER_FLAGS}")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${MITK_SHARED_LINKER_FLAGS}")
 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${MITK_MODULE_LINKER_FLAGS}")
 
 #-----------------------------------------------------------------------------
 # Add subdirectories
 #-----------------------------------------------------------------------------
 
 add_subdirectory(Utilities)
 
 add_subdirectory(Modules)
 
 include("${CMAKE_CURRENT_SOURCE_DIR}/Modules/ModuleList.cmake")
 mitkFunctionWhitelistModules(MITK MITK_MODULES)
 
 set(MITK_ROOT_FOLDER_BACKUP "${MITK_ROOT_FOLDER}")
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   get_filename_component(MITK_ROOT_FOLDER "${MITK_EXTENSION_DIR}" NAME)
   set(MITK_MODULES_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Modules")
   if(EXISTS "${MITK_MODULES_EXTENSION_DIR}/ModuleList.cmake")
     set(MITK_MODULES "")
     include("${MITK_MODULES_EXTENSION_DIR}/ModuleList.cmake")
     foreach(mitk_module ${MITK_MODULES})
       add_subdirectory("${MITK_MODULES_EXTENSION_DIR}/${mitk_module}" "Modules/${mitk_module}")
     endforeach()
   endif()
   set(MITK_MODULE_NAME_PREFIX ${MITK_DEFAULT_MODULE_NAME_PREFIX})
 endforeach()
 set(MITK_ROOT_FOLDER "${MITK_ROOT_FOLDER_BACKUP}")
 
 add_subdirectory(Wrapping)
 
 set(MITK_DOXYGEN_OUTPUT_DIR "${PROJECT_BINARY_DIR}/Documentation/Doxygen" CACHE PATH
   "Output directory for doxygen generated documentation.")
 
 if(MITK_USE_BLUEBERRY)
 
   set(BLUEBERRY_XPDOC_OUTPUT_DIR "${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html/")
   execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ${BLUEBERRY_XPDOC_OUTPUT_DIR})
 
   include("${CMAKE_CURRENT_SOURCE_DIR}/Plugins/PluginList.cmake")
   mitkFunctionWhitelistPlugins(MITK MITK_PLUGINS)
 
   set(mitk_plugins_fullpath "")
   foreach(mitk_plugin ${MITK_PLUGINS})
     list(APPEND mitk_plugins_fullpath Plugins/${mitk_plugin})
   endforeach()
 
   set(MITK_PLUGIN_REGEX_LIST "")
   foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
     set(MITK_PLUGINS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Plugins")
     if(EXISTS "${MITK_PLUGINS_EXTENSION_DIR}/PluginList.cmake")
       set(MITK_PLUGINS "")
       include("${MITK_PLUGINS_EXTENSION_DIR}/PluginList.cmake")
       foreach(mitk_plugin ${MITK_PLUGINS})
         list(APPEND mitk_plugins_fullpath "${MITK_PLUGINS_EXTENSION_DIR}/${mitk_plugin}")
       endforeach()
     endif()
   endforeach()
 
   if(EXISTS ${MITK_PRIVATE_MODULES}/PluginList.cmake)
     include(${MITK_PRIVATE_MODULES}/PluginList.cmake)
 
     foreach(mitk_plugin ${MITK_PRIVATE_PLUGINS})
       list(APPEND mitk_plugins_fullpath ${MITK_PRIVATE_MODULES}/${mitk_plugin})
     endforeach()
   endif()
 
   if(MITK_BUILD_EXAMPLES)
     include("${CMAKE_CURRENT_SOURCE_DIR}/Examples/Plugins/PluginList.cmake")
     set(mitk_example_plugins_fullpath )
     foreach(mitk_example_plugin ${MITK_EXAMPLE_PLUGINS})
       list(APPEND mitk_example_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
       list(APPEND mitk_plugins_fullpath Examples/Plugins/${mitk_example_plugin})
     endforeach()
   endif()
 
   # Specify which plug-ins belong to this project
   macro(GetMyTargetLibraries all_target_libraries varname)
     set(re_ctkplugin_mitk "^org_mitk_[a-zA-Z0-9_]+$")
     set(re_ctkplugin_bb "^org_blueberry_[a-zA-Z0-9_]+$")
     set(_tmp_list)
     list(APPEND _tmp_list ${all_target_libraries})
     ctkMacroListFilter(_tmp_list re_ctkplugin_mitk re_ctkplugin_bb MITK_PLUGIN_REGEX_LIST OUTPUT_VARIABLE ${varname})
   endmacro()
 
   # Get infos about application directories and build options
   set(mitk_apps_fullpath "")
   foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
     set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
     if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
       set(MITK_APPS "")
       include("${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
       foreach(mitk_app ${MITK_APPS})
         # extract option_name
         string(REPLACE "^^" "\\;" target_info ${mitk_app})
         set(target_info_list ${target_info})
         list(GET target_info_list 0 directory_name)
         list(GET target_info_list 1 option_name)
         if(${option_name})
           list(APPEND mitk_apps_fullpath "${MITK_APPLICATIONS_EXTENSION_DIR}/${directory_name}^^${option_name}")
         endif()
       endforeach()
     endif()
   endforeach()
 
   if (mitk_plugins_fullpath)
     ctkMacroSetupPlugins(${mitk_plugins_fullpath}
                          BUILD_OPTION_PREFIX MITK_BUILD_
                          APPS ${mitk_apps_fullpath}
                          BUILD_ALL ${MITK_BUILD_ALL_PLUGINS}
                          COMPACT_OPTIONS)
   endif()
 
   set(MITK_PLUGIN_USE_FILE "${MITK_BINARY_DIR}/MitkPluginUseFile.cmake")
   if(${PROJECT_NAME}_PLUGIN_LIBRARIES)
     ctkFunctionGeneratePluginUseFile(${MITK_PLUGIN_USE_FILE})
   else()
     file(REMOVE ${MITK_PLUGIN_USE_FILE})
     set(MITK_PLUGIN_USE_FILE )
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # Documentation
 #-----------------------------------------------------------------------------
 
 if(DOXYGEN_FOUND)
   add_subdirectory(Documentation)
 endif()
 
 #-----------------------------------------------------------------------------
 # Installation
 #-----------------------------------------------------------------------------
 
 
 # set MITK cpack variables
 # These are the default variables, which can be overwritten ( see below )
 include(mitkSetupCPack)
 
 set(use_default_config ON)
 
 set(ALL_MITK_APPS "")
 set(activated_apps_no 0)
 
 foreach(MITK_EXTENSION_DIR ${MITK_DIR_PLUS_EXTENSION_DIRS})
   set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
   if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
     set(MITK_APPS "")
     include("${MITK_APPLICATIONS_EXTENSION_DIR}/AppList.cmake")
     foreach(mitk_app ${MITK_APPS})
       string(REPLACE "^^" "\\;" target_info ${mitk_app})
       set(target_info_list ${target_info})
       list(GET target_info_list 0 directory_name)
       list(GET target_info_list 1 option_name)
       list(GET target_info_list 2 executable_name)
       list(APPEND ALL_MITK_APPS "${MITK_EXTENSION_DIR}/Applications/${directory_name}^^${option_name}^^${executable_name}")
       if(${option_name} OR MITK_BUILD_ALL_APPS)
         MATH(EXPR activated_apps_no "${activated_apps_no} + 1")
       endif()
     endforeach()
   endif()
 endforeach()
 
 list(LENGTH ALL_MITK_APPS app_count)
 
 if(app_count EQUAL 1 AND (activated_apps_no EQUAL 1 OR MITK_BUILD_ALL_APPS))
   # Corner case if there is only one app in total
   set(use_project_cpack ON)
 elseif(activated_apps_no EQUAL 1 AND NOT MITK_BUILD_ALL_APPS)
   # Only one app is enabled (no "build all" flag set)
   set(use_project_cpack ON)
 else()
   # Less or more then one app is enabled
   set(use_project_cpack OFF)
 endif()
 
 foreach(mitk_app ${ALL_MITK_APPS})
   # extract target_dir and option_name
   string(REPLACE "^^" "\\;" target_info ${mitk_app})
   set(target_info_list ${target_info})
   list(GET target_info_list 0 target_dir)
   list(GET target_info_list 1 option_name)
   list(GET target_info_list 2 executable_name)
   # check if the application is enabled
   if(${option_name} OR MITK_BUILD_ALL_APPS)
     # check whether application specific configuration files will be used
     if(use_project_cpack)
       # use files if they exist
       if(EXISTS "${target_dir}/CPackOptions.cmake")
         include("${target_dir}/CPackOptions.cmake")
       endif()
 
       if(EXISTS "${target_dir}/CPackConfig.cmake.in")
         set(CPACK_PROJECT_CONFIG_FILE "${target_dir}/CPackConfig.cmake")
         configure_file(${target_dir}/CPackConfig.cmake.in
                        ${CPACK_PROJECT_CONFIG_FILE} @ONLY)
         set(use_default_config OFF)
       endif()
     endif()
   # add link to the list
   list(APPEND CPACK_CREATE_DESKTOP_LINKS "${executable_name}")
   endif()
 endforeach()
 
 # if no application specific configuration file was used, use default
 if(use_default_config)
   configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
                  ${MITK_BINARY_DIR}/MITKCPackOptions.cmake @ONLY)
   set(CPACK_PROJECT_CONFIG_FILE "${MITK_BINARY_DIR}/MITKCPackOptions.cmake")
 endif()
 
 # include CPack model once all variables are set
 include(CPack)
 
 # Additional installation rules
 include(mitkInstallRules)
 
 #-----------------------------------------------------------------------------
 # Last configuration steps
 #-----------------------------------------------------------------------------
 
 # ---------------- Export targets -----------------
 
 set(MITK_EXPORTS_FILE "${MITK_BINARY_DIR}/MitkExports.cmake")
 file(REMOVE ${MITK_EXPORTS_FILE})
 
 set(targets_to_export)
 get_property(module_targets GLOBAL PROPERTY MITK_MODULE_TARGETS)
 if(module_targets)
   list(APPEND targets_to_export ${module_targets})
 endif()
 
 if(MITK_USE_BLUEBERRY)
   if(MITK_PLUGIN_LIBRARIES)
     list(APPEND targets_to_export ${MITK_PLUGIN_LIBRARIES})
   endif()
 endif()
 
 export(TARGETS ${targets_to_export} APPEND
        FILE ${MITK_EXPORTS_FILE})
 
 set(MITK_EXPORTED_TARGET_PROPERTIES )
 foreach(target_to_export ${targets_to_export})
   get_target_property(autoload_targets ${target_to_export} MITK_AUTOLOAD_TARGETS)
   if(autoload_targets)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_TARGETS \"${autoload_targets}\")")
   endif()
   get_target_property(autoload_dir ${target_to_export} MITK_AUTOLOAD_DIRECTORY)
   if(autoload_dir)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_AUTOLOAD_DIRECTORY \"${autoload_dir}\")")
   endif()
 
   get_target_property(deprecated_module ${target_to_export} MITK_MODULE_DEPRECATED_SINCE)
   if(deprecated_module)
     set(MITK_EXPORTED_TARGET_PROPERTIES "${MITK_EXPORTED_TARGET_PROPERTIES}
 set_target_properties(${target_to_export} PROPERTIES MITK_MODULE_DEPRECATED_SINCE \"${deprecated_module}\")")
   endif()
 endforeach()
 
 # ---------------- External projects -----------------
 
 get_property(MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS_CONFIG GLOBAL PROPERTY MITK_ADDITIONAL_LIBRARY_SEARCH_PATHS)
 
 set(MITK_CONFIG_EXTERNAL_PROJECTS )
 #string(REPLACE "^^" ";" _mitk_external_projects ${MITK_EXTERNAL_PROJECTS})
 
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS}
 set(MITK_USE_${ep} ${MITK_USE_${ep}})
 set(MITK_${ep}_DIR \"${${ep}_DIR}\")
 set(MITK_${ep}_COMPONENTS ${_components})
 ")
 endforeach()
 
 foreach(ep ${MITK_EXTERNAL_PROJECTS})
   get_property(_package GLOBAL PROPERTY MITK_${ep}_PACKAGE)
   get_property(_components GLOBAL PROPERTY MITK_${ep}_COMPONENTS)
   if(_components)
       set(_components_arg COMPONENTS \${_components})
   else()
     set(_components_arg)
   endif()
 
   if(_package)
     set(MITK_CONFIG_EXTERNAL_PROJECTS "${MITK_CONFIG_EXTERNAL_PROJECTS}
 if(MITK_USE_${ep})
   set(${ep}_DIR \${MITK_${ep}_DIR})
   if(MITK_${ep}_COMPONENTS)
     mitkMacroFindDependency(${_package} COMPONENTS \${MITK_${ep}_COMPONENTS})
   else()
     mitkMacroFindDependency(${_package})
   endif()
 endif()")
   endif()
 endforeach()
 
 
 # ---------------- Tools -----------------
 
 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 files -----------------
 
 configure_file(mitkVersion.h.in ${MITK_BINARY_DIR}/mitkVersion.h)
 configure_file(mitkConfig.h.in ${MITK_BINARY_DIR}/mitkConfig.h)
 
 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)
 
 write_basic_config_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
   VERSION ${MITK_VERSION_STRING} COMPATIBILITY AnyNewerVersion)
 
 #-----------------------------------------------------------------------------
 # MITK Applications
 #-----------------------------------------------------------------------------
 
 # This must come after MITKConfig.h was generated, since applications
 # might do a find_package(MITK REQUIRED).
 add_subdirectory(Applications)
 
 if(MSVC AND TARGET MitkWorkbench)
   set_directory_properties(PROPERTIES VS_STARTUP_PROJECT MitkWorkbench)
 endif()
 
 foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
   set(MITK_APPLICATIONS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/Applications")
   if(EXISTS "${MITK_APPLICATIONS_EXTENSION_DIR}/CMakeLists.txt")
     add_subdirectory("${MITK_APPLICATIONS_EXTENSION_DIR}" "Applications")
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # MITK Examples
 #-----------------------------------------------------------------------------
 
 if(MITK_BUILD_EXAMPLES)
   # This must come after MITKConfig.h was generated, since applications
   # might do a find_package(MITK REQUIRED).
   add_subdirectory(Examples)
 endif()
 
 #-----------------------------------------------------------------------------
 # Print configuration summary
 #-----------------------------------------------------------------------------
 
 message("\n\n")
 feature_summary(
   DESCRIPTION "------- FEATURE SUMMARY FOR ${PROJECT_NAME} -------"
   WHAT ALL
 )
diff --git a/Documentation/CMakeLists.txt b/Documentation/CMakeLists.txt
index d68002a508..9a25867947 100644
--- a/Documentation/CMakeLists.txt
+++ b/Documentation/CMakeLists.txt
@@ -1,202 +1,166 @@
 # Different doxygen versions produce significantly different behaviour in the MITK documentation
 # especially in regards to the MITK Qt assistant help files and markdown files.
 # The HTML documentation is supposed to be build with Doxygen 1.8.7 or newer, the
 # Qt assistant QCH files are supposed to be generated with Doxygen 1.8.7 or newer.
 # So we check for 1.8.7 here and QCH generation support is checked in
 # BlueBerry/CMakeLists.txt
 set(supported_doxygen_version "1.8.7")
 
 if(DOXYGEN_VERSION VERSION_LESS ${supported_doxygen_version})
   MESSAGE(WARNING "Unsupported doxygen version ${DOXYGEN_VERSION}. The MITK HTML documentation has been tested to work with doxygen ${supported_doxygen_version} or newer.")
 endif()
 
 option(USE_DOT "Use dot program for generating graphical class diagrams with doxygen, if available" ON)
 option(MITK_DOXYGEN_BUILD_ALWAYS "Always build the MITK documentation when building the default target" OFF)
 option(MITK_DOXYGEN_GENERATE_QCH_FILES "Use doxygen to generate Qt compressed help files for MITK docs" OFF)
 mark_as_advanced(USE_DOT MITK_DOXYGEN_BUILD_ALWAYS MITK_DOXYGEN_GENERATE_QCH_FILES)
 if (MITK_DOXYGEN_GENERATE_QCH_FILES AND DOXYGEN_VERSION VERSION_LESS "1.8.7")
   message(WARNING "> Forcing MITK_DOXYGEN_GENERATE_QCH_FILES to OFF because Doxygen version 1.8.7 or newer not found.")
   set(MITK_DOXYGEN_GENERATE_QCH_FILES OFF CACHE BOOL "Use doxygen to generate Qt compressed help files for MITK docs" FORCE)
 endif()
 
 set(HAVE_DOT "NO")
 if(DOXYGEN_DOT_EXECUTABLE AND USE_DOT)
   set(HAVE_DOT "YES")
 endif()
 
 set(MITK_DOXYGEN_TAGFILE_NAME ${MITK_DOXYGEN_OUTPUT_DIR}/MITK.tag CACHE INTERNAL "MITK Doxygen tag file")
 
 # This is relative to the working directory of the doxygen command
 set(MITK_DOXYGEN_STYLESHEET mitk_doxygen_extra.css)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${MITK_DOXYGEN_STYLESHEET}
                ${CMAKE_CURRENT_BINARY_DIR}/${MITK_DOXYGEN_STYLESHEET} COPYONLY)
 
 # Create QCH files for MITK and external projects
 set(MITK_DOXYGEN_GENERATE_QHP "NO")
 if(MITK_DOXYGEN_GENERATE_QCH_FILES)
 
   find_program(QT_HELPGENERATOR_EXECUTABLE
     NAMES qhelpgenerator qhelpgenerator-qt5 qhelpgenerator5
     PATHS ${QT_BINARY_DIR}
     DOC "The location of the the Qt help generator executable"
     NO_DEFAULT_PATH
   )
   mark_as_advanced(QT_HELPGENERATOR_EXECUTABLE)
 
   if(NOT QT_HELPGENERATOR_EXECUTABLE)
     message(SEND_ERROR "The Qt help generator could not be found. Disabling qch generation")
   else()
     set(MITK_DOXYGEN_GENERATE_QHP "YES")
   endif()
 
   # The name of the generated MITK qch file, relative to the
   # Doxygen HTML output folder
   set(MITK_DOXYGEN_QCH_FILE "${MITK_BINARY_DIR}/MITK-${MITK_REVISION_ID}.qch")
 
   # Generating ITK and VTK docs it not done yet
   #option(MITK_DOXYGEN_GENERATE_VTK_QCH_FILE "Use doxygen to generate a Qt compressed help file for VTK docs" OFF)
   #option(MITK_DOXYGEN_GENERATE_ITK_QCH_FILE "Use doxygen to generate a Qt compressed help file for ITK docs" OFF)
   #mark_as_advanced(MITK_DOXYGEN_GENERATE_VTK_QCH_FILE MITK_DOXYGEN_GENERATE_ITK_QCH_FILE)
 
 endif()
 
 # Compile a doxygen input filter for processing CMake scripts
 include(mitkFunctionCMakeDoxygenFilterCompile)
 mitkFunctionCMakeDoxygenFilterCompile(NAMESPACE "CMake")
 
 # Configure some doxygen options
 if(NOT MITK_DOXYGEN_INTERNAL_DOCS)
   set(MITK_DOXYGEN_INTERNAL_DOCS "NO")
   set(MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS "YES")
   set(MITK_DOXYGEN_EXCLUDE_PATTERNS "*_p.* *Private.h */internal/*")
 else()
   set(MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS "NO")
   set(MITK_DOXYGEN_EXCLUDE_PATTERNS "")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_TODOLIST)
   set(MITK_DOXYGEN_GENERATE_TODOLIST "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_BUGLIST)
   set(MITK_DOXYGEN_GENERATE_BUGLIST "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS)
   set(MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_UML_LOOK)
   set(MITK_DOXYGEN_UML_LOOK "NO")
 endif()
 
 if(NOT MITK_DOXYGEN_GENERATE_DEPRECATEDLIST)
   set(MITK_DOXYGEN_GENERATE_DEPRECATEDLIST "YES")
 endif()
 
 if(NOT DEFINED MITK_DOXYGEN_DOT_NUM_THREADS)
   set(MITK_DOXYGEN_DOT_NUM_THREADS 0)
 endif()
 
 if(NOT DEFINED US_PLATFORM)
   if(UNIX)
     if(APPLE)
       set(US_PLATFORM "US_PLATFORM_APPLE=1")
     else()
       set(US_PLATFORM "US_PLATFORM_LINUX=1")
     endif()
     set(US_PLATFORM "${US_PLATFORM} \\\nUS_PLATFORM_POSIX=1")
   else()
     set(US_PLATFORM "US_PLATFORM_WINDOWS=1")
   endif()
 endif()
 
 # parse which plug-in documentation to activate
 set(USERS_GUIDE_INPUT "${MITK_SOURCE_DIR}/Documentation/Doxygen/UserManual/")
 if(MITK_USE_BLUEBERRY)
   if(MITK_BUILD_ALL_PLUGINS)
     set(USERS_GUIDE_INPUT "${USERS_GUIDE_INPUT} \\
         ${MITK_SOURCE_DIR}/Plugins/")
   else()
     foreach(mitk_plugin ${${CMAKE_PROJECT_NAME}_PLUGIN_LIBRARIES})
       # we want each line to end in " \" and each directory be on a separate line
       set(USERS_GUIDE_INPUT "${USERS_GUIDE_INPUT} \\
           ${${mitk_plugin}_SOURCE_DIR}/")
     endforeach()
   endif()
 
   if(MITK_BUILD_EXAMPLES)
     set(USERS_GUIDE_INPUT "${USERS_GUIDE_INPUT} \\
         ${MITK_SOURCE_DIR}/Examples/Plugins/")
   endif()
 endif()
 
 # create output directories for the guides
 file(MAKE_DIRECTORY ${MITK_DOXYGEN_OUTPUT_DIR}/Guides/Users_Guide/)
 file(MAKE_DIRECTORY ${MITK_DOXYGEN_OUTPUT_DIR}/Guides/Developers_Guide/)
 
 configure_file(doxygen.conf.in
                ${CMAKE_CURRENT_BINARY_DIR}/doxygen.conf)
 configure_file(doxygen_users_guide.conf.in
                ${CMAKE_CURRENT_BINARY_DIR}/doxygen_users_guide.conf)
 configure_file(doxygen_developers_guide.conf.in
                ${CMAKE_CURRENT_BINARY_DIR}/doxygen_developers_guide.conf)
 
 if(MITK_DOXYGEN_BUILD_ALWAYS)
   set(_doc_in_all "ALL")
 else()
   set(_doc_in_all "")
 endif()
 
 add_custom_target(doc ${_doc_in_all}
                   ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.conf
                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                   )
 
 add_custom_target(doc_usersguide
                   ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen_users_guide.conf
                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                   )
 
 add_custom_target(doc_developersguide
                   ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen_developers_guide.conf
                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                   )
 
 set_property(TARGET doc doc_usersguide doc_developersguide PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Documentation")
-
-if(MITK_USE_BLUEBERRY)
-  # convert the extension points schema files into html
-  find_package(Ant)
-  set(BLUEBERRY_DOC_TOOLS_DIR "" CACHE PATH "Directory containing additional tools needed for generating the documentation")
-  if(ANT_FOUND AND BLUEBERRY_DOC_TOOLS_DIR)
-
-    list(APPEND MITK_XP_GLOB_EXPRESSIONS
-         ${MITK_SOURCE_DIR}/Plugins/plugin.xml)
-
-    file(GLOB_RECURSE _plugin_xmls ${MITK_XP_GLOB_EXPRESSIONS})
-
-    mitkFunctionConvertXPSchema(INPUT ${_plugin_xmls}
-                                OUTPUT_DIR "${MITK_DOXYGEN_OUTPUT_DIR}/html/extension-points/html"
-                                TARGET_NAME mitkXPDoc
-                               )
-
-    add_dependencies(doc mitkXPDoc)
-  else()
-    message(STATUS "Extension-point schema documentation generation disabled due to missing Ant and / or missing BlueBerry doc tools.")
-  endif()
-endif(MITK_USE_BLUEBERRY)
-
-#if(MITK_DOXYGEN_GENERATE_ITK_QCH_FILE)
-#  # add the command to generate the ITK documentation
-#  add_custom_target(doc-itk
-#                    COMMAND ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.itk.conf)
-#  add_dependencies(doc doc-itk)
-#endif()
-
-#if(MITK_DOXYGEN_GENERATE_VTK_QCH_FILE)
-#  # add the command to generate the VTK documentation
-#  add_custom_target(doc-vtk
-#                    COMMAND ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/doxygen.vtk.conf)
-#  add_dependencies(doc doc-vtk)
-#endif()
diff --git a/Documentation/Doxygen/2-UserManual/MITKPluginGeneralManualsList.dox b/Documentation/Doxygen/2-UserManual/MITKPluginGeneralManualsList.dox
index 3d89a0f0dd..1bab9b4031 100644
--- a/Documentation/Doxygen/2-UserManual/MITKPluginGeneralManualsList.dox
+++ b/Documentation/Doxygen/2-UserManual/MITKPluginGeneralManualsList.dox
@@ -1,33 +1,32 @@
 /**
 \page PluginListGeneralPage  List of General Purpose Plugins
 
 
   \li \subpage org_mitk_views_basicimageprocessing
   \li \subpage org_mitk_views_datamanager
   \li \subpage org_mitk_views_properties
   \li \subpage org_mitk_editors_dicombrowser
   \li \subpage org_mitk_views_dicominspector
   \li \subpage org_mitk_views_imagecropper
   \li \subpage org_mitk_views_imagenavigator
   \li \subpage org_blueberry_views_logview
-  \li \subpage org_mitk_gui_qt_matchpoint_algorithm_batch
   \li \subpage org_mitk_views_matchpoint_algorithm_browser
   \li \subpage org_mitk_views_matchpoint_algorithm_control
   \li \subpage org_mitk_views_matchpoint_evaluator
   \li \subpage org_mitk_views_matchpoint_framereg
   \li \subpage org_mitk_views_matchpoint_manipulator
   \li \subpage org_mitk_views_matchpoint_mapper
   \li \subpage org_mitk_views_matchpoint_visualizer
   \li \subpage org_mitk_gui_qt_measurementtoolbox
   \li \subpage org_mitk_views_moviemaker
   \li \subpage org_mitk_views_multilabelsegmentation
   \li \subpage org_mitk_views_pointsetinteraction
   \li \subpage org_mitk_views_python
-  \li \subpage org_mitk_views_qt_remeshing
+  \li \subpage org_mitk_views_remeshing
   \li \subpage org_mitk_views_screenshotmaker
   \li \subpage org_mitk_views_segmentation
   \li \subpage org_mitk_views_deformableclippingplane
   \li \subpage org_mitk_gui_qt_flow_segmentation
   \li \subpage org_mitk_views_viewnavigatorview
   \li \subpage org_mitk_views_volumevisualization
 */
diff --git a/Documentation/Doxygen/2-UserManual/MITKPluginManualsList.dox b/Documentation/Doxygen/2-UserManual/MITKPluginManualsList.dox
index be3c4b4319..28d65a2336 100644
--- a/Documentation/Doxygen/2-UserManual/MITKPluginManualsList.dox
+++ b/Documentation/Doxygen/2-UserManual/MITKPluginManualsList.dox
@@ -1,83 +1,73 @@
 /**
 \page PluginListPage MITK Plugin Manuals
 
 The plugins and bundles provide much of the extended functionality of MITK. Each encapsulates a solution to a problem and associated features. This way one can easily assemble the necessary capabilites for a workflow without adding a lot of bloat, by combining plugins as needed.
 
 \subpage PluginListGeneralPage
 
 <ul>
   <li> \ref org_mitk_views_basicimageprocessing </li>
   <li> \ref org_mitk_views_datamanager </li>
   <li> \ref org_mitk_editors_dicombrowser </li>
   <li> \ref org_mitk_views_dicominspector </li>
   <li> \ref org_mitk_views_imagecropper </li>
   <li> \ref org_mitk_views_imagenavigator </li>
   <li> \ref org_blueberry_views_logview </li>
   <li> \ref org_mitk_views_matchpoint_algorithm_browser </li>
   <li> \ref org_mitk_views_matchpoint_algorithm_control </li>
   <li> \ref org_mitk_views_matchpoint_evaluator </li>
   <li> \ref org_mitk_views_matchpoint_framereg </li>
   <li> \ref org_mitk_views_matchpoint_manipulator </li>
   <li> \ref org_mitk_views_matchpoint_mapper </li>
   <li> \ref org_mitk_views_matchpoint_visualizer </li>
   <li> \ref org_mitk_views_measurement </li>
   <li> \ref org_mitk_views_imagestatistics </li>
   <li> \ref org_mitk_views_moviemaker </li>
   <li> \ref org_mitk_views_multilabelsegmentation </li>
   <li> \ref org_mitk_views_pointsetinteraction </li>
   <li> \ref org_mitk_views_python </li>
   <li> \ref org_mitk_views_remeshing </li>
   <li> \ref org_mitk_views_screenshotmaker </li>
   <li> \ref org_mitk_views_segmentation </li>
   <li> \ref org_mitk_views_deformableclippingplane </li>
   <li> \ref org_mitk_views_viewnavigatorview </li>
   <li> \ref org_mitk_views_volumevisualization </li>
   <li> \ref org_mitk_views_properties </li>
 
 </ul>
 
 \subpage PluginListSpecificPage
 
 <ul>
   <li> \ref org_mitk_gui_qt_flowapplication </li>
-  <li> \ref org_mitk_views_flow_control </li>
   <li> \ref org_mitk_gui_qt_aicpregistration </li>
   <li> \ref org_mitk_gui_qt_cest </li>
   <li> \ref org_mitk_gui_qt_classificationsegmentation </li>
   <li> \ref org_mitk_views_cmdlinemodules </li>
   <li> \ref org_mitk_views_pharmacokinetics_concentration_mri </li>
   <li> \ref org_mitk_views_pharmacokinetics_mri </li>
   <li> \ref org_mitk_views_pharmacokinetics_pet </li>
-  <li> \ref org_mitk_gui_qt_eventrecorder </li>
   <li> \ref org_mitk_gui_qt_examples </li>
   <li> \ref org_mitk_gui_qt_geometrytools </li>
   <li> \ref org_mitk_gui_qt_igtexample </li>
-  <li> \ref org_mitk_gui_qt_igtlplugin </li>
   <li> \ref org_mitk_gui_qt_igttracking </li>
   <li> \ref org_mitk_views_igttrackingsemiautomaticmeasurement </li>
-  <li> \ref org_mitk_gui_qt_lasercontrol </li>
   <li> \ref org_mitk_views_fit_demo </li>
   <li> \ref org_mitk_views_fit_genericfitting </li>
   <li> \ref org_mitk_views_fit_inspector </li>
   <li> \ref org_mitkexamplesopencv </li>
   <li> \ref org_mitk_gui_qt_overlaymanager </li>
   <li> \ref org_mitk_gui_qt_mitkphenotyping </li>
-  <li> \ref org_mitk_gui_qt_photoacoustics_pausmotioncompensation </li>
-  <li> \ref org_mitk_example_gui_pcaexample </li>
   <li> \ref org_mitk_gui_qt_preprocessing_resampling </li>
   <li> \ref org_mitk_views_pharmacokinetics_curvedescriptor </li>
   <li> \ref org_mitk_views_photoacoustics_imageprocessing </li>
   <li> \ref org_mitk_gui_qt_pharmacokinetics_simulation </li>
-  <li> \ref org_mitk_gui_qt_pointsetinteractionmultispectrum </li>
-  <li> \ref org_mitk_gui_qt_renderwindowmanager </li>
   <li> \ref org_mitk_gui_qt_photoacoustics_spectralunmixing </li>
-  <li> \ref org_mitk_gui_qt_spectrocamrecorder </li>
   <li> \ref org_surfacematerialeditor </li>
   <li> \ref org_toftutorial </li>
   <li> \ref org_blueberry_ui_qt_objectinspector </li>
   <li> \ref org_mitk_gui_qt_ultrasound </li>
-  <li> \ref org_mitk_gui_qt_igt_app_echotrack </li>
   <li> \ref org_mitk_gui_qt_xnat </li>
 </ul>
 
 */
diff --git a/Documentation/Doxygen/2-UserManual/MITKPluginSpecificManualsList.dox b/Documentation/Doxygen/2-UserManual/MITKPluginSpecificManualsList.dox
index c30e4932d9..9f1a98ced2 100644
--- a/Documentation/Doxygen/2-UserManual/MITKPluginSpecificManualsList.dox
+++ b/Documentation/Doxygen/2-UserManual/MITKPluginSpecificManualsList.dox
@@ -1,46 +1,36 @@
 /**
 \page PluginListSpecificPage List of Application-specific Plugins
 
   \li \subpage org_mitk_gui_qt_aicpregistration
   \li \subpage org_mitk_gui_qt_cest
   \li \subpage org_mitk_gui_qt_classificationsegmentation
   \li \subpage org_mitk_gui_qt_flowapplication
   \li \subpage org_mitk_views_cmdlinemodules
   \li \subpage org_mitk_views_pharmacokinetics_concentration_mri
   \li \subpage org_mitk_views_pharmacokinetics_mri
   \li \subpage org_mitk_views_pharmacokinetics_pet
   \li \subpage org_mitk_views_pharmacokinetics_simulation
-  \li \subpage org_mitk_gui_qt_eventrecorder
   \li \subpage org_mitk_gui_qt_examples
   \li \subpage org_mitk_gui_qt_geometrytools
   \li \subpage org_mitk_gui_qt_igtexample
-  \li \subpage org_mitk_gui_qt_igtlplugin
   \li \subpage org_mitk_gui_qt_igttracking
   \li \subpage org_mitk_views_igttrackingsemiautomaticmeasurement
   \li \subpage org_mitk_views_imagestatistics
-  \li \subpage org_mitk_gui_qt_lasercontrol
   \li \subpage org_mitk_views_fit_demo
   \li \subpage org_mitk_views_fit_genericfitting
   \li \subpage org_mitk_views_fit_inspector
   \li \subpage org_mitkexamplesopencv
   \li \subpage org_mitk_gui_qt_overlaymanager
   \li \subpage org_mitk_gui_qt_mitkphenotyping
-  \li \subpage org_mitk_gui_qt_photoacoustics_pausmotioncompensation
-  \li \subpage org_mitk_example_gui_pcaexample
   \li \subpage org_mitk_gui_qt_preprocessing_resampling
   \li \subpage org_mitk_views_pharmacokinetics_curvedescriptor
   \li \subpage org_mitk_views_photoacoustics_imageprocessing
   \li \subpage org_mitk_gui_qt_pharmacokinetics_simulation
-  \li \subpage org_mitk_gui_qt_pointsetinteractionmultispectrum
-  \li \subpage org_mitk_gui_qt_renderwindowmanager
   \li \subpage org_mitk_gui_qt_photoacoustics_spectralunmixing
-  \li \subpage org_mitk_gui_qt_spectrocamrecorder
   \li \subpage org_surfacematerialeditor
   \li \subpage org_blueberry_ui_qt_objectinspector
   \li \subpage org_toftutorial
   \li \subpage org_mitk_gui_qt_ultrasound
-  \li \subpage org_mitk_gui_qt_igt_app_echotrack
   \li \subpage org_mitk_gui_qt_xnat
 
-
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Application/BlueBerry/BlueBerryIntro.dox b/Documentation/Doxygen/3-DeveloperManual/Application/BlueBerry/BlueBerryIntro.dox
index 8730cc4537..5543d831ae 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Application/BlueBerry/BlueBerryIntro.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Application/BlueBerry/BlueBerryIntro.dox
@@ -1,79 +1,79 @@
 /**
 
 \page BlueBerryIntro BlueBerry Application Framework
 
 BlueBerry is an application framework used in MITK for creating modular and extensible end-user applications.
 
 More high-level documentation can be found below:
 
 - \subpage BlueBerryWorkbench
 - \ref BlueBerryExamples
 
 Please see the \ref BlueBerryExamples for code examples demonstrating different features of the application framework.
 
 The BlueBerry developer reference is available here:
 
 - \ref BlueBerryPlugins
 - \subpage BlueBerryExtPointsIndex
 
 
 \page BlueBerryWorkbench The Workbench: What are Views, Editors, Perspectives?
 
 BlueBerry makes use of the Eclipse UI guidlines which state some concepts on how to build up a GUI. The different objects of the platform UI shall be described here:
 
 \section Workbench Workbench
 \li root object of the platform UI
 \li collection of \ref WorkbenchWindow "windows"
 \imageMacro{workbench.jpg,"The Workbech",11.64}
 
 \section WorkbenchWindow WorkbenchWindow
-\li has one \ref Workbench-Page "page"
+\li has one page
 \imageMacro{workbench-window.jpg,"Workbench Windows",8.47}
 
 \section WorkbenchPage Workbench Page
 \li denotes to the inner part of the \ref WorkbenchWindow "window", that is: everything except the title bar
 \li may have one menu bar, one toolbar, one shortcut bar, and one statusbar
 \li has one or more \ref Perspective "perspectives"
 \imageMacro{workbench-page.jpg,"Workbench Page",8.47}
 
 \section Perspective Perspective
 <UL>
 <LI> A visual container for a set of \ref Views "views" and content \ref Editors "editors" </LI>
 <LI> Shows \ref Views "views" and \ref Editors "editors" in a certain layout </LI>
 <LI> Like a page within a book: </LI>
     <UL>
     <LI> Only one perspective is visible at any time </LI>
-    <LI> There are several perspectives inside a \ref Workbench-Page "page" </LI>
+    <LI> There are several perspectives inside a page </LI>
     </UL>
 </UL>
 \imageMacro{workbench-window-perspective.png,"A Perspective",11.79}
 
 \section Part Part
 \li every \ref Views "View" or \ref Editors "Editor" is called \b Part
 
 \subsection Editors Editors
 \li the StdMultiWidget is an example for an editor in our MainApp
 \li Contains the primary content, such as a document or image data, which users interact with
 \li content is the primary focus of attention and a reflection of the primary task
 \li primary position in the UI
 \li contributes commands to the workbench's main menu bar and toolbar
 \li shared in other perspectives
 \imageMacro{workbench-window-editor-area.png,"Editor Area",11.79}
 
 \subsection Views Views
 <UL>
 <LI> support the primary task </LI>
     <UL>
     <LI> navigate a hierarchy of information </LI>
     <LI> open an \ref Editors "editor" </LI>
     <LI> view/edit properties </LI>
     </UL>
 <LI> The views exist wholly within the perspective (not shared, one instance at a time) </LI>
 <LI> Every functionality is a view- it supports medical image processing </LI>
 </UL>
 \imageMacro{workbench-window-views.png,"Views",11.79}
 
 \section ClassDiagram Summary as class diagram
 \imageMacro{workbench-class-diagram.jpg,"class diagram",13.74}
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Application/BlueBerryExtensionPointReference.dox b/Documentation/Doxygen/3-DeveloperManual/Application/BlueBerryExtensionPointReference.dox
index 066fc9c444..d382e5912b 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Application/BlueBerryExtensionPointReference.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Application/BlueBerryExtensionPointReference.dox
@@ -1,94 +1,1346 @@
 /**
 
 \page BlueBerryExtPointsIndex BlueBerry Extension-Point Reference
 
-<center>
-  <h1>BlueBerry Platform Extension Points</h1>
-</center>
+\tableofcontents{html:2}
 
-The following extension points can be used to extend the capabilities
-of the platform infrastructure:
+\section BlueBerryExtPointsIndex_CoreExpr Platform Core Expressions
 
-<h3><a name="runtime"></a>Platform Core Expressions</h3>
-<ul>
-  <li>\subpage xp_org_blueberry_core_expressions_definitions
-  <li>\subpage xp_org_blueberry_core_expressions_commonExpression
-  <li>\subpage xp_org_blueberry_core_expressions_propertyTesters
-</ul>
+\subsection BlueBerryExtPointsIndex_CoreExpr_ExprDef Expression Definitions
 
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_ExprDef_Id Identifier
 
-<h3><a name="runtime"></a>Platform Runtime</h3>
-<ul>
-  <li>\subpage xp_org_blueberry_osgi_applications
-  <li>\subpage xp_org_blueberry_core_runtime_products
-</ul>
+\c org.blueberry.core.expressions.definitions
 
-<h3><a name="workbench"></a>Workbench</h3>
-<ul>
-  <li>\subpage xp_org_blueberry_ui_editors
-  <li>\subpage xp_org_blueberry_ui_elementFactories
-  <li>\subpage xp_org_blueberry_ui_keywords
-  <li>\subpage xp_org_blueberry_ui_menus
-  <li>\subpage xp_org_blueberry_ui_perspectiveExtensions
-  <li>\subpage xp_org_blueberry_ui_perspectives
-  <li>\subpage xp_org_blueberry_ui_preferencePages
-  <li>\subpage xp_org_blueberry_ui_presentationFactories
-  <li>\subpage xp_org_blueberry_ui_services
-  <li>\subpage xp_org_blueberry_ui_tweaklets
-  <li>\subpage xp_org_blueberry_ui_views
-</ul>
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_ExprDef_Desc Description
 
-<h3><a name="other"></a>Other</h3>
-<ul>
-    <li>\subpage xp_org_blueberry_tests
-</ul>
+This extension point allows you to create reusable extensions.
+They can then be used in other core expression constructs.
+The reference element in a core expression will evaluated the expression definition with the evaluation context that is active for the reference element.
 
-\page xp_org_blueberry_core_expressions_definitions org.blueberry.core.expressions.definitions
-\htmlinclude org_blueberry_core_expressions_definitions.html
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_ExprDef_ConfMarkup Configuration Markup
 
-\page xp_org_blueberry_core_expressions_commonExpression org.blueberry.core.expressions.commonExpression
-\htmlinclude org_blueberry_core_expressions_commonExpression.html
+\code{.unparsed}
+<!ELEMENT extension (definition*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
 
-\page xp_org_blueberry_core_expressions_propertyTesters org.blueberry.core.expressions.propertyTesters
-\htmlinclude org_blueberry_core_expressions_propertyTesters.html
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
 
-\page xp_org_blueberry_osgi_applications org.blueberry.osgi.applications
-\htmlinclude org_blueberry_osgi_applications.html
+\code{.unparsed}
+<!ELEMENT definition (not | and | or | instanceof | test | systemTest | equals | count | with | resolve | adapt | iterate)>
+<!ATTLIST definition
+  id CDATA #REQUIRED>
+\endcode
 
-\page xp_org_blueberry_core_runtime_products org.blueberry.core.runtime.products
-\htmlinclude org_blueberry_core_runtime_products.html
+Provides a global definition of an expression to be used with the \c \<reference/\> expression element.
+This helps to reuse common expressions.
 
-\page xp_org_blueberry_ui_elementFactories org.blueberry.ui.elementFactories
-\htmlinclude org_blueberry_ui_elementFactories.html
+- <tt>id</tt>: a globally unique identifier for the expression definition
 
-\page xp_org_blueberry_ui_menus org.blueberry.ui.menus
-\htmlinclude org_blueberry_ui_menus.html
+\code{.unparsed}
+<!ELEMENT enablement (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+\endcode
 
-\page xp_org_blueberry_ui_perspectiveExtensions org.blueberry.ui.perspectiveExtensions
-\htmlinclude org_blueberry_ui_perspectiveExtensions.html
+A generic root element.
+The element can be used inside an extension point to define its enablement expression.
+The children of an enablement expression are combined using the and operator.
 
-\page xp_org_blueberry_ui_editors org.blueberry.ui.editors
-\htmlinclude org_blueberry_ui_editors.html
+\code{.unparsed}
+<!ELEMENT not (not | and | or | instanceof | test | systemTest | equals | count | with | resolve | adapt | iterate | reference)>
+\endcode
 
-\page xp_org_blueberry_ui_perspectives org.blueberry.ui.perspectives
-\htmlinclude org_blueberry_ui_perspectives.html
+This element represent a NOT operation on the result of evaluating it's sub-element expression.
 
-\page xp_org_blueberry_ui_presentationFactories org.blueberry.ui.presentationFactories
-\htmlinclude org_blueberry_ui_presentationFactories.html
+\code{.unparsed}
+<!ELEMENT and (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+\endcode
 
-\page xp_org_blueberry_ui_services org.blueberry.ui.services
-\htmlinclude org_blueberry_ui_services.html
+This element represent an AND operation on the result of evaluating all it's sub-elements expressions.
 
-\page xp_org_blueberry_ui_keywords org.blueberry.ui.keywords
-\htmlinclude org_blueberry_ui_keywords.html
+\code{.unparsed}
+<!ELEMENT or (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+\endcode
 
-\page xp_org_blueberry_ui_preferencePages org.blueberry.ui.preferencePages
-\htmlinclude org_blueberry_ui_preferencePages.html
+This element represent an OR operation on the result of evaluating all it's sub-element expressions.
 
-\page xp_org_blueberry_ui_tweaklets org.blueberry.ui.tweaklets
-\htmlinclude org_blueberry_ui_tweaklets.html
+\code{.unparsed}
+<!ELEMENT instanceof EMPTY>
+<!ATTLIST instanceof
+  value CDATA #REQUIRED>
+\endcode
 
-\page xp_org_blueberry_ui_views org.blueberry.ui.views
-\htmlinclude org_blueberry_ui_views.html
+This element is used to perform an instanceof check of the object in focus.
+The expression returns \c EvaluationResult.TRUE if the object's type is a sub type of the type specified by the attribute value.
+Otherwise \c EvaluationResult.FALSE is returned.
+
+- <tt>value</tt>: a fully qualified name of a class or interface
+
+\code{.unparsed}
+<!ELEMENT test EMPTY>
+<!ATTLIST test
+  property              CDATA #REQUIRED
+  args                  CDATA #IMPLIED
+  value                 CDATA #IMPLIED
+  forcePluginActivation (true | false)>
+\endcode
+
+This element is used to evaluate the property state of the object in focus.
+The set of testable properties can be extended using the propery tester extension point.
+The test expression returns \c EvaluationResult.NOT_LOADED if the property tester doing the actual testing isn't loaded yet and the attribute \c forcePluginActivation is set to \c false.
+If \c forcePluginActivation is set to \c true and the evaluation context used to evaluate this expression support plug-in activation then evaluating the property will result in activating the plug-in defining the tester.
+
+- <tt>property</tt>: The name of an object's property to test.
+- <tt>args</tt>: Additional arguments passed to the property tester. Multiple arguments are seperated by commas. Each individual argument is converted into a Java base type using the same rules as defined for the value attribute of the test expression.
+- <tt>value</tt>: The expected value of the property. Can be omitted if the property is a boolean property. The test expression is supposed to return \c EvaluationResult.TRUE if the property matches the value and \c EvaluationResult.FALSE otherwise. The value attribute is converted into a Java base type using the following rules:
+ - The string \c "true" is converted into \c Boolean.TRUE .
+ - The string \c "false" is converted into \c Boolean.FALSE .
+ - If the string contains a dot then the interpreter tries to convert the value into a \c Float object. If this fails the string is treated as a \c java.lang.String.
+ - If the string only consists of numbers then the interpreter converts the value in an \c Integer object.
+ - In all other cases the string is treated as a \c java.lang.String .
+ - The conversion of the string into a \c Boolean , \c Float , or \c Integer can be suppressed by surrounding the string with single quotes. For example, the attribute \c value="'true'" is converted into the string "true".
+- <tt>forcePluginActivation</tt>: A flag indicating whether the plug-in contributing the property tester should be loaded if necessary. As such, this flag should be used judiciously, in order to avoid unnecessary plug-in activations. Most clients should avoid setting this flag to \c true. This flag is only honored if the evaluation context used to evaluate this expression allows plug-in activation. Otherwise the flag is ignored and no plug-in loading takes place.
+
+\code{.unparsed}
+<!ELEMENT systemTest EMPTY>
+<!ATTLIST systemTest
+  property CDATA #REQUIRED
+  value    CDATA #REQUIRED>
+\endcode
+
+Tests a system property by calling the \c System.getProperty method and compares the result with the value specified through the value attribute.
+
+- <tt>property</tt>: The name of an system property to test.
+- <tt>value</tt>: The expected value of the property. The value is interpreted as a string value.
+
+\code{.unparsed}
+<!ELEMENT equals EMPTY>
+<!ATTLIST equals
+  value CDATA #REQUIRED>
+\endcode
+
+This element is used to perform an equals check of the object in focus.
+The expression returns \c EvaluationResult.TRUE if the object is equal to the value provided by the attribute value.
+Otherwise \c EvaluationResult.FALSE is returned.
+
+- <tt>value</tt>: The expected value. The value provided as a string is converted into a Java base type using the same rules as for the value attribute of the test expression.
+
+\code{.unparsed}
+<!ELEMENT count EMPTY>
+<!ATTLIST count
+  value CDATA #REQUIRED>
+\endcode
+
+This element is used to test the number of elements in a collection.
+
+- <tt>value</tt>: An expression to specify the number of elements in a list. Following wildcard characters can be used:
+ - <tt>*</tt>: any number of elements
+ - <tt>?</tt>: no elements or one element
+ - <tt>+</tt>: one or more elements
+ - <tt>!</tt>: no elements
+ - <tt>integer value</tt>: the list must contain the exact number of elements
+
+\code{.unparsed}
+<!ELEMENT with (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+<!ATTLIST with
+  variable CDATA #REQUIRED>
+\endcode
+
+This element changes the object to be inspected for all its child element to the object referenced by the given variable.
+If the variable can not be resolved then the expression will throw an \c ExpressionException when evaluating it.
+The children of a with expression are combined using the and operator.
+
+- <tt>variable</tt>: The name of the variable to be used for further inspection. It is up to the evaluator of an extension point to provide the variable in the variable pool.
+
+\code{.unparsed}
+<!ELEMENT resolve (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+<!ATTLIST resolve
+  variable CDATA #REQUIRED
+  args     CDATA #IMPLIED>
+\endcode
+
+This element changes the object to be inspected for all its child element to the object referenced by the given variable.
+If the variable can not be resolved then the expression will throw an \c ExpressionException when evaluating it.
+The children of a with expression are combined using the and operator.
+
+- <tt>variable</tt>: The name of the variable to be resolved. This variable is then used as the object in focus for child element evaluation. It is up to the evaluator of an extension point to provide a corresponding variable resolver (see berry::IVariableResolver) through the evaluation context passed to the root expression element when evaluating the expression.
+- <tt>args</tt>: Additional arguments passed to the variable resolver. Multiple arguments are seperated by commas. Each individual argument is converted into a Java base type using the same rules as defined for the value attribute of the test expression.
+
+\code{.unparsed}
+<!ELEMENT adapt (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+<!ATTLIST adapt
+  type CDATA #REQUIRED>
+\endcode
+
+This element is used to adapt the object in focus to the type specified by the attribute type.
+The expression returns not loaded if either the adapter or the type referenced isn't loaded yet.
+It throws an \c ExpressionException during evaluation if the type name doesn't exist at all.
+The children of an adapt expression are combined using the and operator.
+
+- <tt>type</tt>: the type to which the object in focus is to be adapted
+
+\code{.unparsed}
+<!ELEMENT iterate (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+<!ATTLIST iterate
+  operator (or|and)
+  ifEmpty  (true | false) >
+\endcode
+
+This element is used to iterate over a variable that is of type \c java.util.Collection.
+If the object in focus is not of type \c java.util.Collection then an \c ExpressionException will be thrown while evaluating the expression.
+
+- <tt>operator</tt>: Either "and" or "or". The operator defines how the child elements will be combined. If not specified, "and" will be used.
+- <tt>ifEmpty</tt>: The value return from the iterate expression if the collection is empty. If not specified then \c true is returned when the operator equals "and" and \c false is returned if the operator equals "or".
+
+\code{.unparsed}
+<!ELEMENT reference EMPTY>
+<!ATTLIST reference
+  definitionId CDATA #REQUIRED>
+\endcode
+
+This element is used to reference an expression from the \c org.blueberry.core.expressions.definitions extension point.
+The expression definition will be evaluated within the current expression element using the current evaluation context.
+
+- <tt>definitionId</tt>: the unique id of an expression from \c org.blueberry.core.expressions.definitions
+
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_ExprDef_Examples Examples
+
+\code{.unparsed}
+<extension point="org.blueberry.core.expressions.definitions">
+  <definition id="com.example.parts.activeProblemsView">
+    <with variable="activePartId">
+      <equals value="org.blueberry.ui.views.ProblemsView"/>
+    </with>
+  </definition>
+  <definition id="com.example.markers.markerSelection">
+    <iterate>
+      <instanceof value="org.blueberry.core.resources.IMarker"/>
+    </with>
+  </definition>
+</extension>
+\endcode
+
+Then this expression definition can be used when composing other expressions.
+
+\code{.unparsed}
+<enabledWhen>
+  <reference definitionId="com.example.parts.activeProblemsView">
+</enabledWhen>
+
+<visibleWhen>
+  <and>
+    <reference definitionId="com.example.parts.activeProblemsView"/>
+    <reference definitionId="com.example.markers.markerSelection"/>
+  </and>
+</visibleWhen>
+\endcode
+
+\subsection BlueBerryExtPointsIndex_CoreExpr_CommExpr Common Expressions
+
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_CommExpr_Id Identifier
+
+\c org.blueberry.core.expressions.commonExpression
+
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_CommExpr_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT enablement (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+\endcode
+
+A generic root element. The element can be used inside an extension point to define its enablement expression.
+The children of an enablement expression are combined using the and operator.
+
+\code{.unparsed}
+<!ELEMENT not (not | and | or | instanceof | test | systemTest | equals | count | with | resolve | adapt | iterate | reference)>
+\endcode
+
+This element represent a NOT operation on the result of evaluating it's sub-element expression.
+
+\code{.unparsed}
+<!ELEMENT and (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+\endcode
+
+This element represent an AND operation on the result of evaluating all it's sub-elements expressions.
+
+\code{.unparsed}
+<!ELEMENT or (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+\endcode
+
+This element represent an OR operation on the result of evaluating all it's sub-element expressions.
+
+\code{.unparsed}
+<!ELEMENT instanceof EMPTY>
+<!ATTLIST instanceof
+  value CDATA #REQUIRED>
+\endcode
+
+This element is used to perform an instanceof check of the object in focus.
+The expression returns \c EvaluationResult.TRUE if the object's type is a sub type of the type specified by the attribute value.
+Otherwise \c EvaluationResult.FALSE is returned.
+
+- <tt>value</tt>: a fully qualified name of a class or interface
+
+\code{.unparsed}
+<!ELEMENT test EMPTY>
+<!ATTLIST test
+  property              CDATA #REQUIRED
+  args                  CDATA #IMPLIED
+  value                 CDATA #IMPLIED
+  forcePluginActivation (true | false) >
+\endcode
+
+This element is used to evaluate the property state of the object in focus.
+The set of testable properties can be extended using the propery tester extension point.
+The test expression returns \c EvaluationResult.NOT_LOADED if the property tester doing the actual testing isn't loaded yet and the attribute \c forcePluginActivation is set to false.
+If \c forcePluginActivation is set to \c true and the evaluation context used to evaluate this expression support plug-in activation then evaluating the property will result in activating the plug-in defining the tester.
+
+- <tt>property</tt>: The name of an object's property to test.
+- <tt>args</tt>: Additional arguments passed to the property tester. Multiple arguments are seperated by commas. Each individual argument is converted into a Java base type using the same rules as defined for the value attribute of the test expression.
+- <tt>value</tt>: The expected value of the property. Can be omitted if the property is a boolean property. The test expression is supposed to return EvaluationResult.TRUE if the property matches the value and EvaluationResult.FALSE otherwise. The value attribute is converted into a Java base type using the following rules:
+ - The string "true" is converted into \c Boolean.TRUE
+ - The string "false" is converted into \c Boolean.FALSE
+ - If the string contains a dot then the interpreter tries to convert the value into a \c Float object. If this fails the string is treated as a \c java.lang.String
+ - If the string only consists of numbers then the interpreter converts the value in an \c Integer object.
+ - In all other cases the string is treated as a \c java.lang.String
+ - The conversion of the string into a \c Boolean , \c Float , or \c Integer can be suppressed by surrounding the string with single quotes. For example, the attribute \c value="'true'" is converted into the string "true"
+- <tt>forcePluginActivation</tt>: A flag indicating whether the plug-in contributing the property tester should be loaded if necessary. As such, this flag should be used judiciously, in order to avoid unnecessary plug-in activations. Most clients should avoid setting this flag to true. This flag is only honored if the evaluation context used to evaluate this expression allows plug-in activation. Otherwise the flag is ignored and no plug-in loading takes place.
+
+\code{.unparsed}
+<!ELEMENT systemTest EMPTY>
+<!ATTLIST systemTest
+  property CDATA #REQUIRED
+  value    CDATA #REQUIRED>
+\endcode
+
+Tests a system property by calling the \c System.getProperty method and compares the result with the value specified through the value attribute.
+
+- <tt>property</tt>: The name of an system property to test.
+- <tt>value</tt>: The expected value of the property. The value is interpreted as a string value.
+
+\code{.unparsed}
+<!ELEMENT equals EMPTY>
+<!ATTLIST equals
+  value CDATA #REQUIRED>
+\endcode
+
+This element is used to perform an equals check of the object in focus.
+The expression returns \c EvaluationResult.TRUE if the object is equal to the value provided by the attribute value.
+Otherwise \c EvaluationResult.FALSE is returned.
+
+- <tt>value</tt>: The expected value. The value provided as a string is converted into a Java base type using the same rules as for the value attribute of the test expression.
+
+\code{.unparsed}
+<!ELEMENT count EMPTY>
+<!ATTLIST count
+  value CDATA #REQUIRED>
+\endcode
+
+This element is used to test the number of elements in a collection.
+
+- <tt>value</tt>: An expression to specify the number of elements in a list. Following wildcard characters can be used:
+ - <tt>*</tt>: any number of elements
+ - <tt>?</tt>: no elements or one element
+ - <tt>+</tt>: one or more elements
+ - <tt>!</tt>: no elements
+ - <tt>integer value</tt>: the list must contain the exact number of elements
+
+\code{.unparsed}
+<!ELEMENT with (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+<!ATTLIST with
+  variable CDATA #REQUIRED>
+\endcode
+
+This element changes the object to be inspected for all its child element to the object referenced by the given variable.
+If the variable can not be resolved then the expression will throw an \c ExpressionException when evaluating it.
+The children of a with expression are combined using the and operator.
+
+- <tt>variable</tt>: The name of the variable to be used for further inspection. It is up to the evaluator of an extension point to provide the variable in the variable pool.
+
+\code{.unparsed}
+<!ELEMENT resolve (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+<!ATTLIST resolve
+  variable CDATA #REQUIRED
+  args     CDATA #IMPLIED>
+\endcode
+
+This element changes the object to be inspected for all its child element to the object referenced by the given variable.
+If the variable can not be resolved then the expression will throw an \c ExpressionException when evaluating it.
+The children of a with expression are combined using the and operator.
+
+- <tt>variable</tt>: The name of the variable to be resolved. This variable is then used as the object in focus for child element evaluation. It is up to the evaluator of an extension point to provide a corresponding variable resolver (see berry::IVariableResolver) through the evaluation context passed to the root expression element when evaluating the expression.
+- <tt>args</tt>: Additional arguments passed to the variable resolver. Multiple arguments are seperated by commas. Each individual argument is converted into a Java base type using the same rules as defined for the value attribute of the test expression.
+
+\code{.unparsed}
+<!ELEMENT adapt (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+<!ATTLIST adapt
+  type CDATA #REQUIRED>
+\endcode
+
+This element is used to adapt the object in focus to the type specified by the attribute type.
+The expression returns not loaded if either the adapter or the type referenced isn't loaded yet. It throws an \c ExpressionException during evaluation if the type name doesn't exist at all.
+The children of an adapt expression are combined using the and operator.
+
+- <tt>type</tt>: the type to which the object in focus is to be adapted
+
+\code{.unparsed}
+<!ELEMENT iterate (not , and , or , instanceof , test , systemTest , equals , count , with , resolve , adapt , iterate , reference)*>
+<!ATTLIST iterate
+  operator (or|and)
+  ifEmpty  (true | false) >
+\endcode
+
+This element is used to iterate over a variable that is of type \c java.util.Collection.
+If the object in focus is not of type \c java.util.Collection then an \c ExpressionException will be thrown while evaluating the expression.
+
+- <tt>operator</tt>: Either "and" or "or". The operator defines how the child elements will be combined. If not specified, "and" will be used.
+- <tt>ifEmpty</tt>: The value return from the iterate expression if the collection is empty. If not specified then \c true is returned when the operator equals "and" and \c false is returned if the operator equals "or".
+
+\code{.unparsed}
+<!ELEMENT reference EMPTY>
+<!ATTLIST reference
+  definitionId CDATA #REQUIRED>
+\endcode
+
+This element is used to reference an expression from the \c org.blueberry.core.expressions.definitions extension point.
+The expression definition will be evaluated within the current expression element using the current evaluation context.
+
+- <tt>definitionId</tt>: the unique id of an expression from \c org.blueberry.core.expressions.definitions
+
+\subsection BlueBerryExtPointsIndex_CoreExpr_PropTest Property Testers
+
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_PropTest_Id Identifier
+
+\c org.blueberry.core.expressions.propertyTesters
+
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_PropTest_Desc Description
+
+This extension point allows to add properties to an already existing type.
+Those properties can then be used inside the expression language's test expression element.
+
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_PropTest_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (propertyTester*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
+
+\code{.unparsed}
+<!ELEMENT propertyTester EMPTY>
+<!ATTLIST propertyTester
+  id         CDATA #REQUIRED
+  type       CDATA #REQUIRED
+  namespace  CDATA #REQUIRED
+  properties CDATA #REQUIRED
+  class      CDATA #REQUIRED>
+\endcode
+
+- <tt>id</tt>: Unique identifier for the property tester.
+- <tt>type</tt>: The type to be extended by this property tester.
+- <tt>namespace</tt>: A unique id determining the name space the properties are added to.
+- <tt>properties</tt>: A comma separated list of properties provided by this property tester.
+- <tt>class</tt>: The name of the class that implements the testing methods. The class must be public and extend \c org.blueberry.core.expressions.PropertyTester with a public 0-argument constructor.
+
+\subsubsection BlueBerryExtPointsIndex_CoreExpr_PropTest_Examples Examples
+
+\code{.unparsed}
+<extension point="org.eclipse.core.expressions.propertyTesters">
+  <propertyTester
+    id="org.eclipse.jdt.ui.IResourceTester"
+    type="org.eclipse.core.resources.IResource"
+    namespace="org.eclipse.jdt.ui"
+    properties="canDelete"
+    class="org.eclipse.jdt.ui.internal.ResourceTester">
+  </propertyTester>
+</extension>
+\endcode
+
+\section BlueBerryExtPointsIndex_PlatformRuntime Platform Runtime
+
+\subsection BlueBerryExtPointsIndex_PlatformRuntime_App Applications
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_App_Id Identifier
+
+\c org.blueberry.osgi.applications
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_App_Desc Description
+
+The applications extension point allows plugins to contribute applications to the BlueBerry Platform.
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_App_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (application)+>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+\code{.unparsed}
+<!ELEMENT application (run)>
+<!ATTLIST application
+  id   CDATA #REQUIRED
+  name CDATA #IMPLIED>
+\endcode
+
+\code{.unparsed}
+<!ELEMENT run EMPTY>
+<!ATTLIST run
+  class CDATA #REQUIRED>
+\endcode
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_App_Examples Examples
+
+\code{.unparsed}
+<extension id="sampleApplication" point="org.blueberry.osgi.applications">
+  <application id="my.domain.application">
+  <run class="xyz::SampleApp"/>
+  </application>
+</extension>
+\endcode
+
+\subsection BlueBerryExtPointsIndex_PlatformRuntime_Prod Products
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_Prod_Id Identifier
+
+\c org.blueberry.core.runtime.products
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_Prod_Desc Description
+
+Products are the BlueBerry unit of branding.
+Product extensions are supplied by plug-ins wishing to define one or more products.
+There must be one product per extension as the extension id is used in processing and identifying the product.
+
+There are two possible forms of product extension, static and dynamic.
+Static product extensions directly contain all relevant information about the product.
+Dynamic product extensions identify a class (an \c IProductProvider) which is capable of defining one or more products when queried.
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_Prod_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension ((product | provider))>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+\code{.unparsed}
+<!ELEMENT product (property*)>
+<!ATTLIST product
+  application CDATA #REQUIRED
+  name        CDATA #REQUIRED
+  description CDATA #IMPLIED>
+\endcode
+
+- <tt>application</tt>: the default application to run when running this product
+- <tt>name</tt>: the human-readable name of this product
+- <tt>description</tt>: the human-readable description of this product
+
+\code{.unparsed}
+<!ELEMENT property EMPTY>
+<!ATTLIST property
+  name  CDATA #REQUIRED
+  value CDATA #REQUIRED>
+\endcode
+
+- <tt>name</tt>: the key under which this property is stored
+- <tt>value</tt>: the value of this property
+
+\code{.unparsed}
+<!ELEMENT provider (run)>
+\endcode
+
+\code{.unparsed}
+<!ELEMENT run EMPTY>
+<!ATTLIST run
+  class CDATA #REQUIRED>
+\endcode
+
+- <tt>class</tt>: the fully-qualified name of a class which implements \c IProductProvider
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_Prod_Examples Examples
+
+\code{.unparsed}
+<extension id="coolProduct" point="org.blueberry.core.runtime.products">
+  <product name="%coolName" application="coolApplication" description="%coolDescription">
+    <property name="windowImages" value="window.gif"/>
+    <property name="aboutImage" value="image.gif"/>
+    <property name="aboutText" value="%aboutText"/>
+    <property name="appName" value="CoolApp"/>
+    <property name="welcomePage" value="$nl$/welcome.xml"/>
+    <property name="preferenceCustomization" value="plugin_customization.ini"/>
+  </product>
+</extension>
+\endcode
+
+The following is an example of a dynamic product (product provider) declaration: Following is an example of an application declaration:
+
+\code{.unparsed}
+<extension id="coolProvider" point="org.blueberry.core.runtime.products">
+  <provider>
+     <run class="me::CoolProvider"/>
+  </provider>
+</extension>
+\endcode
+
+\subsubsection BlueBerryExtPointsIndex_PlatformRuntime_Prod_SupplImpl Supplied Implementation
+
+No implementations of \c IProductProvider are supplied.
+
+\section BlueBerryExtPointsIndex_Workbench Workbench
+
+\subsection BlueBerryExtPointsIndex_Workbench_Edit Internal and External Editors
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Edit_Id Identifier
+
+\c org.blueberry.ui.editors
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Edit_Desc Description
+
+This extension point is used to add new editors to the workbench.
+A editor is a visual component within a workbench page.
+It is typically used to edit or browse a document or input object.
+To open an editor, the user will typically invoke "Open" on an \c IFile.
+When this action is performed the workbench registry is consulted to determine an appropriate editor for the file type and then a new instance of the editor type is created.
+The actual result depends on the type of the editor.
+The workbench provides support for the creation of internal editors, which are tightly integrated into the workbench, and external editors, which are launched in a separate frame window.
+There are also various levels of integration between these extremes.
+
+In the case of an internal editor tight integration can be achieved between the workbench window and the editor part.
+The workbench menu and toolbar are pre-loaded with a number of common actions, such as cut, copy, and paste.
+The active part, view or editor, is expected to provide the implementation for these actions.
+An internal editor may also define new actions which appear in the workbench window.
+These actions only appear when the editor is active.
+
+The integration between the workbench and external editors is more tenuous.
+In this case the workbench may launch an editor but after has no way of determining the state of the external editor or collaborating with it by any means except through the file system.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Edit_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (editor*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
+
+\code{.unparsed}
+<!ELEMENT editor (contentTypeBinding*)>
+<!ATTLIST editor
+  id               CDATA #REQUIRED
+  name             CDATA #REQUIRED
+  icon             CDATA #IMPLIED
+  extensions       CDATA #IMPLIED
+  class            CDATA #IMPLIED
+  command          CDATA #IMPLIED
+  launcher         CDATA #IMPLIED
+  contributorClass CDATA #IMPLIED
+  default          (true | false) "false"
+  filenames        CDATA #IMPLIED
+  matchingStrategy CDATA #IMPLIED>
+\endcode
+
+- <tt>id</tt>: a unique name that will be used to identify this editor
+- <tt>name</tt>: a translatable name that will be used in the UI for this editor
+- <tt>icon</tt>: A relative name of the icon that will be used for all resources that match the specified extensions. Editors should provide an icon to make it easy for users to distinguish between different editor types. If you specify a command rather than a class, an icon is not needed. In that case, the workbench will use the icon provided by the operating system.
+- <tt>extensions</tt>: an optional field containing the list of file types understood by the editor. This is a string containing comma separate file extensions. For instance, an editor which understands hypertext documents may register for "htm, html".
+- <tt>class</tt>: the name of a class that implements berry::IEditorPart. The attributes \c class , \c command , and \c launcher are mutually exclusive. If this attribute is defined then \c contributorClass should also be defined.
+- <tt>command</tt>: a command to run in order to launch an external editor. The executable command must be located on the system path or in the plug-in's directory. The attributes class, command, and launcher are mutually exclusive.
+- <tt>launcher</tt>: the name of a class which that implements berry::IEditorLauncher. A launcher will open an external editor. The attributes \c class , \c command , and \c launcher are mutually exclusive.
+- <tt>contributorClass</tt>: the name of a class that implements berry::IEditorActionBarContributor. This attribute should only be defined if the \c class attribute is defined. This class is used to add new actions to the workbench menu and tool bar which reflect the features of the editor type.
+- <tt>default</tt>: if true, this editor will be used as the default editor for the type. This is only relevant in a case where more than one editor is registered for the same type. If an editor is not the default for the type, it can still be launched using "Open with..." submenu for the selected resource.
+Please note that this attribute is only honored for filename and extension associations at this time. It will not be honored for content type bindings. Content type-based resolution will occur on a first come, first serve basis and is not explicitly specified.
+- <tt>filenames</tt>: an optional field containing the list of file names understood by the editor. This is a string containing comma separate file names. For instance, an editor which understands specific hypertext documents may register for "ejb.htm, ejb.html".
+- <tt>matchingStrategy</tt>: the name of a class that implements berry::IEditorMatchingStrategy. This attribute should only be defined if the \c class attribute is defined. This allows the editor extension to provide its own algorithm for matching the input of one of its editors to a given editor input.
+
+\code{.unparsed}
+<!ELEMENT contentTypeBinding EMPTY>
+<!ATTLIST contentTypeBinding
+  contentTypeId CDATA #REQUIRED>
+\endcode
+
+Advertises that the containing editor understands the given content type and is suitable for editing files of that type.
+
+- <tt>contentTypeId</tt>: The content type identifier. This is an ID defined by the \c org.blueberry.core.runtime.contentTypes extension point.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Edit_Examples Examples
+
+The following is an example of an internal editor extension definition:
+
+\code{.unparsed}
+<extension point="org.blueberry.ui.editors">
+  <editor
+    id="com.xyz.XMLEditor"
+    name="Fancy XYZ XML editor"
+    icon="./icons/XMLEditor.gif"
+    extensions="xml"
+    class="xyz::XMLEditor"
+    contributorClass="xyz::XMLEditorContributor"
+    default="false">
+  </editor>
+</extension>
+\endcode
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Edit_SupplImpl Supplied Implementation
+
+The workbench provides a "Default Text Editor". The end user product may contain other editors as part of the shipping bundle. In that case, editors will be registered as extensions using the syntax described above.
+
+\subsection BlueBerryExtPointsIndex_Workbench_Keywords Keywords
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Keywords_Id Identifier
+
+\c org.blueberry.ui.keywords
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Keywords_Desc Description
+
+The keywords extension point defines keywords and a unique id for reference by other schemas. See \c propertyPages and \c preferencePages .
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Keywords_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (keyword*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
+
+\code{.unparsed}
+<!ELEMENT keyword EMPTY>
+<!ATTLIST keyword
+  id    CDATA #REQUIRED
+  label CDATA #REQUIRED>
+\endcode
+
+- <tt>id</tt>: The id is the unique id used to reference the keyword
+- <tt>label</tt>: The human readable label of the keyword
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Keywords_Examples Examples
+
+The following is an example of a keyword extension:
+
+\code{.unparsed}
+<extension
+  point="org.blueberry.ui.keywords">
+  <keyword
+    label="presentation tab themes"
+    id="com.xyz.AppearanceKeywords"/>
+</extension>
+\endcode
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Keywords_SupplImpl Supplied Implementation
+
+Keywords are used only with preference and property pages. See the \c keywordReference element of the \c org.blueberry.ui.propertyPages and \c org.blueberry.ui.preferencePages extension points.
+
+\subsection BlueBerryExtPointsIndex_Workbench_PerspExt Perspective Extensions
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PerspExt_Id Identifier
+
+\c org.blueberry.ui.perspectiveExtensions
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PerspExt_Desc Description
+
+This extension point is used to extend perspectives registered by other plug-ins.
+A perspective defines the initial contents of the window action bars (menu and toolbar) and the initial set of views and their layout within a workbench page.
+Other plug-ins may contribute actions or views to the perspective which appear when the perspective is selected.
+Optional additions by other plug-ins are appended to the initial definition.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PerspExt_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (perspectiveExtension*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
+
+\code{.unparsed}
+<!ELEMENT perspectiveExtension (actionSet | viewShortcut | perspectiveShortcut | newWizardShortcut | view | showInPart | hiddenMenuItem | hiddenToolBarItem)*>
+<!ATTLIST perspectiveExtension
+  targetID IDREF #REQUIRED>
+\endcode
+
+- <tt>targetID</tt>: the unique identifier of the perspective (as specified in the registry) into which the contribution is made. If the value is set to "*" the extension is applied to all perspectives.
+
+\code{.unparsed}
+<!ELEMENT actionSet EMPTY>
+<!ATTLIST actionSet
+  id IDREF #REQUIRED>
+\endcode
+
+- <tt>id</tt>: the unique identifier of the action set which will be added to the perspective.
+
+\code{.unparsed}
+<!ELEMENT viewShortcut EMPTY>
+<!ATTLIST viewShortcut
+  id IDREF #REQUIRED>
+\endcode
+
+- <tt>id</tt>: the unique identifier of the view which will be added to the perspective's "Show View" submenu of the "Window" menu.
+
+\code{.unparsed}
+<!ELEMENT perspectiveShortcut EMPTY>
+<!ATTLIST perspectiveShortcut
+  id IDREF #REQUIRED>
+\endcode
+
+- <tt>id</tt>: the unique identifier of the perspective which will be added to the perspective's "Open Perspective" submenu of the "Window" menu.
+
+\code{.unparsed}
+<!ELEMENT newWizardShortcut EMPTY>
+<!ATTLIST newWizardShortcut
+  id IDREF #REQUIRED>
+\endcode
+
+- <tt>id</tt>: the unique identifier of the new wizard which will be added to the perspective's "New" submenu of the "File" menu.
+
+\code{.unparsed}
+<!ELEMENT showInPart EMPTY>
+<!ATTLIST showInPart
+  id IDREF #IMPLIED>
+\endcode
+
+- <tt>id</tt>: the unique identifier of the view which will be added to the perspective's "Show In..." prompter in the Navigate menu.
+
+\code{.unparsed}
+<!ELEMENT view EMPTY>
+<!ATTLIST view
+  id           IDREF #REQUIRED
+  relative     IDREF #IMPLIED
+  relationship (stack|left|right|top|bottom|fast)
+  ratio        CDATA #IMPLIED
+  visible      (true | false)
+  closeable    (true | false)
+  moveable     (true | false)
+  standalone   (true | false)
+  showTitle    (true | false)
+  minimized    (true | false) "false">
+\endcode
+
+- <tt>id</tt>: the unique identifier of the view which will be added to the perspective layout.
+- <tt>relative</tt>: the unique identifier of a view which already exists in the perspective. This will be used as a reference point for placement of the view. The relationship between these two views is defined by \c relationship . Ignored if relationship is "fast".
+- <tt>relationship</tt>: specifies the relationship between \c id and \c relative . The following values are supported:
+ - <tt>fast</tt>: the view extension will be created as a fast view.
+ - <tt>stack</tt>: the view extension will be stacked with the relative view in a folder.
+ - <tt>left, right, top, bottom</tt>: the view extension will be placed beside the relative view. In this case a \c ratio must also be defined.
+- <tt>ratio</tt>: the percentage of area within the relative view which will be donated to the view extension. If the view extension is a fast view, the ratio is the percentage of the workbench the fast view will cover when active. This must be defined as a floating point value and lie between 0.05 and 0.95.
+- <tt>visible</tt>: whether the view is initially visible when the perspective is opened. This attribute should have a value of "true" or "false" if used. If this attribute is not used, the view will be initially visible by default.
+- <tt>closeable</tt>: whether the view is closeable in the target perspective. This attribute should have a value of "true" or "false" if used. If this attribute is not used, the view will be closeable, unless the perspective itself is marked as fixed.
+- <tt>moveable</tt>: whether the view is moveable. A non-moveable view cannot be moved either within the same folder, or moved between folders in the perspective. This attribute should have a value of "true" or "false" if used. If this attribute is not used, the view will be moveable, unless the perspective itself is marked as fixed.
+- <tt>standalone</tt>: whether the view is a standalone view. A standalone view cannot be docked together with others in the same folder. This attribute should have a value of "true" or "false" if used. This attribute is ignored if the relationship attribute is "fast" or "stacked". If this attribute is not used, the view will be a regular view, not a standalone view (default is "false").
+- <tt>showTitle</tt>: whether the view's title is shown. This attribute should have a value of "true" or "false" if used. This attribute only applies to standalone views. If this attribute is not used, the view's title will be shown (default is "true").
+- <tt>minimized</tt>: If the perspective extension will result in a new view stack being created (i.e. the 'relationship' attribute is one of left, right, top or bottom) this field determines the new stack's initial display state.
+
+\code{.unparsed}
+<!ELEMENT hiddenMenuItem EMPTY>
+<!ATTLIST hiddenMenuItem
+  id CDATA #REQUIRED>
+\endcode
+
+- <tt>id</tt>: The unique identifier of the Command which is to be removed from the menu. <b>WARNING:</b> This is considered to be a 'Product level' extension and should not be used in consumable plugins without great care.
+
+\code{.unparsed}
+<!ELEMENT hiddenToolBarItem EMPTY>
+<!ATTLIST hiddenToolBarItem
+  id CDATA #REQUIRED>
+\endcode
+
+- <tt>id</tt>: The unique identifier of the Command which is to be removed from thetoolbar. <b>WARNING:</b> This is considered to be a 'Product level' extension and should not be used in consumable plugins without great care.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PerspExt_Examples Examples
+
+The following is an example of a perspective extension (note the subelements and the way attributes are used):
+
+\code{.unparsed}
+<extension point="org.blueberry.ui.perspectiveExtensions">
+  <perspectiveExtension
+    targetID="org.blueberry.ui.resourcePerspective">
+    <actionSet id="org.xyz.MyActionSet"/>
+    <viewShortcut id="org.xyz.views.PackageExplorer"/>
+    <newWizardShortcut id="org.xyz.wizards.NewProjectCreationWizard"/>
+    <perspectiveShortcut id="org.xyz.MyPerspective"/>
+    <view id="org.xyz.views.PackageExplorer"
+      relative="org.blueberry.ui.views.ResourceNavigator"
+      relationship="stack"/>
+    <view id="org.xyz.views.TypeHierarchy"
+      relative="org.blueberry.ui.views.ResourceNavigator"
+      relationship="left"
+      ratio="0.50"/>
+  </perspectiveExtension>
+</extension>
+\endcode
+
+In the example above, an action set, view shortcut, new wizard shortcut, and perspective shortcut are contributed to the initial contents of the Resource Perspective.
+In addition, the Package Explorer view is stacked on the Resource Navigator and the Type Hierarchy View is added beside the Resource Navigator.
+
+\subsection BlueBerryExtPointsIndex_Workbench_Persp Perspectives
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Persp_Id Identifier
+
+\c org.blueberry.ui.perspective
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Persp_Desc Description
+
+This extension point is used to add perspective factories to the workbench.
+A perspective factory is used to define the initial layout and visible action sets for a perspective.
+The user can select a perspective by invoking the "Open Perspective" submenu of the "Window" menu.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Persp_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (perspective*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
+
+\code{.unparsed}
+<!ELEMENT perspective (description? , keywordReference*)>
+<!ATTLIST perspective
+  id    CDATA #REQUIRED
+  name  CDATA #REQUIRED
+  class CDATA #REQUIRED
+  icon  CDATA #IMPLIED
+  fixed (true | false)>
+\endcode
+
+- <tt>id</tt>: a unique name that will be used to identify this perspective.
+- <tt>name</tt>: a translatable name that will be used in the workbench window menu bar to represent this perspective.
+- <tt>class</tt>: a fully qualified name of the class that implements berry::IPerspectiveFactory interface.
+- <tt>icon</tt>: a relative name of the icon that will be associated with this perspective.
+- <tt>fixed</tt>: indicates whether the layout of the perspective is fixed. If true, then views created by the perspective factory are not closeable, and cannot be moved. The default is false.
+
+\code{.unparsed}
+<!ELEMENT description (#PCDATA)>
+\endcode
+
+An optional subelement whose body should contain text providing a short description of the perspective.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Persp_Examples Examples
+
+The following is an example of a perspective extension:
+
+\code{.unparsed}
+<extension
+  point="org.blueberry.ui.perspectives">
+  <perspective
+    id="org.blueberry.ui.resourcePerspective"
+    name="Resource"
+    class="berry::ResourcePerspective"
+    icon="resources/MyIcon.gif">
+  </perspective>
+</extension>
+\endcode
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Persp_SupplImpl Supplied Implementation
+
+The workbench provides a "Resource Perspective".
+Additional perspectives may be added by plug-ins.
+They are selected using the "Open Perspective" submenu of the "Window" menu.
+
+\subsection BlueBerryExtPointsIndex_Workbench_PrefPages Preference Pages
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PrefPages_Id Identifier
+
+\c org.blueberry.ui.preferencePages
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PrefPages_Desc Description
+
+The workbench provides one common dialog box for preferences.
+The purpose of this extension point is to allow plug-ins to add pages to the preference dialog box.
+When preference dialog box is opened (initiated from the menu bar), pages contributed in this way will be added to the dialog box.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PrefPages_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (page*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
+
+\code{.unparsed}
+<!ELEMENT page (keywordReference*)>
+<!ATTLIST page
+  id       CDATA #REQUIRED
+  name     CDATA #REQUIRED
+  class    CDATA #REQUIRED
+  category IDREF #IMPLIED>
+\endcode
+
+- <tt>id</tt>: a unique name that will be used to identify this page.
+- <tt>name</tt>: a translatable name that will be used in the UI for this page.
+- <tt>class</tt>: a name of the fully qualified class that implements berry::IWorkbenchPreferencePage.
+- <tt>category</tt>: a path indicating the location of the page in the preference tree. The path may either be a parent node ID or a sequence of IDs separated by '/', representing the full path from the root node.
+
+\code{.unparsed}
+<!ELEMENT keywordReference EMPTY>
+<!ATTLIST keywordReference
+  id IDREF #REQUIRED>
+\endcode
+
+A reference by a preference page to a keyword. See the keywords extension point.
+
+- <tt>id</tt>: The id of the keyword being referred to.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PrefPages_Examples Examples
+
+The following is an example for the preference extension point:
+
+\code{.unparsed}
+<extension
+  point="org.blueberry.ui.preferencePages">
+  <page
+    id="com.xyz.prefpage1"
+    name="XYZ"
+    class="xyz::PrefPage1">
+    <keywordReference id="xyz.Keyword"/>
+  </page>
+  <page
+    id="com.xyz.prefpage2"
+    name="Keyboard Settings"
+    class="xyz::PrefPage2"
+    category="com.xyz.prefpage1">
+  </page>
+</extension>
+\endcode
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PrefPages_SupplImpl Supplied Implementation
+
+The workbench adds several pages for setting the preferences of the platform. Pages registered through this extension will be added after them according to their category information.
+
+\subsection BlueBerryExtPointsIndex_Workbench_PresFact Presentation Factories
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PresFact_Id Identifier
+
+\c org.blueberry.ui.presentationFactories
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PresFact_Desc Description
+
+This extension point is used to add presentation factories to the workbench. A presentation factory defines the overall look and feel of the workbench, including how views and editors are presented.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PresFact_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (factory*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+\code{.unparsed}
+<!ELEMENT factory EMPTY>
+<!ATTLIST factory
+  class CDATA #REQUIRED
+  id    CDATA #REQUIRED
+  name  CDATA #REQUIRED>
+\endcode
+
+- <tt>class</tt>: Specify the fully qualified class to be used for the presentation factory. The specified value must implement the interface berry::IPresentationFactory.
+- <tt>id</tt>: a unique name that will be used to identify this presentation factory
+- <tt>name</tt>: a translatable name that can be used to show this presentation factory in the UI
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PresFact_Examples Examples
+
+The following is an example of a presentationFactory extension:
+
+\code{.unparsed}
+<extension point="org.blueberry.ui.presentationFactories">
+  <factory
+    class="berry::ExampleWorkbenchPresentationFactory"/>
+</extension>
+\endcode
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_PresFact_SupplImpl Supplied Implementation
+
+If a presentation factory is not specified or is missing then the implementation in berry::QtWorkbenchPresentationFactory will be used.
+
+\subsection BlueBerryExtPointsIndex_Workbench_Services Services
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Services_Id Identifier
+
+\c org.blueberry.ui.services
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Services_Desc Description
+
+Define service factories so that services can be contributed declaratively and will be available through berry::IServiceLocator::GetService(Class).
+The implementation of \c AbstractServiceFactory must be able to return a global service and multiple child services (if applicable).
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Services_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (serviceFactory? , sourceProvider?)+>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+Contribute services to the workbench.
+
+\code{.unparsed}
+<!ELEMENT serviceFactory (service+)>
+<!ATTLIST serviceFactory
+  factoryClass CDATA #REQUIRED>
+\endcode
+
+Match a service interface to a factory that can supply a hierachical implementation of that service.
+
+- <tt>factoryClass</tt>: The factory that extends \c AbstractServiceFactory and can create the implementation for the \c serviceClass.
+
+\code{.unparsed}
+<!ELEMENT service EMPTY>
+<!ATTLIST service
+  serviceClass CDATA #IMPLIED>
+\endcode
+
+A service this factory can provide.
+
+- <tt>serviceClass</tt>: The interface that represents a service contract.
+
+\code{.unparsed}
+<!ELEMENT sourceProvider (variable+)>
+<!ATTLIST sourceProvider
+  provider CDATA #REQUIRED>
+\endcode
+
+A Source Provider supplies source variables to the IEvaluationService. It can also notify the IEvaluationService when one or more of the variables change.
+
+- <tt>provider</tt>: This class must provide variables and call the appropriate \c fireSourceChanged(*) method when any of the variables change.
+
+\code{.unparsed}
+<!ELEMENT variable EMPTY>
+<!ATTLIST variable
+  name          CDATA #REQUIRED
+  priorityLevel (workbench|activeContexts|activeShell|activeWorkbenchWindow|activeEditorId|activePartId|activeSite) >
+\endcode
+
+A source variable from this provider.
+A source provider must declare all variables that it provides.
+
+- <tt>name</tt>: The name of a contributed source variable. It is a good practice to prepend the plugin id to the variable name to avoid collisions with other source providers.
+- <tt>priorityLevel</tt>: For conflict resolution used by services like the \c IHandlerService , contributed source variables must assign a priority. workbench is the global default priority. See \c ISources for relative priority information.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Services_Examples Examples
+
+Here is a basic definition:
+
+\code{.unparsed}
+<extension point="org.blueberry.ui.services">
+  <serviceFactory factoryClass="my::LevelServiceFactory">
+    <service serviceClass="my::ILevelService">
+    </service>
+  </serviceFactory>
+</extension>
+\endcode
+
+The LevelServiceFactory can return an ILevelService when it is requested from the IServiceLocator:
+
+\code{.unparsed}
+berry::ILevelService::Pointer s = GetSite()->GetService(my::ILevelService::GetStaticClassName());
+std::cout << s->GetLevel();
+\endcode
+
+In this test example, the factory would instantiate three \c ILevelService implementations during the first call to \c GetSite()->GetService(*) . The global one in the workbench, one for the workbench window, and one for the site.
+
+\subsection BlueBerryExtPointsIndex_Workbench_Tweak Tweaklets
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Tweak_Id Identifier
+
+\c org.blueberry.ui.tweaklets
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Tweak_Desc Description
+
+Typically, although not required, the value of the \c definition attribute is the fully qualified name without colons of an abstract class defined by the workbench, and the value of the \c implementation attribute is the fully qualified name of a non-abstract class provided by the extending plug-in.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Tweak_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (tweaklet)*>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+\code{.unparsed}
+<!ELEMENT tweaklet EMPTY>
+<!ATTLIST tweaklet
+  id             CDATA #REQUIRED
+  name           CDATA #REQUIRED
+  description    CDATA #IMPLIED
+  definition     CDATA #IMPLIED
+  implementation CDATA #IMPLIED>
+\endcode
+
+- <tt>id</tt>: a unique name that will be used to identify this tweaklet
+- <tt>name</tt>: a translatable name that will be used in the UI for this tweaklet
+- <tt>description</tt>: a translatable short description of this tweaklet, to be used in the UI
+- <tt>definition</tt>: an identifier of the tweaklet definition in the workbench, typically a fully qualified type name without colons
+- <tt>implementation</tt>: an identifier of the tweaklet implementation provided by the extender, typically a fully qualified class name
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Tweak_SupplImpl Supplied Implementation
+
+Tweaklets are usually used to specialize the workbench for a specific GUI toolkit.
+
+\subsection BlueBerryExtPointsIndex_Workbench_Views Views
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Views_Id Identifier
+
+\c org.blueberry.ui.views
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Views_Desc Description
+
+This extension point is used to define additional views for the workbench.
+A view is a visual component within a workbench page.
+It is typically used to navigate a hierarchy of information (like the workspace), open an editor, or display properties for the active editor.
+The user can make a view visible from the Window > Show View menu or close it from the view local title bar.
+
+In order to reduce the visual clutter in the Show View Dialog, views should be grouped using categories.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Views_ConfMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (category | view | stickyView)*>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
+
+\code{.unparsed}
+<!ELEMENT category EMPTY>
+<!ATTLIST category
+  id             CDATA #REQUIRED
+  name           CDATA #REQUIRED
+  parentCategory IDREF #IMPLIED>
+\endcode
+
+- <tt>id</tt>: a unique name that will be used to identify this category
+- <tt>name</tt>: a translatable name that will be used in the UI for this category
+- <tt>parentCategory</tt>: an optional path composed of category IDs separated by '/'. This allows the creation of a hierarchy of categories.
+
+\code{.unparsed}
+<!ELEMENT view (description? , keywordReference*)>
+<!ATTLIST view
+  id                 CDATA #REQUIRED
+  name               CDATA #REQUIRED
+  category           IDREF #IMPLIED
+  class              CDATA #REQUIRED
+  icon               CDATA #IMPLIED
+  fastViewWidthRatio CDATA #IMPLIED
+  allowMultiple      (true | false)
+  restorable         (true | false) "true">
+\endcode
+
+- <tt>id</tt>: a unique name that will be used to identify this view
+- <tt>name</tt>: a translatable name that will be used in the UI for this view
+- <tt>category</tt>: an optional attribute that is composed of the category IDs separated by '/'. Each referenced category must be declared in a corresponding category element.
+- <tt>class</tt>: a fully qualified name of the class that implements berry::IViewPart. A common practice is to subclass berry::ViewPart or berry::QtViewPart in order to inherit the default functionality.
+- <tt>icon</tt>: a relative name of the icon that will be associated with the view.
+- <tt>fastViewWidthRatio</tt>: the percentage of the width of the workbench that the view will take up as an active fast view. This must be defined as a floating point value and lie between 0.05 and 0.95. If no value is supplied, a default ratio will be used.
+- <tt>allowMultiple</tt>: flag indicating whether this view allows multiple instances to be created using IWorkbenchPage::ShowView(QString id, QString secondaryId). The default is false.
+- <tt>restorable</tt>: flag indicating whether this view allows to be restored upon workbench restart. If set to false, the view will not be open after a workbench restart. The default is true.
+
+\code{.unparsed}
+<!ELEMENT description (#PCDATA)>
+\endcode
+
+An optional subelement whose body should contain text providing a short description of the view.
+
+\code{.unparsed}
+<!ELEMENT stickyView EMPTY>
+<!ATTLIST stickyView
+  id        IDREF #REQUIRED
+  location  (RIGHT|LEFT|TOP|BOTTOM)
+  closeable (true | false)
+  moveable  (true | false)>
+\endcoe
+
+A sticky view is a view that will appear by default across all perspectives in a window once it is opened.
+Its initial placement is governemed by the location attribute, but nothing prevents it from being moved or closed by the user.
+Use of this element will only cause a placeholder for the view to be created, it will not show the view.
+Please note that usage of this element should be done with great care and should only be applied to views that truely have a need to live across perspectives.
+
+- <tt>id</tt>: the id of the view to be made sticky.
+- <tt>location</tt>: optional attribute that specifies the location of the sticky view relative to the editor area. If absent, the view will be docked to the right of the editor area.
+- <tt>closeable</tt>: optional attribute that specifies wether the view should be closeable. If absent it will be closeable.
+- <tt>moveable</tt>: optional attribute that specifies wether the view should be moveable. If absent it will be moveable.
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Views_Examples Examples
+
+The following is an example of the extension point:
+
+\code{.unparsed}
+<extension point="org.blueberry.ui.views">
+  <category
+    id="com.xyz.views.XYZviews"
+    name="XYZ"/>
+  <view
+    id="com.xyz.views.XYZView"
+    name="XYZ View"
+    category="com.xyz.views.XYZviews"
+    class="ns::XYZView"
+    icon="icons/XYZ.gif"/>
+</extension>
+\endcode
+
+The following is an example of a sticky view declaration:
+
+\code{.unparsed}
+<extension point="org.blueberry.ui.views">
+  <stickyView id="com.xyz.views.XYZView" />
+</extension>
+\endcode
+
+\subsubsection BlueBerryExtPointsIndex_Workbench_Views_SupplImpl Supplied Implementation
+
+The BlueBerry Platform provides a number of standard views.
+From the user point of view, these views are no different from any other view provided by the plug-ins.
+All the views can be shown from the "Show View" submenu of the "Window" menu.
+The position of a view is persistent: it is saved when the view is closed and restored when the view is reopened in a single session.
+The position is also persisted between workbench sessions.
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Application/ExtensionPointReference.dox b/Documentation/Doxygen/3-DeveloperManual/Application/ExtensionPointReference.dox
index eb658dd2a1..e681bbce1b 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Application/ExtensionPointReference.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Application/ExtensionPointReference.dox
@@ -1,21 +1,62 @@
 /**
 
 \page mitkExtPointsIndex MITK Extension-Point Reference
 
-<center>
-  <h1>MITK Extension Points</h1>
-</center>
+\tableofcontents
 
-The following extension points can be used to extend the capabilities
-of MITK Plugins:
+\section mitkExtPointsIndex_InputDevices Input Devices
 
+\subsection mitkExtPointsIndex_InputDevices_Identifier Identifier
 
-<h3>Input Devices</h3>
-<ul>
-<li>\subpage xp_org_mitk_core_ext_inputdevices
-</ul>
+\c org.mitk.core.ext.inputdevices
 
-\page xp_org_mitk_core_ext_inputdevices org.mitk.core.ext.inputdevices
-\htmlinclude org_mitk_core_ext_inputdevices.html
+\subsection mitkExtPointsIndex_InputDevices_Description Description
+
+This extension point is used to define additional input devices.
+
+\subsection mitkExtPointsIndex_InputDevices_ConfigurationMarkup Configuration Markup
+
+\code{.unparsed}
+<!ELEMENT extension (inputdevice*)>
+<!ATTLIST extension
+  point CDATA #REQUIRED
+  id    CDATA #IMPLIED
+  name  CDATA #IMPLIED>
+\endcode
+
+- <tt>point</tt>: a fully qualified identifier of the target extension point
+- <tt>id</tt>: an optional identifier of the extension instance
+- <tt>name</tt>: an optional name of the extension instance
+
+\code{.unparsed}
+<!ELEMENT inputdevice (description?)>
+<!ATTLIST inputdevice
+  id    CDATA #REQUIRED
+  name  CDATA #IMPLIED
+  class CDATA #REQUIRED>
+\endcode
+
+- <tt>id</tt>: the identifier of the input device
+- <tt>name</tt>: an optional name of the input device
+- <tt>class</tt>: a fully qualified name of the class that implements mitk::IInputDevice.
+
+\code{.unparsed}
+<!ELEMENT description (#PCDATA)>
+\endcode
+
+An optional subelement whose body should contain text providing a short description of the input device.
+
+\subsection mitkExtPointsIndex_InputDevices_Examples Examples
+
+\code{.unparsed}
+<extension point="org.mitk.core.ext.inputdevices">
+  <inputdevice
+    id="com.xyz.inputdevice.XYZDevice"
+    name="XYZ Device"
+    class="ns::XYZDevice">
+    <description>My new 20-dimensional input device</description>
+  </inputdevice>
+</extension>
+\endcode
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/GeometryOverview.dox b/Documentation/Doxygen/3-DeveloperManual/Concepts/GeometryOverview.dox
index 9d1afa71e2..f7bbcb984b 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Concepts/GeometryOverview.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Concepts/GeometryOverview.dox
@@ -1,131 +1,160 @@
-namespace mitk{
 /**
 \page GeometryOverviewPage Geometry Overview
 
 \tableofcontents
 
 \section GeometryOverviewPage_Introduction Introduction to Geometries
 
-Geometries are used to describe the geometrical properties of data objects in space and time.\n
-To use the geometry classes in the right way you have to understand the three different coordinate types present in MITK:\n\n
+Geometries are used to describe the geometrical properties of data objects in space and time.
+To use the geometry classes in the right way you have to understand the three different coordinate types present in MITK:
+
 \imageMacro{CoordinateTypes.png,"",16}
-<center><b>The different coordinate types\n\n</b></center>\n
-  -# World coordinates:
-    - World coordinates are describing the actual spacial position of all MITK objects regarding a global coordinate system, normally specified by the imaging modality
-    - World coordinates are represented by  mitk::Point3D objects.
-    - The geometry defines the offset, orientation, and scale of the considered data objects in reference to the world coordinate systems.
-    - World coordinates are always measured in mm
-    - If you are dealing with an image geometry, the origin of an image is pointing to the CENTER of the bottom-left-back voxel.\n
-    - If you are NOT dealing with an image geometry (no defined discrete Voxels), the origin is pointing to the bottom-left-back CORNER
-    - Index coordinates can be converted to world coordinates by calling BaseGeometry::IndexToWorld()\n\n
+
+\section GeometryOverviewPage_CoordTypes The different coordinate types
+
+\subsection GeometryOverviewPage_WorldCoord
+
+- World coordinates are describing the actual spacial position of all MITK objects regarding a global coordinate system, normally specified by the imaging modality
+- World coordinates are represented by  mitk::Point3D objects.
+- The geometry defines the offset, orientation, and scale of the considered data objects in reference to the world coordinate systems.
+- World coordinates are always measured in mm
+- If you are dealing with an image geometry, the origin of an image is pointing to the CENTER of the bottom-left-back voxel.
+- If you are NOT dealing with an image geometry (no defined discrete Voxels), the origin is pointing to the bottom-left-back CORNER
+- Index coordinates can be converted to world coordinates by calling mitk::BaseGeometry::IndexToWorld()
 
 \imageMacro{worldcoordinateSystem.png,"",12}
-<center><b>Corner-based coordinates\n\n</b></center>
+
+\subsection GeometryOverviewPage_CornerCoord Corner-based coordinates
+
 \imageMacro{WorldcoordinateSystemCenterBased.png,"",12}
-<center><b>Center-based image-coordinates\n\n</b></center>\n
-  -# Continuous index coordinates:
-    - Dividing world coordinates through the pixel spacing and simultanously taking the offset into account leads to continuous index coordinates inside your dataobject.\n
-      So continuous coordinates can be float values!
-    - Continuous index coordinates are represented by  mitk::Point3D objects.
-    - They can be obtained by calling BaseGeometry::WorldToIndex(), where &pt_mm is a point in worldcoordinates.\n
-  -# Index coordinate system:
-    - Index coordinates are discrete values that address voxels of a data object explicitly.
-    - Index coordinates are represented by  itk::Index<3> objects.
-    - Basically they are continuous index coordinates which are rounded from half integer up.
-    - E.g. (0,0) specifies the very first pixel of a 2D image, (0,1) the pixel of the next column in the same row
-    - If you have world coordinates, they can be converted to discrete index coordinates by calling
-          BaseGeometry::WorldToIndex()\n\n
+
+\subsection GeometryOverviewPage_CenterCoord Center-based image-coordinates
+
+\subsubsection GeometryOverviewPage_CenterCoord_ContIdx Continuous index coordinates
+
+- Dividing world coordinates through the pixel spacing and simultanously taking the offset into account leads to continuous index coordinates inside your dataobject. So continuous coordinates can be float values!
+- Continuous index coordinates are represented by  mitk::Point3D objects.
+- They can be obtained by calling mitk::BaseGeometry::WorldToIndex(), where &pt_mm is a point in worldcoordinates.\n
+
+\subsubsection GeometryOverviewPage_CenterCoord_Idx Index coordinate system
+
+- Index coordinates are discrete values that address voxels of a data object explicitly.
+- Index coordinates are represented by  itk::Index<3> objects.
+- Basically they are continuous index coordinates which are rounded from half integer up.
+- E.g. (0,0) specifies the very first pixel of a 2D image, (0,1) the pixel of the next column in the same row
+- If you have world coordinates, they can be converted to discrete index coordinates by calling mitk::BaseGeometry::WorldToIndex()\n\n
 
 \section GeometryOverviewPage_PointsAndVector Difference between Points and Vectors
 
-Like ITK, MITK differenciate between points and vectors. A point defines a position in a coordinate system while a
-vector is the distance between two points. Therefore points and vectors behave different if a coordinate transformation
-is applied. An offest in a coordinate transformation will affect a transformed point but not a vector.
+Like ITK, MITK differenciate between points and vectors.
+A point defines a position in a coordinate system while a vector is the distance between two points.
+Therefore points and vectors behave different if a coordinate transformation is applied.
+An offest in a coordinate transformation will affect a transformed point but not a vector.
+
+An Example:
 
-An Example:\n
 If two systems are given, which differ by a offset of (1,0,0). The point A(2,2,2) in system one will correspont to point A'(3,2,2) in the second system.
 But a vector a(2,2,2) will correspond to the vector a'(2,2,2).
 
-
 \section GeometryOverviewPage_Concept The Geometry Concept
 
-As the superclass of all MITK geometries BaseGeometry holds:
-  - a spacial bounding box which is axes-parallel in index coordinates (often discrete indices of pixels), to be accessed by BaseGeometry::GetBoundingBox()
-  - a time related bounding box which holds the temporal validity of the considered data object in milliseconds (start and end time), to be accessed by BaseGeometry::GetTimeBounds().\n
-    The default for 3D geometries is minus infinity to plus infinity, meaning the object is always displayed independent of displayed time in MITK.
-  - position information in form of a Euclidean transform in respect to world coordinates (i.e. a linear transformation matrix and offset) to convert (discrete or continuous) index coordinates to world coordinates and vice versa,\n
-       to be accessed by BaseGeometry::GetIndexToWorldTransform()\n
-     See also: \ref GeometryOverviewPage_Introduction "Introduction to Geometries"
-  - Many other properties (e.g. origin, extent, ...) which can be found in the \ref BaseGeometry "class documentation"
-  - <b> VERY IMPORTANT:</b>\n A flag called <i>isImageGeometry</i>, which indicates whether the coordinates are center-based or not!\n
-    See also: \ref GeometryOverviewPage_Introduction "Introduction to Geometries" and \ref GeometryOverviewPage_Putting_Together "IMPORTANT: Putting it together for an Image"\n\n
+As the superclass of all MITK geometries mitk::BaseGeometry holds:
 
+- a spacial bounding box which is axes-parallel in index coordinates (often discrete indices of pixels), to be accessed by BaseGeometry::GetBoundingBox()
+- a time related bounding box which holds the temporal validity of the considered data object in milliseconds (start and end time), to be accessed by BaseGeometry::GetTimeBounds(). The default for 3D geometries is minus infinity to plus infinity, meaning the object is always displayed independent of displayed time in MITK.
+- position information in form of a Euclidean transform in respect to world coordinates (i.e. a linear transformation matrix and offset) to convert (discrete or continuous) index coordinates to world coordinates and vice versa, to be accessed by mitk::BaseGeometry::GetIndexToWorldTransform(). See also: \ref GeometryOverviewPage_Introduction "Introduction to Geometries"
+- Many other properties (e.g. origin, extent, ...) which can be found in the mitk::BaseGeometry "class documentation"
+- <b>VERY IMPORTANT:</b> A flag called \c isImageGeometry, which indicates whether the coordinates are center-based or not! See also: \ref GeometryOverviewPage_Introduction "Introduction to Geometries" and \ref GeometryOverviewPage_Putting_Together . <b>IMPORTANT:</b> Putting it together for an Image.
 
-Every data object (sub-)class of BaseData has a TimeGeometry which is accessed by BaseData::GetTimeGeometry(). This TimeGeometry holds one or more BaseGeometry objects which describes the object at specific time points, e.g. provides conversion between world and index coordinates and contains bounding boxes covering the area in which the data are placed. There is the possibility of using different implementations of the abstract TimeGeometry class which may differ in how the time steps are saved and the times are calculated.
+Every data object (sub-)class of BaseData has a mitk::TimeGeometry which is accessed by mitk::BaseData::GetTimeGeometry().
+This mitk::TimeGeometry holds one or more mitk::BaseGeometry objects which describes the object at specific time points, e.g. provides conversion between world and index coordinates and contains bounding boxes covering the area in which the data are placed.
+There is the possibility of using different implementations of the abstract mitk::TimeGeometry class which may differ in how the time steps are saved and the times are calculated.
 
-There are two ways to represent a time, either by a TimePointType or a TimeStepType. The first is similar to the continous index coordinates and defines a Time Point in milliseconds from timepoint zero. The second type is similar to index coordinates. These are discrete values which specify the number of the current time step going from 0 to GetNumberOfTimeSteps(). The conversion between a time point and a time step is done by calling the method TimeGeometry::TimeStepToTimePoint() or TimeGeometry::TimePointToTimeStep(). Note that the duration of a time step may differ from object to object, so in general it is better to calculate the corresponding time steps by using time points. Also the distance of the time steps does not need to be equidistant over time, it depends on the used TimeGeometry implementation.
+There are two ways to represent a time, either by a mitk::TimePointType or a mitk::TimeStepType.
+The first is similar to the continous index coordinates and defines a Time Point in milliseconds from timepoint zero.
+The second type is similar to index coordinates.
+These are discrete values which specify the number of the current time step going from 0 to GetNumberOfTimeSteps().
+The conversion between a time point and a time step is done by calling the method mitk::TimeGeometry::TimeStepToTimePoint() or mitk::TimeGeometry::TimePointToTimeStep().
+Note that the duration of a time step may differ from object to object, so in general it is better to calculate the corresponding time steps by using time points.
+Also the distance of the time steps does not need to be equidistant over time, it depends on the used mitk::TimeGeometry implementation.
 
-Each TimeGeometry has a bounding box covering the whole area in which the corresponding object is situated during all time steps. This bounding box may be accessed by calling TimeGeometry::GetBoundingBoxInWorld() and is always in world coordinates. The bounding box is calculated from all time steps, to manually start this calculation process call TimeGeometry::Update().  The bounding box is not updated if the getter is called.
+Each mitk::TimeGeometry has a bounding box covering the whole area in which the corresponding object is situated during all time steps.
+This bounding box may be accessed by calling mitk::TimeGeometry::GetBoundingBoxInWorld() and is always in world coordinates.
+The bounding box is calculated from all time steps, to manually start this calculation process call mitk::TimeGeometry::Update().
+The bounding box is not updated if the getter is called.
 
-The TimeGeometry does not provide a transformation of world coordinates into image coordinates since each time step may has a different transformation. If a conversion between image and world is needed, the BaseGeometry for a specific time step or time point must be fetched either by TimeGeometry::GetGeometryForTimeStep() or TimeGeometry::GetGeometryForTimePoint() and then the conversion is calculated by using this geometry.
+The mitk::TimeGeometry does not provide a transformation of world coordinates into image coordinates since each time step may has a different transformation.
+If a conversion between image and world is needed, the mitk::BaseGeometry for a specific time step or time point must be fetched either by mitk::TimeGeometry::GetGeometryForTimeStep() or mitk::TimeGeometry::GetGeometryForTimePoint() and then the conversion is calculated by using this geometry.
 
-The TimeGeometry class is an abstract class therefore it is not possible to instantiate it. Instead a derived class must be used. Currently the only class that can be chosen is ProportionalTimeGeometry() which assumes that the time steps are ordered equidistant. To initialize an object with given geometries call ProportionalTimeGeometry::Initialize() with an existing BaseGeometry and the number of time steps. The given geometries will be copied and not referenced!
+The mitk::TimeGeometry class is an abstract class therefore it is not possible to instantiate it.
+Instead a derived class must be used.
+Currently the only class that can be chosen is mitk::ProportionalTimeGeometry which assumes that the time steps are ordered equidistant.
+To initialize an object with given geometries call mitk::ProportionalTimeGeometry::Initialize() with an existing BaseGeometry and the number of time steps.
+The given geometries will be copied and not referenced!
 
-Also, the BaseGeometry is an abstract class and derived classes must be used. The most simple implementation, i.e. the one to one implementation of the BaseGeometry class, is the class Geometry3D.
+Also, the mitk::BaseGeometry is an abstract class and derived classes must be used.
+The most simple implementation, i.e. the one to one implementation of the BaseGeometry class, is the class mitk::Geometry3D.
 
-SlicedGeometry3D is a sub-class of BaseGeometry, which describes data objects consisting of slices, e.g., objects of type Image (or SlicedData, which is the super-class of Image).
-Therefore, Image::GetTimeGeometry() will contain a list of SlicedGeometry3D instances. There is a special method SlicedData::GetSlicedGeometry(t) which directly returns\n
-a SlicedGeometry3D to avoid the need of casting.
+mitk::SlicedGeometry3D is a sub-class of mitk::BaseGeometry, which describes data objects consisting of slices, e.g., objects of type Image (or mitk::SlicedData, which is the super-class of mitk::Image).
+Therefore, mitk::Image::GetTimeGeometry() will contain a list of mitk::SlicedGeometry3D instances. There is a special method mitk::SlicedData::GetSlicedGeometry(t) which directly returns a mitk::SlicedGeometry3D to avoid the need of casting.
 
-The class SlicedGeometry3D contains a list of PlaneGeometry objects describing the slices in the image.We have here spatial steps from 0 to GetSlices().
-SlicedGeometry3D::InitializeEvenlySpaced (PlaneGeometry *planeGeometry, unsigned int slices) initializes a stack of slices with the same thickness, one starting at the position where the previous one ends.
+The class mitk::SlicedGeometry3D contains a list of mitk::PlaneGeometry objects describing the slices in the image.
+We have here spatial steps from 0 to GetSlices().
+mitk::SlicedGeometry3D::InitializeEvenlySpaced(PlaneGeometry *planeGeometry, unsigned int slices) initializes a stack of slices with the same thickness, one starting at the position where the previous one ends.
 
-PlaneGeometry provides methods for working with 2D manifolds (i.e., simply spoken, an object that can be described using a 2D coordinate-system) in 3D space.\n
-For example it allows mapping of a 3D point on the 2D manifold using PlaneGeometry::Map(). \n
+mitk::PlaneGeometry provides methods for working with 2D manifolds (i.e., simply spoken, an object that can be described using a 2D coordinate-system) in 3D space.
+For example it allows mapping of a 3D point on the 2D manifold using mitk::PlaneGeometry::Map().
 
-Finally there is the AbstractTransformGeometry which describes a 2D manifold in 3D space, defined by a vtkAbstractTransform. It is a abstract superclass for arbitrary user defined geometries.\n
-An example is the ThinPlateSplineCurvedGeometry.\n
+Finally there is the mitk::AbstractTransformGeometry which describes a 2D manifold in 3D space, defined by a vtkAbstractTransform. It is a abstract superclass for arbitrary user defined geometries.
+An example is the mitk::ThinPlateSplineCurvedGeometry.
 
-\subsection GeometryOverviewPage_Putting_Together IMPORTANT: Putting it together for an Image
+\subsection GeometryOverviewPage_Putting_Together Putting it together for an Image
 
-Please read this section accurately if you are working with Images!
+Please read this section carefully if you are working with Images!
 
 The definition of the position of the corners of an image is different than the one of other data objects:
 
-As mentioned in the previous section, world coordinates of data objects (e.g. surfaces ) usually specify the bottom left back corner of an object.
+As mentioned in the previous section, world coordinates of data objects (e.g. surfaces) usually specify the bottom left back corner of an object.
 
-In contrast to that a geometry of an Image is center-based, which means that the world coordinates of a voxel belonging to an image points to the center of that voxel.
+In contrast to that, a geometry of an mitk::Image is center-based, which means that the world coordinates of a voxel belonging to an image points to the center of that voxel.
 E.g:
 
 \imageMacro{PixelCenterBased.png,"",6}
-<center><b>Center-based voxel\n\n</b></center>
+
+\subsection GeometryOverviewPage_CenterBasedVoxel Center-based voxel
 
 If the origin of e.g. a surface lies at (15,10,0) in world coordinates, the origin`s world coordinates for an image are internally calculated like the following:
 
-                    <center>(15-0.5*X-Spacing\n
-                     10-0.5*Y-Spacing\n
-                       0-0.5*Z-Spacing)\n</center>
+\code{.unparsed}
+(15-0.5*X-Spacing
+ 10-0.5*Y-Spacing
+  0-0.5*Z-Spacing)
+\endcode
 
 If the image`s spacing is (x,y,z)=(1,1,3) then the corner coordinates are (14.5,9.5,-1.5).
 
-<b>If your geometry describes an image, the member variable <i>isImageGeometry</i> must be changed to true. This variable indicates also if your geometry is center-based or not.\n
-The change can be done in two ways:\n
-  -#  You are sure that your origin is already center-based. Whether because you adjusted it manually or you copied it from another image.\n
-      In that case, you can call the function <i>setImageGeometry(true)</i> or <i>imageGeometryOn()</i> to set the bool variable to true.
-   -#  You created a new geometry, did not manually adjust the origin to be center-based and have the bool value isImageGeometry set to false (default).\n
-       In that case, call the function  <i>ChangeImageGeometryConsideringOriginOffset(true)</i>. It will adjust your origin automatically and set the bool flag to true.\n
+If your geometry describes an image, the member variable \c isImageGeometry must be changed to true.
+This variable indicates also if your geometry is center-based or not.
+
+The change can be done in two ways:
+- You are sure that your origin is already center-based. Whether because you adjusted it manually or you copied it from another image. In that case, you can call the function \c setImageGeometry(true) or \c imageGeometryOn() to set the bool variable to true.
+- You created a new geometry, did not manually adjust the origin to be center-based and have the bool value \c isImageGeometry set to false (default). In that case, call the function \c ChangeImageGeometryConsideringOriginOffset(true) . It will adjust your origin automatically and set the bool flag to true.
 
-If you experience displaced contours, figures or other stuff, it is an indicator that you have not considered the origin offset mentioned above.</b>\n\n
+If you experience displaced contours, figures or other stuff, it is an indicator that you have not considered the origin offset mentioned above.
 
-An image has a TimeGeometry, which contains one or more SlicedGeometry3D instances (one for each time step), all of which contain one or more instances of (sub-classes of) PlaneGeometry.\n
-As a reminder: Geometry instances referring to images need a slightly different definition of corners, see BaseGeometry::SetImageGeometry. This is usualy automatically called by Image.\n\n
+An image has a mitk::TimeGeometry, which contains one or more mitk::SlicedGeometry3D instances (one for each time step), all of which contain one or more instances of (sub-classes of) mitk::PlaneGeometry.
+
+As a reminder: Geometry instances referring to images need a slightly different definition of corners, see mitk::BaseGeometry::SetImageGeometry.
+This is usualy automatically called by Image.
 
 \section GeometryOverviewPage_Connection Connection between MITK, ITK and VTK Geometries
+
 \imageMacro{ITK_VTK_MITK_Geometries.png,"",10}
-\n\n
-  - VTK transformation for rendering
-  - ITK transformation for calculations
-  - Both automatically updated when one is changed\n
-Attention:<b>Not</b> automatically updated when changed hardcoded. Example: geometry->GetVtkMatrix()->Rotate(....)
+
+- VTK transformation for rendering
+- ITK transformation for calculations
+- Both automatically updated when one is changed
+
+Attention: <b>Not</b> automatically updated when changed hardcoded. Example: \c geometry->GetVtkMatrix()->Rotate(...)
+
 */
-}
diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/Modularization.dox b/Documentation/Doxygen/3-DeveloperManual/Concepts/Modularization.dox
index 58d0f02c4e..32fd931e28 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Concepts/Modularization.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Concepts/Modularization.dox
@@ -1,44 +1,44 @@
 /**
 
 \page ModularizationPage Modular MITK
 
 MITK has been designed to be modular and flexible, to facilitate reuse of existing code and functionality if possible. As such there are several levels of modularization which can be chosen when working with MITK, depending on the use case.
 
 \section ModularizationPageOverview Overview
 
 The general hierarchy of modularization runs micro service, module, view, plug-in, perspective and finally application.
 
 \subsection ModularizationPageMicroServices Micro Services
 
 A \ref MicroServices_Overview "micro service" is a reusable component provided by MITK modules. It can be accessed by other MITK modules or MITK plug-ins via its declared interface.
 
 \subsection ModularizationPageModules Modules
 
 Modules can be found in the MITK/Modules directory (with the exception of the core module in MITK/Core). Each module is a shared library that provides algorithms, data structures and similar code. Many modules are gui independent. A module is only build if it is required by other code, e.g. if a plug-ins is activated that requires it.
 
 \subsection ModularizationPageViews Views
 
-One of the smallest units in the MITK application framework (\ref FurtherReading "Blueberry") is a \e view. A view is always part of a plug-in and provides one specific function, such as grouping all gui elements needed for providing segmentation algorithms or loading dicom images. Views usually contain any code which communicates with the user, performs input checking and similar, but no advanced algorithms.
+One of the smallest units in the MITK application framework is a \e view. A view is always part of a plug-in and provides one specific function, such as grouping all gui elements needed for providing segmentation algorithms or loading dicom images. Views usually contain any code which communicates with the user, performs input checking and similar, but no advanced algorithms.
 
 \subsection ModularizationPagePlugInBundles Plugins
 
 The next smallest unit is a CTK Plug-in (the term \e Bundle is used interchangeably). They can be found in MITK/Plugins or MITK/BlueBerry/Bundles. Plugins can be individually switched on and off during the CMake configuration.
 
 A plugin usually represents a solution to a specific problem, such as segmentation or data management. As such they may provide any number of views and other contributions to the MITK application framework.
 
 If you want to create your own MITK plugin you find further information \ref NewPluginPage "here".
 
 \subsection ModularizationPagePerspectives Perspectives
 
 Perspectives represent a configuration for the MITK application framework (specifically, for the \e Workbench) needed for a specific workflow. They allow the arrangement of different views (contributed by different plug-ins) to reflect the usage scenario, such as a data loading view in the top right, a segmentation view to the right and a visualization view to the bottom right. A perspective is provided by arbitrary plug-ins as an extension (contribution) to the application framework.
 
 \subsection ModularizationPageApplications Applications
 
 A specific selection of plug-ins together with custom configuration data defines the functionality for an application. The application corresponds to an executable and enables very specific program behaviour and configuration.
 
 Example applications can be found in the MITK/Applications directory.
 
 \section ModularizationPageHowTo How to create your own application
 
 It is suggested to use the project generator provided by MITK unless one knows what one is doing. See \ref NewPluginWithProject "here" for more information.
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Concepts/TestsGeneral.dox b/Documentation/Doxygen/3-DeveloperManual/Concepts/TestsGeneral.dox
index e1481463fb..0c3174a87d 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Concepts/TestsGeneral.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Concepts/TestsGeneral.dox
@@ -1,104 +1,104 @@
 /**
 \page GeneralTests General: Tests in MITK
 
 \tableofcontents
 
 \section GeneralTestsIntroduction Testing in MITK
 
 The basic idea about unit testing is to write a test for every unit (e.g. function) of your software, which automatically checks if the code still returns the expected result for a defined input. The goal is to isolate units as much as possible, in order to be efficient with fixing errors.
 
 If this is performed on a low level, this is called unit testing. On higher levels, where various circumstances (such as configuration files, internet connection, hardware, or even input/output) may influence the outcome of the test, this is called integration testing.
 
 MITK uses CppUnit, which is a framework for efficient and fast test writing, to support developers in test coding. Furthermore MITK offers currently three types of tests: classic <B>unit tests</B>, <B>rendering tests</B> and <B>interaction tests</B>. Although our unit tests often involve data input (or output), we still consider them to be unit tests.
 
 \warning Most of our units tests have been written before adopting CppUnit and have not yet been updated. Therefore we do not recommend to look at a random test for an example of coding a test.
 
 This pages gives a general introduction to our test framework. Rendering tests are explained in more detail in the section \ref RenderingTests and interaction tests the section \ref InteractionTestingHowTo. The following sections will explain how to write your own tests with MITK and how to run them.
 
 \section GeneralTestsAdding Adding a test to your module
 
 Generally, functional code you want to test using unit tests will be located in a module. For an overview of the directory structure see \ref NewModulePageCreateFolder and how to add the files comprising your test compare \ref NewModulePageCreateTestingEnvironment
 
 \subsection GeneralTestsAddingFramework Test and test class/suite
 
 CppUnit and MITK distinguish between the term test class and test, which is important to understand. A test is simply a call of a single function and a comparison against a reference.
 
 The ideal way to write a test is:
 \code
         result = myGreatFunction(myParameter);
         ASSERT_EQUAL(result, reference);
 \endcode
 
 which is just 2 lines of code at the best. Sometimes objects and data may be initialized in a test, but usually this should be done in the setUp() method (see below). If possible, avoid multiple assertions in order to be efficient in error localization and for better readability. For instance, if you instantiate an object and test if its data is not NULL, this is already a complete test and you do not want to repeat this comparison in other tests.
 
 All tests check different things and just one at a time. Remember: The goal is to have isolated unit tests and avoid large, confusing tests which are hard to maintain.
 \note The reference should never be computed and ideally be a distinct and well defined (often hard coded) value. You don't care where you reference comes from, you just want to ensure that your test actually results in the reference value.
 
 A test class (also called suite) is a set of tests and often associated to a single functional class in MITK. A test class refers to a TestSuite in CppUnit. These terms are easily confused, so we suggest to use the term <B>test suite</B> for a collection of tests (which is often in a single file), and the term "test" for a single test (usually many per file).
 
 In order to create a test class you need to create a new class deriving from mitk::TestFixture. While a purist approach would be to create a new mitk::TestFixture for each method of your class (resulting in as many test source files as your class has methods), we usually follow a more pragmatic approach within MITK. In most cases we suggest having one test source file per class. If your class source file is called mitkGreatClass.cpp we suggest the name mitkGreatClassTest.cpp for your test source file. For very complex and long classes splitting this into several tests may be advisable. Additionally, rendering tests and interaction tests should always get their own test class/suite to mark them as obvious integration tests, because the goal is to isolate unit tests from integration tests. The dashboard for continuous integration will automatically show the results of a test suite and summarize the output. If you run your test manually (e.g. with ctest -VV), you will see the detailed output of all tests of the suite.
 
 In order to use CppUnit via MITK you will need to include the corresponding files and register your test:
 \code
   #include <mitkTestingMacros.h>
   #include <mitkTestFixture.h>
   …
   MITK_TEST_SUITE_REGISTRATION(mitkImageEqual)
 \endcode
 
 \subsection GeneralTestsAddingHow How to structure your test
 
-As mentioned before, all test suites derive from mitk::TestFixture. A suggested name for your test suite would be <FUNCTIONALITY_TO_BE_TESTED>TestSuite.
+As mentioned before, all test suites derive from mitk::TestFixture. A suggested name for your test suite would be \c \<FUNCTIONALITY_TO_BE_TESTED\>TestSuite .
 
-You then create a suite and register your tests. A suggested naming convention for test methods is <METHOD_TO_BE_TESTED>_<INPUT_PARAMETERS/CONDITION>_<EXPECTED_RESULT>. We suggest not to add the word test, because that is most likely the only thing the reader knows anyway about your test, as he is reading a test suite.
+You then create a suite and register your tests. A suggested naming convention for test methods is \c \<METHOD_TO_BE_TESTED\>_\<INPUT_PARAMETERS/CONDITION\>_\<EXPECTED_RESULT\> . We suggest not to add the word test, because that is most likely the only thing the reader knows anyway about your test, as he is reading a test suite.
 
 An example:
 \code
   class mitkImageEqualTestSuite : public mitk::TestFixture
   {
     CPPUNIT_TEST_SUITE(mitkImageEqualTestSuite);
     MITK_TEST(Equal_CloneAndOriginal_ReturnsTrue);
     MITK_TEST(Equal_InputIsNull_ReturnsFalse);
     MITK_TEST(Equal_DifferentImageGeometry_ReturnsFalse);
     MITK_TEST(Equal_DifferentPixelTypes_ReturnsFalse);
     …
     CPPUNIT_TEST_SUITE_END();
     …
   }
 \endcode
 
 You also may provide a setUp() and a tearDown() function. These will be called before/after each test and should be used to make sure that each test works independently and on freshly initialized members and memory to maximize isolation. That way you avoid only testing whether a function works after another function has already been called. See <a href="http://cppunit.sourceforge.net/doc/cvs/class_test_fixture.html">CppUnit documentation</a> for more information. For an example test suite including tests see \ref GeneralTestsExample
 
 \section GeneralTestsRunning Running your test suite
 
 The build system of MITK generates a test driver which includes all test suites that have been added to the project. Alternatively you can run MITK test suites by using the program ctest. This is the way all MITK tests run on the continuous dart clients of MITK. The results of these runs can be found at http://cdash.mitk.org.
 
 If you use the test driver, you only need to start the executable. If you start it without parameters, it will then give you an overview of all tests which are included in this test driver and you can choose one by typing a number. Alternatively, you can give your test driver the name of your test suite as parameter. If you want to use ctest instead of the test driver you need to start a command line, go to the binary directory of MITK and call ctest. To avoid errors, check if your path variable contains all relevant paths to start MITK.
 
 \section GeneralTestsParameterInput Adding parameters to your test
 
 If possible, the setUp() method of the test suite should provide all necessary inputs for the respective tests. MITK provides several helper classes to generate synthetic test data, such as the mitk::ImageGenerator. If you have to load data from the hard disc for your test, you can use the method GetTestDataFilePath(string fileName). For an example of loading data from the MITK_DATA_DIR check the mitkIOUtilTestSuite.
 
 \section GeneralTestsPredefinedAssertions Predefined assertions
 
 MITK and CppUnit offer predefined assertions, i.e. helper methods which will help to compare your data against a certain reference. All basic types are covered by CppUnit assertions, such as CPPUNIT_ASSERT. For examples, please check the <a href="http://cppunit.sourceforge.net/doc/cvs/group___assertions.htmll">CppUnit documentation</a>. MITK further offers comparison tools for floating point numbers, vectors, images, surfaces and point sets. A complete list of assertion macros is given in \ref MITKTestingAPI.
 
 An example to compare images:
 \code
         MITK_ASSERT_EQUAL(image, reference, "Checks if image is equal to a reference");
 \endcode
 
 By default, the method uses an mitk::eps for floating point comparison, but this can be adapted. It can be necessary to write your own assertion for your own data meeting your special requirements. Recommended examples are all equal test suites for basic data types (mitkImageEqualTest, mitkSurfaceEqualTest and mitkPointSetEqualTest).
 
 \section GeneralTestsExample An example
 
 \include Examples/FirstSteps/NewModule/test/mitkExampleDataStructureTest.cpp
 
 \section GeneralTestsFurtherInfo Further information
 
 More examples can be found in the corresponding <a href="http://www.mitk.org/images/5/5d/BugSquashingSeminars%24CppUnitFrameworkSeminar.pdf"> bugsquashing presentation</a>.
 */
 
 \section GeneralTestsDeprecatedOldTestingStyle Deprecated macros
 
 All tests with MITK_TEST_BEGIN(); and MITK_TEST_END(); use the deprecated old MITK testing style. If possible, they should be replaced with the new CppUnit style as explained before. Most of these test classes contain very unfortunate examples and should not be regarded as reference.
diff --git a/Documentation/Doxygen/3-DeveloperManual/DeveloperManualPortal.dox b/Documentation/Doxygen/3-DeveloperManual/DeveloperManualPortal.dox
index 425b916c4a..678ce379c8 100644
--- a/Documentation/Doxygen/3-DeveloperManual/DeveloperManualPortal.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/DeveloperManualPortal.dox
@@ -1,33 +1,31 @@
 /**
 \developersguidemainpage{DeveloperManualPortal} Developer Manual
 
 Development with MITK can happen under several conditions. Depending on whether you are using the Toolkit or the entire application, different sections may apply to you.
 In case you are unsure about what you need, please refer to \link Architecture The Architecture of MITK text\endlink.
 An extensive Introduction to MITK is available under \link StartingDevelopment Starting your MITK Development\endlink.
 
 Once you have made yourself familiar with MITK, you should have a look at the \link Concepts Development Concepts\endlink, as MITK implements a lot of high-level functionality.
 Knowing about these concepts will prevent you from reimplementing functionality.
 
 Once you start consuming more specific functionality, the \link MITKModuleManualsListPage Module Manual\endlink will be helpful to understand how a specific plugin works and what functionality it provides.
 
-Finally, generated API-Documentation can be found \link DevelopmentAPI here\endlink.
-
 <ul>
   <li> \subpage StartingDevelopment </li>
   <ul>
     <li> \ref Architecture </li>
     <li> \ref SettingUpMITK </li>
     <li> \ref GettingToKnowMITK </li>
     <li> \ref FirstSteps </li>
     <li> \ref AboutTestingPage </li>
   </ul>
   <li> \subpage Concepts </li>
   <li> \subpage MITKModuleManualsListPage </li>
   <li> \subpage DevelopmentApplication </li>
   <ul>
     <li> \ref mitkExtPointsIndex </li>
   </ul>
   <li> \subpage DeploymentPage </li>
 </ul>
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/CMakeFAQ.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/CMakeFAQ.dox
index 7906c0733e..d6ec7bbcae 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/CMakeFAQ.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/CMakeFAQ.dox
@@ -1,41 +1,41 @@
 /**
 \page CMAKE_FAQ CMake FAQ
 
 \section CMAKE_FAQ_General A general comment
 
 MITK uses %CMake for configuration. If you want to develop either using MITK as a toolkit or by extending the capabilities of the applications provided by us, we recommend using %CMake for your own project too.
 While it might be possible to use MITK in conjunction with other options, such as QMake or setting up your own project manually it will invariably involve a lot of work and probably hacks as well.
 As we do have no experience with this, we will not be able to help you.
 Be prepared to do a lot of tweaking on by yourself.
 
 This guide does not try to give a general introduction to CMake, instead it tries to answer some basic questions that might arise for those new to %CMake, to help you get started on MITK. For a more comprehensive introduction on %CMake see <a href="http://www.cmake.org/cmake/help/cmake_tutorial.html">here</a>.
 
 We will assume in this guide, that the path to your source is /MITK/.
 
 \section CMAKE_FAQ_Question Basic Questions
 
 \subsection CMAKE_FAQ_Question_WhereGetIt Where do I get CMake and what version do I need?
 See \ref BuildInstructions_Prerequisites.
 
 \subsection CMAKE_FAQ_Question_NewPluginNothing I coded a new plugin for the Workbench and nothing happened. Why?
-The correct way to create a new plugin is described in \ref NewPluginOnly. Do note that you need to move the source to the MITK/Plugins directory and you will have to add the plugin to the config file (most likely MITK/Plugins/Plugins.cmake</tt>). After that see \ref CMAKE_FAQ_Question_HowDoIActivatePlugin.
+The correct way to create a new plugin is described in \ref NewPluginOnly. Do note that you need to move the source to the MITK/Plugins directory and you will have to add the plugin to the config file (most likely MITK/Plugins/Plugins.cmake). After that see \ref CMAKE_FAQ_Question_HowDoIActivatePlugin.
 
 \subsection CMAKE_FAQ_Question_HowDoIActivatePlugin I want to use a plugin, how do I activate it?
 <ol>
  <li> Start %CMake
  <li> Configure
  <li> Set the variable MITK_BUILD_\<Your-plugin-id-here\> to TRUE
  <li> Configure again
  <li> Generate
  <li> Start a build using your development environment
 </ol>
 
 \subsection CMAKE_FAQ_Question_HowDoIActivateModule I want to use a module, how do I activate it?
 Modules are build automatically if a plugin that requires them is activated. See \ref CMAKE_FAQ_Question_HowDoIActivatePlugin.
 
 \subsection CMAKE_FAQ_Question_HowOwnToolkits MITK always downloads the toolkits, but I want to use my own.
 This is covered in \ref HowToNewProjectCustomizingMITKConfigure.
 
 \subsection CMAKE_FAQ_Question_HowOwnProjectMITK I want to use an MITK plugin in my own project but I can not find it.
 See \ref HowToNewProjectAddingMITKFunctionality.
 */
\ No newline at end of file
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/DirectoryStructure.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/DirectoryStructure.dox
index 4dda6a0e2b..51c9236973 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/DirectoryStructure.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/DirectoryStructure.dox
@@ -1,70 +1,70 @@
 /**
 \page DirectoryStructurePage Directory Structure
 
 To avoid clutter and ease the administration of the source code the MITK source code is structured into several subdirectories according to their function. This document aims at helping you finding what you want within this structure.
 
 \section DirectoryStructurePageOverview Overview
 
 The top level directories are the following:
 
 \li \ref DirectoryStructurePageApplications
 \li \ref DirectoryStructurePageCMake
 \li \ref DirectoryStructurePageCMakeExternals
 \li \ref DirectoryStructurePageDocumentation
 \li \ref DirectoryStructurePageExamples
 \li \ref DirectoryStructurePageLicenses
 \li \ref DirectoryStructurePageModules
 \li \ref DirectoryStructurePagePlugins
 \li \ref DirectoryStructurePageTemplates
 \li \ref DirectoryStructurePageUtilities
 \li \ref DirectoryStructurePageWrapping
 
 see the corresponding section for more information.
 
 \section DirectoryStructurePageTopLevelDirs The Top Level Directories
 
 \subsection DirectoryStructurePageApplications Applications
 
-This directory contains the different applications. Each application has its own subfolder, including the necessary code, icons and other resources. For more information on applications see \ref ModularizationPageApplications or \ref ApplicationsPageApplications .
+This directory contains the different applications. Each application has its own subfolder, including the necessary code, icons and other resources. For more information on applications see \ref ModularizationPageApplications .
 
 \subsection DirectoryStructurePageCMake CMake
 
 The %CMake directory contains %CMake files, macros and templates for the configuration of MITK as a project.
 
 \subsection DirectoryStructurePageCMakeExternals CMakeExternals
 
 This directory contains %CMake files for the configuration of other projects used by MITK.
 
 \subsection DirectoryStructurePageDocumentation Documentation
 
 The Documentation directory contains doxygen and other documentation as well as tutorials and examples. It includes basic end user manuals for the framework as well as developer documentation which does not depend on any additional modules.
 
 \subsection DirectoryStructurePageExamples Examples
 
 This directory contains example code used by the documentation in the Documentation directory.
 
 \subsection DirectoryStructurePageLicenses Licenses
 
 The Licenses directory contains various licenses used by MITK's dependencies.
 
 \subsection DirectoryStructurePageModules Modules
 
 This directory contains modules, which extend the capabilities of MITK. For the concept behind modules see \ref ModularizationPageModules .
 
 \subsection DirectoryStructurePagePlugins Plugins
 
 This directory contains plugins, which provide specific solutions. For further information see \ref ModularizationPagePlugInBundles .
 
 \subsection DirectoryStructurePageTemplates Templates
 
 This directory contains template files for recurring snippets like the copyright header for all source files.
 
 \subsection DirectoryStructurePageUtilities Utilities
 
 The Utilities directory contains self contained components, which are used by MITK, but not necessarily developed or maintained by the MITK team.
 
 \subsection DirectoryStructurePageWrapping Wrapping
 
 The Wrapping directory contains code necessary for the Python wrapping capabilities of MITK.
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/DocumentationGuide.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/DocumentationGuide.dox
index 6ab7e3e9a8..353ee16c39 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/DocumentationGuide.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/DocumentationGuide.dox
@@ -1,84 +1,84 @@
 /**
 \page DocumentationGuide Writing Documentation
 
 \section DocumentationGuideCodeGeneral General remarks
 
-MITK uses <a href="http://www.stack.nl/~dimitri/doxygen/">Doxygen</a> for the generation of our user manual pages as well as for the generation of the on- and offline reference manuals. So on the technical side many questions can be answered by the <a href="http://www.stack.nl/~dimitri/doxygen/manual.html">doxygen documentation</a>, such as the list of commands or a few basic doxygen tutorials.
+MITK uses <a href="https://www.doxygen.nl/">Doxygen</a> for the generation of our user manual pages as well as for the generation of the on- and offline reference manuals. So on the technical side many questions can be answered by the <a href="https://www.doxygen.nl/manual/index.html">doxygen documentation</a>, such as the list of commands or a few basic doxygen tutorials.
 
 Therefore this document is not primarily intended as a guide to using doxygen, the doxygen manual does a much better job of that, but as a guide to use doxygen in MITK and a collection of helpful hints and advise about pittfalls.
 
 Also, of course you need to have doxygen installed to generate documentation.
 
 \section DocumentationGuideCode Documenting the source code
 
 MITK is a substantial project and encompasses many different source files by many different developers over quite a considerable timeframe. Many of them have written excellent code which can do a lot of things and is very helpful to people who might apply it in wholly unlooked for ways to completely different problems. To facilitate this sharing and reusing of ressources one first and foremost has to know what kind of ressources are already available.
 
 Few people write code in the intention for it to be difficult to be used by others, but unfortunately what might seem a very efficient and easily understandable piece of code to the author might be nigh unreadable for someone else. Very often it does not in fact matter whether the code itself is understandable, as long as it one can get the information what a function is supposed to do. While comments in the source file help a lot to gain this knowledge in can get quite tedious go through every file looking for the right tool.
 
 This is where using doxygen pays off by giving a short comment in the header file a reference manual is automatically generated.
 
 While doxygen support several different manners of documentation, the MITK documentation should keep a uniform documentation style:
 \warning{
 Use <b>only</b> the \verbatim /** ... */ \endverbatim style for documentation.
 }
 
 In dire emergencies you may consider commenting via the /// style, others must <b>never</b> be used.
 
 An example:
 \verbatim
   /** \brief Brief description what the commented part does.
    *
    * More detailed description. This can be as long as you like,
    * whereas the brief description should never be more than one sentence.
    */
 \endverbatim
 
 See \subpage DocumentationExample for an exemplary documentation of a class.
 
 \subsection DocumentationGuideCodeHints Helpful hints:
 <ul>
  <li> Always put comments intended for doxygen in the header files.
 </ul>
 
 \section DocumentationGuideManual Writing user manuals
 
 While the usage of your view/perspective/application might seem obvious and accessible to you, to most people it is not. Writing a good manual is key for this. It is very difficult to write a manual which is too comprehensive, most often if something can be done in a wrong way, somebody will see this as the only one.
 
 For MITK purposes you should put your documentation in BUNDLEPATH/documentation/UserManual/QmitkMyViewName.dox .
 
 Give them a unique name and remember to only use alphanumeric characters and underscores. Identifiers like "org.placeA.x" and "org.placeB.y" look identical to doxygen because it only parses the "org". Use "org_placeA_x" instead.
 
 Regarding images: Doxygen looks for images globally. To avoid confusion, include the plugin name into the image. E.g. "Checkboxes.png" is a bad name while "QmitkIGTTracking_Checkboxes.png" is a good name.
 
 Include images only via the image Macro! This way it is automatically included in the pdf export of the documentation.
 
 \verbatim
   // The Macro hast he following form (note the braces!):
   \imageMacro{imagePath, "Image Description", Image size in cm}
 
   // e.g.:
   \imageMacro{QmitkIGTTracking_Checkboxes.png, "Some beautiful Checkboxes!", 5}
 
   // If you must use commas in the description, escape them!
  \imageMacro{QmitkIGTTracking_Checkboxes.png, "Some beautiful Checkboxes\, you have never seen better ones! ", 5}
 
 \endverbatim
 
 Image size is only used for the pdf export, but images won't be displayed at all if it is missing. Maximum is 16.
 
 The nightly generated HTML documentation and the Qt Help System documentation can contain different content using the isHTML command.
 
 \subsection DocumentationGuideManualHints Helpful hints:
 <ul>
  <li> Do not use fullstops (".") in identifiers, it throws doxygen off
  <li> Think were your page should go in the MITK help page structure and declare it as a subpage accordingly
  <lI> Use the imageMacro instead of the image command
  <li> Use structuring elements, such as sections and subsections
  <li> Use references to allow for fast navigation
  <li> Images, pictures and sketches are great, use them
  <li> Use visual help like remark, paragraph and warning
  <li> BLUEBERRY_USE_QT_HELP should be set to ON
  <li> The plug-in org.blueberry.ui.qt.help should be set to ON
 </ul>
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/StyleGuideAndNotes.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/StyleGuideAndNotes.dox
index f06de7fe39..b8432d91e4 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/StyleGuideAndNotes.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/StyleGuideAndNotes.dox
@@ -1,469 +1,467 @@
 /**
 \page StyleGuideAndNotesPage The MITK Style Guide and Technical Notes
 
 \tableofcontents
 
 The following document is a description of the accepted coding style for the Medical Imaging Interaction Toolkit (MITK). Developers who wish to contribute code to MITK should read and adhere to the standards described here.
 
 
 \section StyleGuideAndNotesPage_NameConventions Naming Conventions
 
 \li Using case change to indicate separate words
 @code
 ImageFilter
 PixelType
 DataStorage
 NodePredicateProperty
 @endcode
 
 \li Underscores are not used e.g. Image_Filer, _Node
 
 \li Variable names should convey the meaning behind the code
 @code
 BoundingBox::Pointer boundingBox = BoundingBox::New();
 @endcode
 
 \li Names are generally spelled out
 @code
 mitk::DataNode* node;
 @endcode
 
 \li Abbreviation are allowable when in common use e.g. ROI for Region of
 Interest
 
 
 \subsection StyleGuideAndNotesPage_NamingClasses Naming Classes
 
 \li Classes are named beginning with a capital letter
 
 \li Classes are named according to the following general rule:
 @code
 class name = <algorithm><input><concept>
 @endcode
 
 \li Examples of concepts  \n
 <b>Accessor</b>: Access and convert between types e.g. NullScalarAccessor \n
 <b>Container</b>: A container of objects such as points or images e.g. VectorContainer \n
 <b>Filter</b>: A class that participates in the data processing pipeline e.g. AddImageFilter \n
 <b>Mapper</b>: Transform data from one form into another e.g. ContourMapper2D \n
 <b>Reader/Writer</b>: A class that reads/writes a single data object e.g. VtkSurfaceReader \n
 
 
 \subsection StyleGuideAndNotesPage_NamingFiles Naming Files
 
 \li MITK classes like @a ExampleClass should be in namespace @a mitk and their corresponding files should be named @a mitkExampleClass.h/.cpp.
 @code
 mitk::DataStorage
 @endcode
 
 \li Qt specific MITK classes like @a QmitkListView should have the prefix Qmitk in their class names and their corresponding files should be named @a QmitkListView.h/.cpp.
 @code
 QmitkDataStorageComboBox
 @endcode
 
 \li Header Files ends with an .h and
 
 \li Implementation Files with an .cpp or .txx for a template class
 
 
 \subsection StyleGuideAndNotesPage_NamingMethodsandFunctions Naming Methods and Functions
 
 \li Functions and methods are named beginning with a capital letter
 
 \li Referring to class methods in code, an explicit this-> pointer should be
 used
 @code
 mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetAll();
 @endcode
 
 
 \subsection StyleGuideAndNotesPage_NamingSignalSlots Naming Signal/Slots Methods and Functions
 
 \li Slots are named according to the following general rule
 @code
 On[variable name who send the signal][signal]();
 @endcode
 
 \li Example
 @code
 connect( loadImagePushButton, SIGNAL( clicked(bool ) ),
 SLOT( OnLoadImagePushButtonClicked( bool ) ) );
 
 void mitk::Image::OnLoadImagePushButtonClicked( bool )
 {
 ... Do something ...
 }
 @endcode
 
 \li Signals are named according to the following general rule
 @code
 Signal[MethodName]();
 @endcode
 
 \li Example
 @code
 emit SignalFinishedSegmentation();
 @endcode
 
 
 \subsection StyleGuideAndNotesPage_NamingClassDataMembers Naming Class Data Members
 
 \li Class data members are prefixed with m_
 @code
 m_Volumes
 m_OffsetTable
 m_ImageMask
 @endcode
 
 \li An exception to this rule, Qt class Data members are not prefixed and begin with a lower-case letter
 @code
 loadImageButton
 closeImageAction
 @endcode
 
 \subsection StyleGuideAndNotesPage_NamingLocalVariables Naming Local Variables
 
 \li Local variables first letter is lower-case
 @code
 offset
 data
 slicesIt
 @endcode
 
 
 \subsection StyleGuideAndNotesPage_NamingQtVariables Naming Qt Variables
 
 \li GUI variables ends with name of used QT tool.
 @code
 QPushButton* loadImagePushButton;
 QAction* closeImageAction;
 QCheckBox* hideImageCheckBox;
 QRadioButton* binaryImageRadioButton;
 @endcode
 
 
 \subsection StyleGuideAndNotesPage_NamingTypedefs Naming Typedefs
 
 \li Typedefs must end in the word Type
 @code
 typedef TPixel PixelType;
 typedef itk::Image< TPixel, VImageDimension > ImageType;
 typedef std::list<mitk::Image::Pointer> ImageListType;
 @endcode
 
 
 \section StyleGuideAndNotesPage_Pointer Pointer
 
 \subsection StyleGuideAndNotesPage_DeclarationofPointers Declaration of Pointers
 
 \li Position of * pointers are connected with the variable
 @code
 int *counter;
 @endcode
 
 \li Analog to references
 @code
 int &counter;
 @endcode
 
 
 \subsection StyleGuideAndNotesPage_SmartPointer SmartPointer
 
 \li SmartPointers must be used for classes that have itk::Object as a base
 class.
 
 \li Assignment of a just created instance to a normal pointer results in a
 crash, since the reference count is decreased immediately to zero and the
 object is destroyed.
 @code
 itk::Object::Pointer object = itk::Object::New();
 @endcode
 
 \li Static declarations are also forbidden and result into an exception when
 the scope of the variable is left, because the destructor is called while the
 reference count is still greater than zero.
 
 \li Note that using smart pointers requires using real (normal) pointers when
 setting input. If you want to return a newly created smart pointer that
 is not also kept within the class (e.g., if you write a Clone method), you
 have to return a smart pointer on output (compare itkMacro.h). If the
 smart pointer is kept within the class, returning a real (normal) pointer
 is sufficient.
 
 \li Testing a SmartPointer against NULL is done with the IsNull() and Is-
 NotNull() methods. A simple ==NULL issues a warning.
 
 
 \section StyleGuideAndNotesPage_Namespace Namespace
 
 \li MITK classes should be in namespace @a mitk
 @code
 mitk::Image::Pointer mitk::ImageGenerator::MakeImage()
 {
 // already in namespace mitk here!
 Image::Pointer image = mitk::Image::New();
 ImageDecorator::Pointer decorator = mitk::ImageDecorator::New();
 d->Decorate( image );
 return image;
 }
 @endcode
 
 \li Constants in MITK for mitk::Operation and mitk::Action are set in
 namespace, so don't forget to add prefix mitk::
 @code
 switch (actionId)
 {
   case mitk::AcMOVESELECTED:
   ....Do something ...
     break;
 
   default:
     break;
 }
 @endcode
 
 
 \section StyleGuideAndNotesPage_CodeLayoutandIndentation Code Layout and Indentation
 
 \subsection StyleGuideAndNotesPage_GeneralLayout General Layout
 
 \li Each line of code should take no more than 120 characters.
 
 \li Use lots of whitespace to separate logical blocks of code, intermixed with
 comments
 
 \li <b>DO NOT USE TABS.</b> The standard indention is <b>2 spaces</b> (see <a href="https://itk.org/Wiki/images/c/c6/ITKStyle.pdf">ITK Style Guide</a>). Configure your
 editor accordingly.
 
 \li DO NOT USE trailing whitespaces
 
 \li Declaration of variables should be one declaration per line
 @code
 int 				sliceNumber;
 char* 				stringName;
 ImageType::Pointer 	image;
 @endcode
 
 
 \subsection StyleGuideAndNotesPage_ClassLayout Class Layout
 
 \li Copyright
 @code
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 @endcode
 
 \li Includes [A .. Z]
 @code
 #include "... .h"
 @endcode
 
 \li Namespace
 @code
 namespace mitk
 {
 @endcode
 DO NOT litter your header with "using namespace;"!
 
 
 \li Class (Template)
 @code
 template <class TType>
 class ClassName : public ImageBase<VImageDimension>
 {
 @endcode
 
 \li Typedefs
 @code
 public:
   ....typedefs....
 @endcode
 
 \li Methods
 @code
 public:
   ....methods....
 protected:
   ....methods....
 private:
   ....methods....
 @endcode
 
 \li QT Signals
 @code
 signals:
   Signal...();
 @endcode
 
 \li QT Slots
 @code
 public slots:
   On...();
 protected slots:
   On...();
 @endcode
 
 \li Data Member
 @code
 private/protected:
   ....class data members....
 };
 }
 #endif
 @endcode
 
 \section StyleGuideAndNotesPage_UseofBraces Use of Braces
 
 \li Used to delimit the scope of an if, for, while, switch.
 
 \li Braces are placed on a line by themselves:
 @code
 for ( unsigned int i = 0; i < 3; ++i )
 {
 ... do something ...
 }
 @endcode
 or
 @code
 if ( condition )
 {
 ... do something ...
 }
 else if ( other condition )
 {
 ... do something ...
 }
 else
 {
 ... do something ...
 }
 @endcode
 
 \li You can choose to use braces on a line with a code block when the block
 consists of a single line:
 @code
 if ( condition ) { foo = 1; }
 else if ( condition2 ) { foo = 3; }
 else { return; }
 @endcode
 or
 @code
 for ( unsigned int i = 0; i < 3; ++i) { x[i] = 0.0; }
 @endcode
 
 
 \section StyleGuideAndNotesPage_IncludeGuards Include Guards
 
-\li #inlcude guard is a particular construct used to avoid the problem of
-double inclusion when dealing with the #include directive.
+\li \#include guard is a particular construct used to avoid the problem of
+double inclusion when dealing with the \#include directive.
 
-\li Naming convention for #inlcude guards is: ClassName_h
+\li Naming convention for \#include guards is: ClassName_h
 
-\li Following example demonstrates a problem that can arise if #include guards
+\li Following example demonstrates a problem that can arise if \#include guards
 are missing: Here, the file child.cpp has indirectly included two copies of the text in the
 header file grandfather.h. This causes a compilation error, since the structure
 type foo is apparently defined twice.
 @code
 grandfather.h  struct foo
                {
                  int m Member;
                };
 
 father.h       #include "grandfather.h"
 
 child.h        #include "grandfather.h"
                #include "father.h"
 @endcode
 
 
-\subsection StyleGuideAndNotesPage_Useofincludeguards Use of #include guards
+\subsection StyleGuideAndNotesPage_Useofincludeguards Use of \#include guards
 \li Here, the first inclusion of grandfather.h causes the macro grandfather h to
 be defined. Then, when child.cpp includes grandfather.h the second time,
-the #ifndef test fails, and the preprocessor skips down to the #endif, thus
+the \#ifndef test fails, and the preprocessor skips down to the \#endif, thus
 avoiding the second definition of struct foo. The program compiles correctly.
 @code
 grandfather.h  #ifndef grandfather h
                #define grandfather h
                struct foo
                {
                  int m Member;
                };
 
 father.h       #include "grandfather.h"
 
 child.h        #include "grandfather.h"
                #include "father.h"
 @endcode
 
 
 \section StyleGuideAndNotesPage_TechnicalNotes Some Technical Notes
 
 \li Use forward declarations in header files wherever possible. Only include those header files in a header file
 that are really necessary. Include the rest in the implementation file.
 
 \li For classes inheriting directly or indirectly from @a itk::LightObject (most of the MITK-classes do so), the
 class definition should include the mitkClassMacro. Additionally, if the class can be instantiated (normally the case,
 if the class is not abstract) and has @em only a constructor without parameters, the constructor should be declared
 protected and the @a itkFactorylessNewMacro should be used to create a @a New() method for instantiation. Here is an example:
 @code
 class ExampleClass : public SuperClassOfTheExampleClass
 {
 public:
     mitkClassMacro(ExampleClass, SuperClassOfTheExampleClass)
     itkFactorylessNewMacro(Self)
     [...]
 protected:
     ExampleClass();
     virtual ~ExampleClass();
 }
 @endcode
 
 \li Set- and Get-methods can be created with the macros @a itkSetObjectMacro(name,type) and
 @a itkGetObjectMacro(name,type), respectively, if the @a type is derived from @a itk::LightObject or
 @a itk::Object. There are also macros for other types, e.g., strings, see
 <a href="http://www.itk.org/Doxygen12/html/itkMacro_8h.html">itkMacro.h</a>.
 
 \li When using inner classes of a parent class which is templated, you have
 to use the keyword @a typename for gcc 3.x and standard compliance. For example,
 @a TreeChangeListener is an inner class of @a Tree, therefore use:
 @code
 class LinkedTree : public Tree<T>
 {
 
 public:
     typedef typename LinkedTree<T>::TreeChangeListener TreeChangeListener;
     [...]
 }
 @endcode
 Another example:
 @code
 typename std::vector<TreeChangeListener*>::iterator pos = treeChangeListenerList.begin();
 @endcode
 @a iterator is an inner class of @a vector.
 
 \li Constants in MITK for mitk::Operation and mitk::Action are set in namespace, so don't forget to add prefix @a mitk::
 @code
 switch (actionId)
   {
   case mitk::AcMOVESELECTED:
 @endcode
 Prefixes for the constants are to be used like corresponding others. See file @a Interactions\\mitkBaseInteraction\\mitkInteractionConst.h for further details.
 
 \section StyleGuideAndNotesPage_AutomaticCodeFormatting Automatic Code Formatting
 
 We offer a .clang-format file, which can be used to automatically format code acceptably.
 
-\include .clang-format
-
 For an explanation of the different options check out http://clang.llvm.org/docs/ClangFormatStyleOptions.html
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
index f7e9e689b4..cd5bd5e6f0 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
@@ -1,255 +1,255 @@
 /**
 \page HowToNewProject Creating a new MITK project
 
 \tableofcontents
 
 This page is intended to give a comprehensive guide to setting up your own MITK based
 project. It will use the application framework provided by MITK and is probably the
 preferred way for most users.
 
 The first part of this document is a tutorial aimed at newcomers to MITK and possibly
 %CMake and tries to give as much help as possible on setting up your own project. If
 you are looking for more technical information about customizing MITK, the structure
 of the superbuild or packaging you might want to read the
 \ref HowToNewProjectAdvancedInformation.
 
 If you have set up your MITK project already and want to start developing you could
 take a look at \ref TutorialPage.
 
 \section HowToNewProjectGettingStarted Getting Started
 
 To bootstrap your project MITK offers two convenient options:
 
 <ol>
  <li> Use the MITK Plugin Generator, a command line tool used to generate a customized
       MITK project and/or MITK plug-ins (available for download
       <a href="http://www.mitk.org/Download#Plugin_Generator">here</a>).
  <li> Use the <a href="https://github.com/MITK/MITK-ProjectTemplate">MITK project template</a>
       as an example project.
 </ol>
 
 Both options will provide you with a project which contains a "superbuild" mechanism
 to automatically download, configure, and build MITK as a dependency of your own project.
 
 The MITK Plugin Generator generates code using the supplied command line arguments,
 whereas the MITK project template needs immediate modifications to customize it to
 your naming schemes. However, the project template will potentially contain more
 code demonstrating features of MITK.
 
 \note Using the MITK Plugin Generator is recommended for beginners.
 
 \section HowToNewProjectPrerequisites Prerequisites
 
 What ever option you choose, a MITK-based project needs essentially the same
 prerequisites as MITK itself. Please see \ref BuildInstructions_Prerequisites for
 details.
 \note If you use one of the two options above you will \b not \b need to build MITK
 yourself. This will be done automatically.
 
 \section HowToNewProjectCreatingSourceDir Preparing your source directory
 
 In order to start developing with MITK, you first have to set up the source directory
 for your project.
 
 \subsection HowToNewProjectSourceUsingGenerator Using the MITK Plugin Generator
 
 The usage of the Plugin Generator for creating a new project is described in
 \ref NewPluginWithProject, please have a look there.
 
 \subsection HowToNewProjectSourceUsingTemplate Using the MITK Project Template
 
 Download the project as a tarball or zipball and extract it to your desired source
 directory.
 
-\note This is a \b template \b. You must modify it such that it fits the needs of
+\note This is a <b>template</b>. You must modify it such that it fits the needs of
 your particular project. Especially you should do a global search and replace for
 the string "awesome" to rename the template application and plug-in. You may want
 to rename some files too.
 
 \section HowToNewProjectGeneratingCMake Generating your binary with CMake
 
 After you have set up your source directory you can proceed to generate your binary
 directory using %CMake. Depending on your operating system and preferences you might
 want to use "cmake-gui" or "ccmake" (shell). This document assumes you are using
 cmake-gui.
 
 <ol>
  <li> Start "cmake-gui" and enter your source (e.g. "D:\AwesomeProject") and binary
       directory (e.g. "D:\AwesomeProject-superbuild").
  <li> Upon first pressing "Configure" you will be prompted to select your generator.
       This determines what project files will be generated by %CMake. Set this to the
       development tool you are intending to use (e.g. "Visual Studio 2010 64Bit" or
       "linux makefiles".
  <li> Press "Configure" until no new variables appear and then "Generate". Now all
       project files have been generated into your binary directory.
  <li> Double-check that the right Qt version is used.
 </ol>
 
 Now you are ready to compile your code. Depending on your choice of tool this will
 be done differently, we cover two possibilities here.
 
 \subsection HowToNewProjectCompilingLinuxMakefiles Compiling using linux makefiles
 
 <ol>
  <li> In the shell, switch to your binary directory.
  <li> type "make" and hit enter
 </ol>
 
 \subsection HowToNewProjectCompilingVisualStudio Compiling using visual studio
 
 We assume your application is called "AwesomeApp" and your project "AwesomeProject"
 and your binary directory is "D:\AwesomeProject-superbuild\". Replace names and
 paths accordingly.
 
 <ol>
  <li> Close %CMake and open "D:\AwesomeProject-superbuild\AwesomeProject-superbuild.sln".
       Your Visual Studio should appear and by pressing F7 you start the compilation.
       This will clone the MITK source code, build it, and then start building your own
       project.
  <li> After the superbuild compilation has finished, close the superbuild solution file and start
       the build solution file "D:\AwesomeProject-superbuild\AwesomeProject-build\AwesomeProject.sln"
  <li> Set the "AwesomeApp" project as start-up project (right click > "Set as StartUp
       Project") and press "F5" to start your MITK AwesomeApp.
 </ol>
 
 \note Just opening AwesomeProject.sln from your explorer by double-cliking won`t
 allow you to start or debug your application because the required environment
 variables would be missing. Use the supplied batch files or set your PATH variable
 accordingly.
 
 \section HowToNewProjectAddingMITKFunctionality I want to use some MITK plugin but
 it is not available
 
 Due to the sheer number of MITK plugins not every plugin is activated by default.
 To activate a specific plugin (again replace paths as needed):
 <ol>
  <li> Start "cmake-gui" and set the binary directory to
       "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\", the source will
       adjust automatically and you will see new settings appear.
  <li> Navigate to the plugin you want to use (e.g. "MITK_BUILD_org.mitk.gui.qt.segmentation")
       and tick the checkbox behind it
  <li> Press "Configure" until no new variables appear and then "Generate".
  <li> Build MITK using your development tool (as in
       \ref HowToNewProjectCompilingLinuxMakefiles or \ref HowToNewProjectCompilingVisualStudio
       only in the "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\" directory )
  <li> Start "cmake-gui" and set the binary directory to
       "D:\AwesomeProject-superbuild\AwesomeProject-build\", the source will adjust
       automatically and you will see new settings appear.
  <li> Press "Configure" until no new variables appear and then "Generate".
  <li> Build your project
  <li> Start your application
 </ol>
 
 \note If you want to use an application provided by MITK (e.g. MITK Workbench) you
 have to tick the appropriate checkbox as well (in this case MITK_BUILD_APP_Workbench)
 and build MITK. Do note, that this application will be located in the bin directory
 of the "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\" folder.
 
 
 \section HowToNewProjectAdvancedInformation Information for advanced users
 
 \subsection HowToNewProjectCustomizingMITK Customizing MITK
 
 The %CMake scripts from the Plugin Generator of the project template provide some
 handy options which allow you to customize the MITK build used in your project.
 You can either inject an already build MITK to be used by your project or configure
 some MITK options directly in your project's superbuild configuration if MITK is
 going to be build inside your project.
 
-\subsubsection HowToNewProjectCustomizingMITKInjectMITK  Inject a MITK build
+\subsubsection HowToNewProjectCustomizingMITKInjectMITK Inject a MITK build
 
 By setting the \b EXTERNAL_MITK_DIR \b variable in your project's superbuild
 %CMake configuration to a MITK build directory (containing the MITKConfig.cmake)
 you can skip the MITK build process.
 
 If MITK is the only external project in your project, you might want to disable
 the superbuild of your project completely (set <your-proj-name>_USE_SUPERBUILD
 to OFF or edit your CMakeLists.txt file to set it to OFF by default) and set
 the \b MITK_DIR \b %CMake variable to your MITK build directory.
 
 \subsubsection HowToNewProjectCustomizingMITKConfigure Configure the MITK superbuild
 
 If MITK is being build inside your project's superbuild process, you can enable
 the use of certain third-party libraries inside of MITK. The following variables
 control the MITK configuration:
 
 <ul>
  <li> \b MITK_USE_BLUEBERRY Enable the use of the BlueBerry application framework
  <li> \b MITK_USE_CTK Download, compile, and use CTK in MITK
  <li> \b MITK_USE_DCMTK Download, compile, and use DCMTK in MITK
  <li> \b MITK_USE_OpenCV Download, compile, and use OpenCV in MITK
  <li> \b MITK_USE_Python3 Download and compile 1CableSwig and enable Python
       wrapping in ITK, VTK, OpenCV, and MITK
  <li> \b MITK_USE_Qt5 Use the Qt 5 framework in MITK
 </ul>
 
 You can also inject already build third-party libraries from inside your project's
 superbuild in the MITK superbuild by using any of the following %CMake variables:
 
 <ul>
  <li> \b MITK_CTK_DIR Reuse a CTK build directory in MITK.
  <li> \b MITK_CableSwig_DIR Reuse a 1CableSwig build directory in MITK.
  <li> \b MITK_DCMTK_DIR Reuse a DCMKT build directory in MITK.
  <li> \b MITK_GDCM_DIR Reuse a GDCM build directory in MITK.
  <li> \b MITK_ITK_DIR Reuse a ITK build directory in MITK.
  <li> \b MITK_OpenCV_DIR Reuse a OpenCV build directory in MITK.
  <li> \b MITK_VTK_DIR Reuse a VTK build directory in MITK.
 </ul>
 
 If the corresponding \b MITK_USE_<proj> \b  option is set to on, the MITK
 superbuild will use the provided build directory instead of building the
 project itself.
 
 You can also control the source code location for MITK in your project's
 superbuild configuration by using the following %CMake variables:
 
 <ul>
  <li> \b MITK_SOURCE_DIR The path to the MITK source directory. If the value
       for this variable is non-empty, the variables below are ignored.
  <li> \b MITK_GIT_REPOSITORY The Git repository containing the MITK source code.
  <li> \b MITK_GIT_TAG The hash id, tag or branch name used for a checkout
       from MITK_GIT_REPOSITORY.
 </ul>
 
 \subsubsection HowToNewProjectProjectStructure Project Structure
 
 If you are using the superbuild feature of the generated project (the default),
 you might want to familiarise yourself with the layout of your build tree.
 The top-level build directory which you specified in %CMake when configuring
 your project will contain all the required dependencies.
 
 Suppose we call our project MyProject and the build directory is
 "C:\MyProject-superbuild". Then the layout looks something like this:
 
 MyProjectLayout.png The top-level directory contains the source code and the
 build directories from the dependencies of your project. In the current case,
 the only dependency of MyProject is MITK, which in turn has downloaded and built
 its own dependencies (CTK, DCMTK, ITK, etc.). The "real" build tree for your
 project is located in MyProject-superbuild/MyProject-build, so point the
 %CMake-GUI to this build directory if you want to change the set of enabled
 plug-ins for example.
 
 Further, you should open the MyProject.sln solution file (for Visual Studio)
 or execute "make" in the MyProject-superbuild/MyProject-build/ directory.
 Only for the very first time or if you want to update and newly build the
 project's dependencies should you use the project files in the
 MyProject-superbuild directory directly.
 
 The same applies for the MyProject-superbuild/MITK-superbuild directory. This
 directory contains the MITK superbuild, nested inside your project's superbuild.
 If you want to change %CMake options for MITK, use the
 MyProject-superbuild/MITK-superbuild/MITK-build build directory.
 
 \imageMacro{HowToNewProject-MyProjectLayout.png,"Layout of MyProject",4.02}
 
 \subsubsection HowToNewProjectPackaging Packaging
 
 The project template and the generated projects by the Plugin Generator come
 with full packaging support. You can create deployable packages of your project
 for all supported operating systems my building the PACKAGE target. On Linux,
 this will create a tarball, on MacOS a .dmg file, and on Windows a zipball and
 an NSIS installer (if NSIS is installed and found).
 
 You can read more about deployment \ref DeploymentPage "here".
 
 */
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/Starting.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/Starting.dox
index fb427a42ac..509cef90c3 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/Starting.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/Starting.dox
@@ -1,40 +1,39 @@
 /**
 
 \page StartingDevelopment Starting your MITK Development
 
 This introduction will acquaint you with the most important workflows to get you started with your MITK development.
 First, \ref Architecture will explain the differences between the application and the toolkit.
 \ref SettingUpMITK will get you started with a working environment for MITK development. \ref GettingToKnowMITK will walk you trough the folder structure, the module system, and plugin system. This chapter also contains an extensive tutorial on how to work with MITK.
 The \ref FirstSteps section will then show you how to extend MITK for your own project.
 
 <ul>
   <li> \subpage Architecture </li>
   <li> \subpage SettingUpMITK </li>
   <ul>
     <li> \ref SupportedPlatformsPage </li>
     <li> \ref BuildInstructionsPage </li>
     <li> \ref thirdpartylibs </li>
-  <li> \ref HowToNewProject </li>
+    <li> \ref HowToNewProject </li>
   </ul>
   <li> \subpage GettingToKnowMITK </li>
   <ul>
     <li> \ref DirectoryStructurePage </li>
     <li> \ref TutorialPage</li>
     <li> \ref CMAKE_FAQ </li>
     <li> \ref StyleGuideAndNotesPage </li>
     <li> \ref DocumentationGuide </li>
     <li> \ref CodingPage </li>
     <li> \ref KnownProblemsPage </li>
   </ul>
   <li> \subpage FirstSteps </li>
   <ul>
     <li> \ref NewPluginPage </li>
     <li> \ref NewViewPage </li>
     <li> \ref NewModulePage</li>
-  <li> \ref CMAKE_FAQ </li>
-    <li> \ref StatemachineEditor </li>
+    <li> \ref CMAKE_FAQ </li>
   </ul>
   <li> \subpage AboutTestingPage </li>
 </ul>
 
 */
diff --git a/Documentation/buildExtPointDoc.xml.in b/Documentation/buildExtPointDoc.xml.in
deleted file mode 100644
index 5dfd6517db..0000000000
--- a/Documentation/buildExtPointDoc.xml.in
+++ /dev/null
@@ -1,40 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="BlueBerry Extension-Point Documentation" default="all"  basedir="." >
-
-  <path id="convertSchema-classpath">  
-      <fileset dir="@BLUEBERRY_DOC_TOOLS_DIR@/plugins" >  
-          <include name="*.jar"/>  
-          <include name="org.eclipse.pde.build*/*.jar"/>
-      </fileset>
-      <fileset dir="@BLUEBERRY_DOC_TOOLS_DIR@/configuration/org.eclipse.osgi/bundles/207/1/.cp/ant_tasks" >  
-          <include name="*.jar"/>  
-      </fileset>
-  </path> 
-  
-  <taskdef name="pde.convertSchemaToHTML" classname="org.eclipse.pde.internal.core.ant.ConvertSchemaToHTML" >
-    <classpath><path refid="convertSchema-classpath"/></classpath>
-  </taskdef>
-  
-  <target name="all" >
-    <antcall target="convertSchemaToHtml" />
-    <!--antcall target="examplesDocCopy" /-->
-    <!--antcall target="createDocZip" /-->
-  </target>
-
-  <target name="convertSchemaToHtml">
-    <property name="dest" value="@XP_DOC_DESTINATION@" />
-    <!--<property name="source" value="/home/zelzer/svn/mbi/MITK_INSRC/trunk/mitk/Utilities/BlueBerry/Bundles" />-->
-    
-    <record name="${basedir}/schema_convert.txt" action="start"/>
-    
-    <!-- =============  start extension point reference generation  ============ -->
-    
-    @XP_ANT_TASKS@
-    
-    <!-- =============  end extension point reference generation  ============== -->
-      
-    <record name="${basedir}/platformconvert.txt" action="stop"/>
-      
-  </target>
-
-</project>
\ No newline at end of file
diff --git a/Documentation/doxygen.conf.in b/Documentation/doxygen.conf.in
index add0ba4986..15ce344e85 100644
--- a/Documentation/doxygen.conf.in
+++ b/Documentation/doxygen.conf.in
@@ -1,2433 +1,2433 @@
 # Doxyfile 1.8.8
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
 #
 # All text after a double hash (##) is considered a comment and is placed in
 # front of the TAG it is preceding.
 #
 # All text after a single hash (#) is considered a comment and will be ignored.
 # The format is:
 # TAG = value [value, ...]
 # For lists, items can also be appended using:
 # TAG += value [value, ...]
 # Values that contain spaces should be placed between quotes (\" \").
 
 #---------------------------------------------------------------------------
 # Project related configuration options
 #---------------------------------------------------------------------------
 
 # This tag specifies the encoding used for all characters in the config file
 # that follow. The default is UTF-8 which is also the encoding used for all text
 # before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
 # built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
 # for the list of possible encodings.
 # The default value is: UTF-8.
 
 DOXYFILE_ENCODING      = UTF-8
 
 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
 # double-quotes, unless you are using Doxywizard) that should identify the
 # project for which the documentation is generated. This name is used in the
 # title of most generated pages and in a few other places.
 # The default value is: My Project.
 
 PROJECT_NAME           = "Medical Imaging Interaction Toolkit"
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number. This
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
 PROJECT_NUMBER         = @MITK_VERSION_STRING@
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
 # quick idea about the purpose of the project. Keep the description short.
 
 PROJECT_BRIEF          = "Medical Imaging Interaction Toolkit"
 
 # With the PROJECT_LOGO tag one can specify an logo or icon that is included in
 # the documentation. The maximum height of the logo should not exceed 55 pixels
 # and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
 # to the output directory.
 
 PROJECT_LOGO           =
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.
 
 OUTPUT_DIRECTORY       = "@MITK_DOXYGEN_OUTPUT_DIR@"
 
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
 # directories (in 2 levels) under the output directory of each output format and
 # will distribute the generated files over these directories. Enabling this
 # option can be useful when feeding doxygen a huge amount of source files, where
 # putting all generated files in the same directory would otherwise causes
 # performance problems for the file system.
 # The default value is: NO.
 
 CREATE_SUBDIRS         = NO
 
 # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
 # characters to appear in the names of generated files. If set to NO, non-ASCII
 # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
 # U+3044.
 # The default value is: NO.
 
 ALLOW_UNICODE_NAMES    = NO
 
 # The OUTPUT_LANGUAGE tag is used to specify the language in which all
 # documentation generated by doxygen is written. Doxygen will use this
 # information to generate all constant output in the proper language.
 # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
 # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
 # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
 # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
 # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
 # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
 # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
 # Ukrainian and Vietnamese.
 # The default value is: English.
 
 OUTPUT_LANGUAGE        = English
 
 # If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
 # descriptions after the members that are listed in the file and class
 # documentation (similar to Javadoc). Set to NO to disable this.
 # The default value is: YES.
 
 BRIEF_MEMBER_DESC      = YES
 
 # If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
 # description of a member or function before the detailed description
 #
 # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
 # brief descriptions will be completely suppressed.
 # The default value is: YES.
 
 REPEAT_BRIEF           = YES
 
 # This tag implements a quasi-intelligent brief description abbreviator that is
 # used to form the text in various listings. Each string in this list, if found
 # as the leading text of the brief description, will be stripped from the text
 # and the result, after processing the whole list, is used as the annotated
 # text. Otherwise, the brief description is used as-is. If left blank, the
 # following values are used ($name is automatically replaced with the name of
 # the entity):The $name class, The $name widget, The $name file, is, provides,
 # specifies, contains, represents, a, an and the.
 
 ABBREVIATE_BRIEF       =
 
 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
 # doxygen will generate a detailed section even if there is only a brief
 # description.
 # The default value is: NO.
 
 ALWAYS_DETAILED_SEC    = NO
 
 # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
 # inherited members of a class in the documentation of that class as if those
 # members were ordinary class members. Constructors, destructors and assignment
 # operators of the base classes will not be shown.
 # The default value is: NO.
 
 INLINE_INHERITED_MEMB  = NO
 
 # If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
 # before files name in the file list and in the header files. If set to NO the
 # shortest path that makes the file name unique will be used
 # The default value is: YES.
 
 FULL_PATH_NAMES        = NO
 
 # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
 # Stripping is only done if one of the specified strings matches the left-hand
 # part of the path. The tag can be used to show relative paths in the file list.
 # If left blank the directory from which doxygen is run is used as the path to
 # strip.
 #
 # Note that you can specify absolute paths here, but also relative paths, which
 # will be relative from the directory where doxygen is started.
 # This tag requires that the tag FULL_PATH_NAMES is set to YES.
 
 STRIP_FROM_PATH        =
 
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
 # path mentioned in the documentation of a class, which tells the reader which
 # header file to include in order to use a class. If left blank only the name of
 # the header file containing the class definition is used. Otherwise one should
 # specify the list of include paths that are normally passed to the compiler
 # using the -I flag.
 
 STRIP_FROM_INC_PATH    =
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
 # less readable) file names. This can be useful is your file systems doesn't
 # support long names like on DOS, Mac, or CD-ROM.
 # The default value is: NO.
 
 SHORT_NAMES            = NO
 
 # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
 # first line (until the first dot) of a Javadoc-style comment as the brief
 # description. If set to NO, the Javadoc-style will behave just like regular Qt-
 # style comments (thus requiring an explicit @brief command for a brief
 # description.)
 # The default value is: NO.
 
 JAVADOC_AUTOBRIEF      = NO
 
 # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
 # line (until the first dot) of a Qt-style comment as the brief description. If
 # set to NO, the Qt-style will behave just like regular Qt-style comments (thus
 # requiring an explicit \brief command for a brief description.)
 # The default value is: NO.
 
 QT_AUTOBRIEF           = NO
 
 # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
 # multi-line C++ special comment block (i.e. a block of //! or /// comments) as
 # a brief description. This used to be the default behavior. The new default is
 # to treat a multi-line C++ comment block as a detailed description. Set this
 # tag to YES if you prefer the old behavior instead.
 #
 # Note that setting this tag to YES also means that rational rose comments are
 # not recognized any more.
 # The default value is: NO.
 
 MULTILINE_CPP_IS_BRIEF = NO
 
 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
 # documentation from any documented member that it re-implements.
 # The default value is: YES.
 
 INHERIT_DOCS           = YES
 
 # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
 # new page for each member. If set to NO, the documentation of a member will be
 # part of the file/class/namespace that contains it.
 # The default value is: NO.
 
 SEPARATE_MEMBER_PAGES  = NO
 
 # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
 # uses this value to replace tabs by spaces in code fragments.
 # Minimum value: 1, maximum value: 16, default value: 4.
 
 TAB_SIZE               = 8
 
 # This tag can be used to specify a number of aliases that act as commands in
 # the documentation. An alias has the form:
 # name=value
 # For example adding
 # "sideeffect=@par Side Effects:\n"
 # will allow you to put the command \sideeffect (or @sideeffect) in the
 # documentation, which will result in a user-defined paragraph with heading
 # "Side Effects:". You can put \n's in the value part of an alias to insert
 # newlines.
 
 ALIASES                = "FIXME=\par Fix Me's:\n" \
                          "BlueBerry=\if BLUEBERRY" \
                          "endBlueBerry=\endif" \
                          "bundlemainpage{1}=\page \1" \
                          "embmainpage{1}=\page \1" \
                          "github{2}=<a href=\"https://github.com/MITK/MITK/blob/master/\1\">\2</a>" \
                          "deprecatedSince{1}=\xrefitem deprecatedSince\1 \"\" \"Functions deprecated as of \1\" \deprecated (as of \1) " \
                          "minimumCMakeVersion=@MITK_CMAKE_MINIMUM_REQUIRED_VERSION@" \
                          "minimumQt5Version=@MITK_QT5_MINIMUM_VERSION@" \
                          "imageMacro{3}=\image html \1 \2 \n \image latex \1 \2 width=\3cm" \
                          "developersguidemainpage{1}=\page \1 " \
                          "usersguidemainpage{1}=\page \1 " \
                          "nondependentPluginLink{3}= \ref \1 \"\3\" "
 
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For
 # instance, some of the names that are used will be different. The list of all
 # members will be omitted, etc.
 # The default value is: NO.
 
 OPTIMIZE_OUTPUT_FOR_C  = NO
 
 # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
 # Python sources only. Doxygen will then generate output that is more tailored
 # for that language. For instance, namespaces will be presented as packages,
 # qualified scopes will look different, etc.
 # The default value is: NO.
 
 OPTIMIZE_OUTPUT_JAVA   = NO
 
 # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
 # sources. Doxygen will then generate output that is tailored for Fortran.
 # The default value is: NO.
 
 OPTIMIZE_FOR_FORTRAN   = NO
 
 # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
 # sources. Doxygen will then generate output that is tailored for VHDL.
 # The default value is: NO.
 
 OPTIMIZE_OUTPUT_VHDL   = NO
 
 # Doxygen selects the parser to use depending on the extension of the files it
 # parses. With this tag you can assign which parser to use for a given
 # extension. Doxygen has a built-in mapping, but you can override or extend it
 # using this tag. The format is ext=language, where ext is a file extension, and
 # language is one of the parsers supported by doxygen: IDL, Java, Javascript,
 # C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
 # FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
 # Fortran. In the later case the parser tries to guess whether the code is fixed
 # or free formatted code, this is the default for Fortran type files), VHDL. For
 # instance to make doxygen treat .inc files as Fortran files (default is PHP),
 # and .f files as C (default is Fortran), use: inc=Fortran f=C.
 #
 # Note For files without extension you can use no_extension as a placeholder.
 #
 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
 # the files are not read by doxygen.
 
 EXTENSION_MAPPING      = cmake=c++
 
 # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
 # according to the Markdown format, which allows for more readable
 # documentation. See http://daringfireball.net/projects/markdown/ for details.
 # The output of markdown processing is further processed by doxygen, so you can
 # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
 # case of backward compatibilities issues.
 # The default value is: YES.
 
 MARKDOWN_SUPPORT       = YES
 
 # When enabled doxygen tries to link words that correspond to documented
 # classes, or namespaces to their corresponding documentation. Such a link can
 # be prevented in individual cases by by putting a % sign in front of the word
 # or globally by setting AUTOLINK_SUPPORT to NO.
 # The default value is: YES.
 
 AUTOLINK_SUPPORT       = YES
 
 # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
 # to include (a tag file for) the STL sources as input, then you should set this
 # tag to YES in order to let doxygen match functions declarations and
 # definitions whose arguments contain STL classes (e.g. func(std::string);
 # versus func(std::string) {}). This also make the inheritance and collaboration
 # diagrams that involve STL classes more complete and accurate.
 # The default value is: NO.
 
 BUILTIN_STL_SUPPORT    = YES
 
 # If you use Microsoft's C++/CLI language, you should set this option to YES to
 # enable parsing support.
 # The default value is: NO.
 
 CPP_CLI_SUPPORT        = NO
 
 # Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
 # http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
 # will parse them like normal C++ but will assume all classes use public instead
 # of private inheritance when no explicit protection keyword is present.
 # The default value is: NO.
 
 SIP_SUPPORT            = NO
 
 # For Microsoft's IDL there are propget and propput attributes to indicate
 # getter and setter methods for a property. Setting this option to YES will make
 # doxygen to replace the get and set methods by a property in the documentation.
 # This will only work if the methods are indeed getting or setting a simple
 # type. If this is not the case, or you want to show the methods anyway, you
 # should set this option to NO.
 # The default value is: YES.
 
 IDL_PROPERTY_SUPPORT   = YES
 
 # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
 # tag is set to YES, then doxygen will reuse the documentation of the first
 # member in the group (if any) for the other members of the group. By default
 # all members of a group must be documented explicitly.
 # The default value is: NO.
 
 DISTRIBUTE_GROUP_DOC   = YES
 
 # Set the SUBGROUPING tag to YES to allow class member groups of the same type
 # (for instance a group of public functions) to be put as a subgroup of that
 # type (e.g. under the Public Functions section). Set it to NO to prevent
 # subgrouping. Alternatively, this can be done per class using the
 # \nosubgrouping command.
 # The default value is: YES.
 
 SUBGROUPING            = YES
 
 # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
 # are shown inside the group in which they are included (e.g. using \ingroup)
 # instead of on a separate page (for HTML and Man pages) or section (for LaTeX
 # and RTF).
 #
 # Note that this feature does not work in combination with
 # SEPARATE_MEMBER_PAGES.
 # The default value is: NO.
 
 INLINE_GROUPED_CLASSES = NO
 
 # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
 # with only public data fields or simple typedef fields will be shown inline in
 # the documentation of the scope in which they are defined (i.e. file,
 # namespace, or group documentation), provided this scope is documented. If set
 # to NO, structs, classes, and unions are shown on a separate page (for HTML and
 # Man pages) or section (for LaTeX and RTF).
 # The default value is: NO.
 
 INLINE_SIMPLE_STRUCTS  = NO
 
 # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
 # enum is documented as struct, union, or enum with the name of the typedef. So
 # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
 # with name TypeT. When disabled the typedef will appear as a member of a file,
 # namespace, or class. And the struct will be named TypeS. This can typically be
 # useful for C code in case the coding convention dictates that all compound
 # types are typedef'ed and only the typedef is referenced, never the tag name.
 # The default value is: NO.
 
 TYPEDEF_HIDES_STRUCT   = NO
 
 # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
 # cache is used to resolve symbols given their name and scope. Since this can be
 # an expensive process and often the same symbol appears multiple times in the
 # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
 # doxygen will become slower. If the cache is too large, memory is wasted. The
 # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
 # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
 # symbols. At the end of a run doxygen will report the cache usage and suggest
 # the optimal cache size from a speed point of view.
 # Minimum value: 0, maximum value: 9, default value: 0.
 
 LOOKUP_CACHE_SIZE      = 0
 
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
 
 # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
 # documentation are documented, even if no documentation was available. Private
 # class members and static file members will be hidden unless the
 # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
 # Note: This will also disable the warnings about undocumented members that are
 # normally produced when WARNINGS is set to YES.
 # The default value is: NO.
 
 EXTRACT_ALL            = YES
 
 # If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
 # be included in the documentation.
 # The default value is: NO.
 
 EXTRACT_PRIVATE        = NO
 
 # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
 # scope will be included in the documentation.
 # The default value is: NO.
 
 EXTRACT_PACKAGE        = NO
 
 # If the EXTRACT_STATIC tag is set to YES all static members of a file will be
 # included in the documentation.
 # The default value is: NO.
 
 EXTRACT_STATIC         = YES
 
 # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
 # locally in source files will be included in the documentation. If set to NO
 # only classes defined in header files are included. Does not have any effect
 # for Java sources.
 # The default value is: YES.
 
 EXTRACT_LOCAL_CLASSES  = @MITK_DOXYGEN_INTERNAL_DOCS@
 
 # This flag is only useful for Objective-C code. When set to YES local methods,
 # which are defined in the implementation section but not in the interface are
 # included in the documentation. If set to NO only methods in the interface are
 # included.
 # The default value is: NO.
 
 EXTRACT_LOCAL_METHODS  = NO
 
 # If this flag is set to YES, the members of anonymous namespaces will be
 # extracted and appear in the documentation as a namespace called
 # 'anonymous_namespace{file}', where file will be replaced with the base name of
 # the file that contains the anonymous namespace. By default anonymous namespace
 # are hidden.
 # The default value is: NO.
 
 EXTRACT_ANON_NSPACES   = NO
 
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
 # undocumented members inside documented classes or files. If set to NO these
 # members will be included in the various overviews, but no documentation
 # section is generated. This option has no effect if EXTRACT_ALL is enabled.
 # The default value is: NO.
 
 HIDE_UNDOC_MEMBERS     = NO
 
 # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
 # undocumented classes that are normally visible in the class hierarchy. If set
 # to NO these classes will be included in the various overviews. This option has
 # no effect if EXTRACT_ALL is enabled.
 # The default value is: NO.
 
 HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
 # (class|struct|union) declarations. If set to NO these declarations will be
 # included in the documentation.
 # The default value is: NO.
 
 HIDE_FRIEND_COMPOUNDS  = @MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS@
 
 # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
 # documentation blocks found inside the body of a function. If set to NO these
 # blocks will be appended to the function's detailed documentation block.
 # The default value is: NO.
 
 HIDE_IN_BODY_DOCS      = NO
 
 # The INTERNAL_DOCS tag determines if documentation that is typed after a
 # \internal command is included. If the tag is set to NO then the documentation
 # will be excluded. Set it to YES to include the internal documentation.
 # The default value is: NO.
 
 INTERNAL_DOCS          = @MITK_DOXYGEN_INTERNAL_DOCS@
 
 # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
 # names in lower-case letters. If set to YES upper-case letters are also
 # allowed. This is useful if you have classes or files whose names only differ
 # in case and if your file system supports case sensitive file names. Windows
 # and Mac users are advised to set this option to NO.
 # The default value is: system dependent.
 
 CASE_SENSE_NAMES       = YES
 
 # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
 # their full class and namespace scopes in the documentation. If set to YES the
 # scope will be hidden.
 # The default value is: NO.
 
 HIDE_SCOPE_NAMES       = NO
 
 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
 # the files that are included by a file in the documentation of that file.
 # The default value is: YES.
 
 SHOW_INCLUDE_FILES     = YES
 
 # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
 # grouped member an include statement to the documentation, telling the reader
 # which file to include in order to use the member.
 # The default value is: NO.
 
 SHOW_GROUPED_MEMB_INC  = NO
 
 # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
 # files with double quotes in the documentation rather than with sharp brackets.
 # The default value is: NO.
 
 FORCE_LOCAL_INCLUDES   = NO
 
 # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
 # documentation for inline members.
 # The default value is: YES.
 
 INLINE_INFO            = YES
 
 # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
 # (detailed) documentation of file and class members alphabetically by member
 # name. If set to NO the members will appear in declaration order.
 # The default value is: YES.
 
 SORT_MEMBER_DOCS       = YES
 
 # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
 # descriptions of file, namespace and class members alphabetically by member
 # name. If set to NO the members will appear in declaration order. Note that
 # this will also influence the order of the classes in the class list.
 # The default value is: NO.
 
 SORT_BRIEF_DOCS        = NO
 
 # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
 # (brief and detailed) documentation of class members so that constructors and
 # destructors are listed first. If set to NO the constructors will appear in the
 # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
 # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
 # member documentation.
 # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
 # detailed member documentation.
 # The default value is: NO.
 
 SORT_MEMBERS_CTORS_1ST = NO
 
 # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
 # of group names into alphabetical order. If set to NO the group names will
 # appear in their defined order.
 # The default value is: NO.
 
 SORT_GROUP_NAMES       = NO
 
 # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
 # fully-qualified names, including namespaces. If set to NO, the class list will
 # be sorted only by class name, not including the namespace part.
 # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
 # Note: This option applies only to the class list, not to the alphabetical
 # list.
 # The default value is: NO.
 
 SORT_BY_SCOPE_NAME     = YES
 
 # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
 # type resolution of all parameters of a function it will reject a match between
 # the prototype and the implementation of a member function even if there is
 # only one candidate or it is obvious which candidate to choose by doing a
 # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
 # accept a match between prototype and implementation in such cases.
 # The default value is: NO.
 
 STRICT_PROTO_MATCHING  = NO
 
 # The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
 # todo list. This list is created by putting \todo commands in the
 # documentation.
 # The default value is: YES.
 
 GENERATE_TODOLIST      = @MITK_DOXYGEN_GENERATE_TODOLIST@
 
 # The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
 # test list. This list is created by putting \test commands in the
 # documentation.
 # The default value is: YES.
 
 GENERATE_TESTLIST      = YES
 
 # The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
 # list. This list is created by putting \bug commands in the documentation.
 # The default value is: YES.
 
 GENERATE_BUGLIST       = @MITK_DOXYGEN_GENERATE_BUGLIST@
 
 # The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
 # the deprecated list. This list is created by putting \deprecated commands in
 # the documentation.
 # The default value is: YES.
 
 GENERATE_DEPRECATEDLIST= @MITK_DOXYGEN_GENERATE_DEPRECATEDLIST@
 
 # The ENABLED_SECTIONS tag can be used to enable conditional documentation
 # sections, marked by \if <section_label> ... \endif and \cond <section_label>
 # ... \endcond blocks.
 
 ENABLED_SECTIONS       = @MITK_DOXYGEN_ENABLED_SECTIONS@
 
 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
 # initial value of a variable or macro / define can have for it to appear in the
 # documentation. If the initializer consists of more lines than specified here
 # it will be hidden. Use a value of 0 to hide initializers completely. The
 # appearance of the value of individual variables and macros / defines can be
 # controlled using \showinitializer or \hideinitializer command in the
 # documentation regardless of this setting.
 # Minimum value: 0, maximum value: 10000, default value: 30.
 
 MAX_INITIALIZER_LINES  = 0
 
 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
 # the bottom of the documentation of classes and structs. If set to YES the list
 # will mention the files that were used to generate the documentation.
 # The default value is: YES.
 
 SHOW_USED_FILES        = YES
 
 # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
 # will remove the Files entry from the Quick Index and from the Folder Tree View
 # (if specified).
 # The default value is: YES.
 
 SHOW_FILES             = YES
 
 # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
 # page. This will remove the Namespaces entry from the Quick Index and from the
 # Folder Tree View (if specified).
 # The default value is: YES.
 
 SHOW_NAMESPACES        = YES
 
 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 # doxygen should invoke to get the current version for each file (typically from
 # the version control system). Doxygen will invoke the program by executing (via
 # popen()) the command command input-file, where command is the value of the
 # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
 # by doxygen. Whatever the program writes to standard output is used as the file
 # version. For an example see the documentation.
 
 FILE_VERSION_FILTER    =
 
 # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
 # by doxygen. The layout file controls the global structure of the generated
 # output files in an output format independent way. To create the layout file
 # that represents doxygen's defaults, run doxygen with the -l option. You can
 # optionally specify a file name after the option, if omitted DoxygenLayout.xml
 # will be used as the name of the layout file.
 #
 # Note that if you run doxygen from a directory containing a file called
 # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
 # tag is left empty.
 
 LAYOUT_FILE            = "@MITK_SOURCE_DIR@/Documentation/MITKDoxygenLayout.xml"
 
 # The CITE_BIB_FILES tag can be used to specify one or more bib files containing
 # the reference definitions. This must be a list of .bib files. The .bib
 # extension is automatically appended if omitted. This requires the bibtex tool
 # to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
 # For LaTeX the style of the bibliography can be controlled using
 # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
 # search path. See also \cite for info how to create references.
 
 CITE_BIB_FILES         =
 
 #---------------------------------------------------------------------------
 # Configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
 
 # The QUIET tag can be used to turn on/off the messages that are generated to
 # standard output by doxygen. If QUIET is set to YES this implies that the
 # messages are off.
 # The default value is: NO.
 
 QUIET                  = YES
 
 # The WARNINGS tag can be used to turn on/off the warning messages that are
 # generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
 # this implies that the warnings are on.
 #
 # Tip: Turn warnings on while writing the documentation.
 # The default value is: YES.
 
 WARNINGS               = YES
 
 # If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
 # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
 # will automatically be disabled.
 # The default value is: YES.
 
 WARN_IF_UNDOCUMENTED   = YES
 
 # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
 # potential errors in the documentation, such as not documenting some parameters
 # in a documented function, or documenting parameters that don't exist or using
 # markup commands wrongly.
 # The default value is: YES.
 
 WARN_IF_DOC_ERROR      = YES
 
 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
 # are documented, but have no documentation for their parameters or return
 # value. If set to NO doxygen will only warn about wrong or incomplete parameter
 # documentation, but not about the absence of documentation.
 # The default value is: NO.
 
 WARN_NO_PARAMDOC       = NO
 
 # The WARN_FORMAT tag determines the format of the warning messages that doxygen
 # can produce. The string should contain the $file, $line, and $text tags, which
 # will be replaced by the file and line number from which the warning originated
 # and the warning text. Optionally the format may contain $version, which will
 # be replaced by the version of the file (if it could be obtained via
 # FILE_VERSION_FILTER)
 # The default value is: $file:$line: $text.
 
 WARN_FORMAT            = "$file:$line: $text"
 
 # The WARN_LOGFILE tag can be used to specify a file to which warning and error
 # messages should be written. If left blank the output is written to standard
 # error (stderr).
 
 WARN_LOGFILE           =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the input files
 #---------------------------------------------------------------------------
 
 # The INPUT tag is used to specify the files and/or directories that contain
 # documented source files. You may enter file names like myfile.cpp or
 # directories like /usr/src/myproject. Separate the files or directories with
 # spaces.
 # Note: If this tag is empty the current directory is searched.
 
 
 INPUT                  = @MITK_SOURCE_DIR@ \
-                         @MITK_SOURCE_DIR@/README.md \
                          @MITK_BINARY_DIR@ \
                          @MITK_DOXYGEN_ADDITIONAL_INPUT_DIRS@
 
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
 # documentation (see: http://www.gnu.org/software/libiconv) for the list of
 # possible encodings.
 # The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
 
 # If the value of the INPUT tag contains directories, you can use the
 # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
 # *.h) to filter out the source-files in the directories. If left blank the
 # following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
 # *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
 # *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
 # *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
 # *.qsf, *.as and *.js.
 
 FILE_PATTERNS          = *.h \
                          *.dox \
                          *.md
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.
 # The default value is: NO.
 
 RECURSIVE              = YES
 
 # The EXCLUDE tag can be used to specify files and/or directories that should be
 # excluded from the INPUT source files. This way you can easily exclude a
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
 #
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
 EXCLUDE                = "@MITK_SOURCE_DIR@/Utilities/IpFunc/" \
                          "@MITK_SOURCE_DIR@/Utilities/IpSegmentation/" \
                          "@MITK_SOURCE_DIR@/Utilities/qtsingleapplication/" \
                          "@MITK_SOURCE_DIR@/Applications/PluginGenerator/" \
                          "@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/doc/snippets/" \
                          "@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/doc/doxygen/standalone/" \
                          "@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/test/" \
                          "@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/examples/" \
                          "@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/src/util/jsoncpp.cpp" \
+                         "@MITK_SOURCE_DIR@/Modules/CppMicroServices/third_party" \
                          "@MITK_SOURCE_DIR@/CMake/PackageDepends" \
                          "@MITK_SOURCE_DIR@/CMakeExternals" \
                          "@MITK_SOURCE_DIR@/Licenses" \
                          "@MITK_BINARY_DIR@/Documentation/Doxygen" \
                          "@MITK_BINARY_DIR@/bin/" \
                          "@MITK_BINARY_DIR@/PT/" \
                          "@MITK_BINARY_DIR@/GP/" \
                          "@MITK_BINARY_DIR@/_CPack_Packages/" \
                          @MITK_DOXYGEN_ADDITIONAL_EXCLUDE_DIRS@
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
 # from the input.
 # The default value is: NO.
 
 EXCLUDE_SYMLINKS       = NO
 
 # If the value of the INPUT tag contains directories, you can use the
 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
 # certain files from those directories.
 #
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories for example use the pattern */test/*
 
 EXCLUDE_PATTERNS       = README* \
                          moc_* \
                          ui_* \
                          qrc_* \
                          wrap_* \
                          Register* \
                          */files.cmake \
                          */.git/* \
                          *_p.h \
                          *Private.* \
                          */Internal/* \
                          */internal/* \
                          */Snippets/* \
                          */snippets/* \
                          */testing/* \
                          */Testing/* \
                          */test/* \
                          */resource/* \
                          "@MITK_BINARY_DIR@/*.cmake" \
                          @MITK_DOXYGEN_EXCLUDE_PATTERNS@
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
 # AClass::ANamespace, ANamespace::*Test
 #
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
 
 EXCLUDE_SYMBOLS        =
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or directories
 # that contain example code fragments that are included (see the \include
 # command).
 
-EXAMPLE_PATH           = "@MITK_SOURCE_DIR@/Documentation/Snippets/" \
-                         "@MITK_SOURCE_DIR@/Examples/" \
+EXAMPLE_PATH           = "@MITK_SOURCE_DIR@/Examples/" \
                          "@MITK_SOURCE_DIR@/Examples/Tutorial/" \
                          "@MITK_SOURCE_DIR@/Examples/Plugins/" \
                          "@MITK_SOURCE_DIR@/Examples/QtFreeRender/" \
                          "@MITK_SOURCE_DIR@/Modules/Core/" \
                          "@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/doc/snippets/" \
                          "@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/examples/" \
                          "@MITK_DOXYGEN_OUTPUT_DIR@/html/extension-points/html/" \
                          "@MITK_SOURCE_DIR@/Modules/OpenCL/Documentation/doxygen/snippets/" \
                          "@MITK_SOURCE_DIR@/Modules/IGT/Tutorial/" \
+                         "@MITK_SOURCE_DIR@/Plugins/org.mitk.gui.common/src/" \
                          "@MITK_SOURCE_DIR@/Plugins/org.mitk.gui.qt.igtexamples/" \
                          "@MITK_SOURCE_DIR@/Plugins/org.mitk.gui.qt.igttracking/"
 
 # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
 # *.h) to filter out the source-files in the directories. If left blank all
 # files are included.
 
 EXAMPLE_PATTERNS       =
 
 # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
 # searched for input files to be used with the \include or \dontinclude commands
 # irrespective of the value of the RECURSIVE tag.
 # The default value is: NO.
 
 EXAMPLE_RECURSIVE      = YES
 
 # The IMAGE_PATH tag can be used to specify one or more files or directories
 # that contain images that are to be included in the documentation (see the
 # \image command).
 
 IMAGE_PATH             = "@MITK_SOURCE_DIR@/Documentation/Doxygen/" \
                          "@MITK_SOURCE_DIR@"
 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
 # invoke to filter for each input file. Doxygen will invoke the filter program
 # by executing (via popen()) the command:
 #
 # <filter> <input-file>
 #
 # where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
 # name of an input file. Doxygen will then use the output that the filter
 # program writes to standard output. If FILTER_PATTERNS is specified, this tag
 # will be ignored.
 #
 # Note that the filter must not add or remove lines; it is applied before the
 # code is scanned, but not when the output code is generated. If lines are added
 # or removed, the anchors will not be placed correctly.
 
 INPUT_FILTER           =
 
 # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
 # basis. Doxygen will compare the file name with each pattern and apply the
 # filter if there is a match. The filters are a list of the form: pattern=filter
 # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
 # filters are used. If the FILTER_PATTERNS tag is empty or if none of the
 # patterns match the file name, INPUT_FILTER is applied.
 
 FILTER_PATTERNS        = *.cmake=@CMakeDoxygenFilter_EXECUTABLE@
 
 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
 # INPUT_FILTER ) will also be used to filter the input files that are used for
 # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
 # The default value is: NO.
 
 FILTER_SOURCE_FILES    = NO
 
 # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
 # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
 # it is also possible to disable source filtering for a specific pattern using
 # *.ext= (so without naming a filter).
 # This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
 
 FILTER_SOURCE_PATTERNS =
 
 # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
 # is part of the input, its contents will be placed on the main page
 # (index.html). This can be useful if you have a project on for instance GitHub
 # and want to reuse the introduction page also for the doxygen output.
 
-USE_MDFILE_AS_MAINPAGE = README.md
+USE_MDFILE_AS_MAINPAGE =
 
 #---------------------------------------------------------------------------
 # Configuration options related to source browsing
 #---------------------------------------------------------------------------
 
 # If the SOURCE_BROWSER tag is set to YES then a list of source files will be
 # generated. Documented entities will be cross-referenced with these sources.
 #
 # Note: To get rid of all source code in the generated output, make sure that
 # also VERBATIM_HEADERS is set to NO.
 # The default value is: NO.
 
 SOURCE_BROWSER         = YES
 
 # Setting the INLINE_SOURCES tag to YES will include the body of functions,
 # classes and enums directly into the documentation.
 # The default value is: NO.
 
 INLINE_SOURCES         = NO
 
 # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
 # special comment blocks from generated source code fragments. Normal C, C++ and
 # Fortran comments will always remain visible.
 # The default value is: YES.
 
 STRIP_CODE_COMMENTS    = YES
 
 # If the REFERENCED_BY_RELATION tag is set to YES then for each documented
 # function all documented functions referencing it will be listed.
 # The default value is: NO.
 
 REFERENCED_BY_RELATION = YES
 
 # If the REFERENCES_RELATION tag is set to YES then for each documented function
 # all documented entities called/used by that function will be listed.
 # The default value is: NO.
 
 REFERENCES_RELATION    = YES
 
 # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
 # to YES, then the hyperlinks from functions in REFERENCES_RELATION and
 # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
 # link to the documentation.
 # The default value is: YES.
 
 REFERENCES_LINK_SOURCE = YES
 
 # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
 # source code will show a tooltip with additional information such as prototype,
 # brief description and links to the definition and documentation. Since this
 # will make the HTML file larger and loading of large files a bit slower, you
 # can opt to disable this feature.
 # The default value is: YES.
 # This tag requires that the tag SOURCE_BROWSER is set to YES.
 
 SOURCE_TOOLTIPS        = YES
 
 # If the USE_HTAGS tag is set to YES then the references to source code will
 # point to the HTML generated by the htags(1) tool instead of doxygen built-in
 # source browser. The htags tool is part of GNU's global source tagging system
 # (see http://www.gnu.org/software/global/global.html). You will need version
 # 4.8.6 or higher.
 #
 # To use it do the following:
 # - Install the latest version of global
 # - Enable SOURCE_BROWSER and USE_HTAGS in the config file
 # - Make sure the INPUT points to the root of the source tree
 # - Run doxygen as normal
 #
 # Doxygen will invoke htags (and that will in turn invoke gtags), so these
 # tools must be available from the command line (i.e. in the search path).
 #
 # The result: instead of the source browser generated by doxygen, the links to
 # source code will now point to the output of htags.
 # The default value is: NO.
 # This tag requires that the tag SOURCE_BROWSER is set to YES.
 
 USE_HTAGS              = NO
 
 # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
 # verbatim copy of the header file for each class for which an include is
 # specified. Set to NO to disable this.
 # See also: Section \class.
 # The default value is: YES.
 
 VERBATIM_HEADERS       = YES
 
 #---------------------------------------------------------------------------
 # Configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
 
 # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
 # compounds will be generated. Enable this if the project contains a lot of
 # classes, structs, unions or interfaces.
 # The default value is: YES.
 
 ALPHABETICAL_INDEX     = YES
 
 # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
 # which the alphabetical index list will be split.
 # Minimum value: 1, maximum value: 20, default value: 5.
 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
 
 COLS_IN_ALPHA_INDEX    = 3
 
 # In case all classes in a project start with a common prefix, all classes will
 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
 # can be used to specify a prefix (or a list of prefixes) that should be ignored
 # while generating the index headers.
 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
 
 IGNORE_PREFIX          =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the HTML output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
 # The default value is: YES.
 
 GENERATE_HTML          = YES
 
 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
 # it.
 # The default directory is: html.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_OUTPUT            = html
 
 # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
 # generated HTML page (for example: .htm, .php, .asp).
 # The default value is: .html.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_FILE_EXTENSION    = .html
 
 # The HTML_HEADER tag can be used to specify a user-defined HTML header file for
 # each generated HTML page. If the tag is left blank doxygen will generate a
 # standard header.
 #
 # To get valid HTML the header file that includes any scripts and style sheets
 # that doxygen needs, which is dependent on the configuration options used (e.g.
 # the setting GENERATE_TREEVIEW). It is highly recommended to start with a
 # default header using
 # doxygen -w html new_header.html new_footer.html new_stylesheet.css
 # YourConfigFile
 # and then modify the file new_header.html. See also section "Doxygen usage"
 # for information on how to generate the default header that doxygen normally
 # uses.
 # Note: The header is subject to change so you typically have to regenerate the
 # default header when upgrading to a newer version of doxygen. For a description
 # of the possible markers and block names see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_HEADER            =
 
 # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
 # generated HTML page. If the tag is left blank doxygen will generate a standard
 # footer. See HTML_HEADER for more information on how to generate a default
 # footer and what special commands can be used inside the footer. See also
 # section "Doxygen usage" for information on how to generate the default footer
 # that doxygen normally uses.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_FOOTER            =
 
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
 # sheet that is used by each HTML page. It can be used to fine-tune the look of
 # the HTML output. If left blank doxygen will generate a default style sheet.
 # See also section "Doxygen usage" for information on how to generate the style
 # sheet that doxygen normally uses.
 # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
 # it is more robust and this tag (HTML_STYLESHEET) will in the future become
 # obsolete.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_STYLESHEET        =
 
 # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
 # cascading style sheets that are included after the standard style sheets
 # created by doxygen. Using this option one can overrule certain style aspects.
 # This is preferred over using HTML_STYLESHEET since it does not replace the
 # standard style sheet and is therefor more robust against future updates.
 # Doxygen will copy the style sheet files to the output directory.
 # Note: The order of the extra stylesheet files is of importance (e.g. the last
 # stylesheet in the list overrules the setting of the previous ones in the
 # list). For an example see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_EXTRA_STYLESHEET  = @MITK_DOXYGEN_STYLESHEET@
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
 # that these files will be copied to the base HTML output directory. Use the
 # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
 # files. In the HTML_STYLESHEET file, use the file name only. Also note that the
 # files will be copied as-is; there are no commands or markers available.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_EXTRA_FILES       = "@MITK_SOURCE_DIR@/Documentation/Doxygen/mitkLogo.jpg"
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the stylesheet and background images according to
 # this color. Hue is specified as an angle on a colorwheel, see
 # http://en.wikipedia.org/wiki/Hue for more information. For instance the value
 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
 # purple, and 360 is red again.
 # Minimum value: 0, maximum value: 359, default value: 220.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_COLORSTYLE_HUE    = 220
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
 # in the HTML output. For a value of 0 the output will use grayscales only. A
 # value of 255 will produce the most vivid colors.
 # Minimum value: 0, maximum value: 255, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_COLORSTYLE_SAT    = 100
 
 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
 # luminance component of the colors in the HTML output. Values below 100
 # gradually make the output lighter, whereas values above 100 make the output
 # darker. The value divided by 100 is the actual gamma applied, so 80 represents
 # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
 # change the gamma.
 # Minimum value: 40, maximum value: 240, default value: 80.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_COLORSTYLE_GAMMA  = 80
 
 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
 # page will contain the date and time when the page was generated. Setting this
 # to NO can help when comparing the output of multiple runs.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_TIMESTAMP         = YES
 
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
 # page has loaded.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_DYNAMIC_SECTIONS  = @MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS@
 
 # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
 # shown in the various tree structured indices initially; the user can expand
 # and collapse entries dynamically later on. Doxygen will expand the tree to
 # such a level that at most the specified number of entries are visible (unless
 # a fully collapsed tree already exceeds this amount). So setting the number of
 # entries 1 will produce a full collapsed tree by default. 0 is a special value
 # representing an infinite number of entries and will result in a full expanded
 # tree by default.
 # Minimum value: 0, maximum value: 9999, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
 # generated that can be used as input for Apple's Xcode 3 integrated development
 # environment (see: http://developer.apple.com/tools/xcode/), introduced with
 # OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
 # Makefile in the HTML output directory. Running make will produce the docset in
 # that directory and running make install will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
 # startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
 # for more information.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_DOCSET        = NO
 
 # This tag determines the name of the docset feed. A documentation feed provides
 # an umbrella under which multiple documentation sets from a single provider
 # (such as a company or product suite) can be grouped.
 # The default value is: Doxygen generated docs.
 # This tag requires that the tag GENERATE_DOCSET is set to YES.
 
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 
 # This tag specifies a string that should uniquely identify the documentation
 # set bundle. This should be a reverse domain-name style string, e.g.
 # com.mycompany.MyDocSet. Doxygen will append .docset to the name.
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_DOCSET is set to YES.
 
 DOCSET_BUNDLE_ID       = org.doxygen.Project
 
 # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
 # the documentation publisher. This should be a reverse domain-name style
 # string, e.g. com.mycompany.MyDocSet.documentation.
 # The default value is: org.doxygen.Publisher.
 # This tag requires that the tag GENERATE_DOCSET is set to YES.
 
 DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
 
 # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
 # The default value is: Publisher.
 # This tag requires that the tag GENERATE_DOCSET is set to YES.
 
 DOCSET_PUBLISHER_NAME  = Publisher
 
 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
 # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
 # Windows.
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output
 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
 # files are now used as the Windows 98 help format, and will replace the old
 # Windows help format (.hlp) on all Windows platforms in the future. Compressed
 # HTML files also contain an index, a table of contents, and you can search for
 # words in the documentation. The HTML workshop also contains a viewer for
 # compressed HTML files.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_HTMLHELP      = NO
 
 # The CHM_FILE tag can be used to specify the file name of the resulting .chm
 # file. You can add a path in front of the file if the result should not be
 # written to the html output directory.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 CHM_FILE               =
 
 # The HHC_LOCATION tag can be used to specify the location (absolute path
 # including file name) of the HTML help compiler ( hhc.exe). If non-empty
 # doxygen will try to run the HTML help compiler on the generated index.hhp.
 # The file has to be specified with full path.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 HHC_LOCATION           =
 
 # The GENERATE_CHI flag controls if a separate .chi index file is generated (
 # YES) or that it should be included in the master .chm file ( NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 GENERATE_CHI           = NO
 
 # The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
 # and project file content.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 CHM_INDEX_ENCODING     =
 
 # The BINARY_TOC flag controls whether a binary table of contents is generated (
 # YES) or a normal table of contents ( NO) in the .chm file. Furthermore it
 # enables the Previous and Next buttons.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 BINARY_TOC             = NO
 
 # The TOC_EXPAND flag can be set to YES to add extra items for group members to
 # the table of contents of the HTML help documentation and to the tree view.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
 TOC_EXPAND             = NO
 
 # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
 # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
 # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
 # (.qch) of the generated HTML documentation.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_QHP           = @MITK_DOXYGEN_GENERATE_QHP@
 
 # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
 # the file name of the resulting .qch file. The path specified is relative to
 # the HTML output folder.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QCH_FILE               = @MITK_DOXYGEN_QCH_FILE@
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
 # Project output. For more information please see Qt Help Project / Namespace
 # (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_NAMESPACE          = "org.mitk"
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
 # Help Project output. For more information please see Qt Help Project / Virtual
 # Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
 # folders).
 # The default value is: doc.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_VIRTUAL_FOLDER     = MITK
 
 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
 # filter to add. For more information please see Qt Help Project / Custom
 # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
 # filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see Qt Help Project / Custom
 # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
 # filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
 # project's filter section matches. Qt Help Project / Filter Attributes (see:
 # http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_SECT_FILTER_ATTRS  =
 
 # The QHG_LOCATION tag can be used to specify the location of Qt's
 # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
 # generated .qhp file.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHG_LOCATION           = @QT_HELPGENERATOR_EXECUTABLE@
 
 # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
 # generated, together with the HTML files, they form an Eclipse help plugin. To
 # install this plugin and make it available under the help contents menu in
 # Eclipse, the contents of the directory containing the HTML and XML files needs
 # to be copied into the plugins directory of eclipse. The name of the directory
 # within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
 # After copying Eclipse needs to be restarted before the help appears.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_ECLIPSEHELP   = NO
 
 # A unique identifier for the Eclipse help plugin. When installing the plugin
 # the directory name containing the HTML and XML files should also have this
 # name. Each documentation set should have its own identifier.
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
 
 ECLIPSE_DOC_ID         = org.doxygen.Project
 
 # If you want full control over the layout of the generated HTML pages it might
 # be necessary to disable the index and replace it with your own. The
 # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
 # of each HTML page. A value of NO enables the index and the value YES disables
 # it. Since the tabs in the index contain the same information as the navigation
 # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 DISABLE_INDEX          = NO
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
 # structure should be generated to display hierarchical information. If the tag
 # value is set to YES, a side panel will be generated containing a tree-like
 # index structure (just like the one that is generated for HTML Help). For this
 # to work a browser that supports JavaScript, DHTML, CSS and frames is required
 # (i.e. any modern browser). Windows users are probably better off using the
 # HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
 # further fine-tune the look of the index. As an example, the default style
 # sheet generated by doxygen has an example that shows how to put an image at
 # the root of the tree instead of the PROJECT_NAME. Since the tree basically has
 # the same information as the tab index, you could consider setting
 # DISABLE_INDEX to YES when enabling this option.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_TREEVIEW      = YES
 
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
 # doxygen will group on one line in the generated HTML documentation.
 #
 # Note that a value of 0 will completely suppress the enum values from appearing
 # in the overview section.
 # Minimum value: 0, maximum value: 20, default value: 4.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 ENUM_VALUES_PER_LINE   = 4
 
 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
 # to set the initial width (in pixels) of the frame in which the tree is shown.
 # Minimum value: 0, maximum value: 1500, default value: 250.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 TREEVIEW_WIDTH         = 300
 
 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
 # external symbols imported via tag files in a separate window.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 EXT_LINKS_IN_WINDOW    = NO
 
 # Use this tag to change the font size of LaTeX formulas included as images in
 # the HTML documentation. When you change the font size after a successful
 # doxygen run you need to manually remove any form_*.png images from the HTML
 # output directory to force them to be regenerated.
 # Minimum value: 8, maximum value: 50, default value: 10.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 FORMULA_FONTSIZE       = 10
 
 # Use the FORMULA_TRANPARENT tag to determine whether or not the images
 # generated for formulas are transparent PNGs. Transparent PNGs are not
 # supported properly for IE 6.0, but are supported on all modern browsers.
 #
 # Note that when changing this option you need to delete any form_*.png files in
 # the HTML output directory before the changes have effect.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 FORMULA_TRANSPARENT    = YES
 
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
 # http://www.mathjax.org) which uses client side Javascript for the rendering
 # instead of using prerendered bitmaps. Use this if you do not have LaTeX
 # installed or if you want to formulas look prettier in the HTML output. When
 # enabled you may also need to install MathJax separately and configure the path
 # to it using the MATHJAX_RELPATH option.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 USE_MATHJAX            = YES
 
 # When MathJax is enabled you can set the default output format to be used for
 # the MathJax output. See the MathJax site (see:
 # http://docs.mathjax.org/en/latest/output.html) for more details.
 # Possible values are: HTML-CSS (which is slower, but has the best
 # compatibility), NativeMML (i.e. MathML) and SVG.
 # The default value is: HTML-CSS.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_FORMAT         = HTML-CSS
 
 # When MathJax is enabled you need to specify the location relative to the HTML
 # output directory using the MATHJAX_RELPATH option. The destination directory
 # should contain the MathJax.js script. For instance, if the mathjax directory
 # is located at the same level as the HTML output directory, then
 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
 # Content Delivery Network so you can quickly see the result without installing
 # MathJax. However, it is strongly recommended to install a local copy of
 # MathJax from http://www.mathjax.org before deployment.
 # The default value is: http://cdn.mathjax.org/mathjax/latest.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
 # extension names that should be enabled during MathJax rendering. For example
 # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_EXTENSIONS     =
 
 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
 # of code that will be used on startup of the MathJax code. See the MathJax site
 # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
 # example see the documentation.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_CODEFILE       =
 
 # When the SEARCHENGINE tag is enabled doxygen will generate a search box for
 # the HTML output. The underlying search engine uses javascript and DHTML and
 # should work on any modern browser. Note that when using HTML help
 # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
 # there is already a search function so this one should typically be disabled.
 # For large projects the javascript based search engine can be slow, then
 # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
 # search using the keyboard; to jump to the search box use <access key> + S
 # (what the <access key> is depends on the OS and browser, but it is typically
 # <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
 # key> to jump into the search results window, the results can be navigated
 # using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
 # the search. The filter options can be selected when the cursor is inside the
 # search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
 # to select a filter and <Enter> or <escape> to activate or cancel the filter
 # option.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
 # implemented using a web server instead of a web client using Javascript. There
 # are two flavors of web server based searching depending on the EXTERNAL_SEARCH
 # setting. When disabled, doxygen will generate a PHP script for searching and
 # an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
 # and searching needs to be provided by external tools. See the section
 # "External Indexing and Searching" for details.
 # The default value is: NO.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 SERVER_BASED_SEARCH    = NO
 
 # When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
 # script for searching. Instead the search results are written to an XML file
 # which needs to be processed by an external indexer. Doxygen will invoke an
 # external search engine pointed to by the SEARCHENGINE_URL option to obtain the
 # search results.
 #
 # Doxygen ships with an example indexer ( doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
 # Xapian (see: http://xapian.org/).
 #
 # See the section "External Indexing and Searching" for details.
 # The default value is: NO.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 EXTERNAL_SEARCH        = NO
 
 # The SEARCHENGINE_URL should point to a search engine hosted by a web server
 # which will return the search results when EXTERNAL_SEARCH is enabled.
 #
 # Doxygen ships with an example indexer ( doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
 # Xapian (see: http://xapian.org/). See the section "External Indexing and
 # Searching" for details.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHENGINE_URL       =
 
 # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
 # search data is written to a file for indexing by an external tool. With the
 # SEARCHDATA_FILE tag the name of this file can be specified.
 # The default file is: searchdata.xml.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHDATA_FILE        = searchdata.xml
 
 # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
 # EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
 # useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
 # projects and redirect the results back to the right project.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 EXTERNAL_SEARCH_ID     =
 
 # The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
 # projects other than the one defined by this configuration file, but that are
 # all added to the same external search index. Each project needs to have a
 # unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
 # to a relative location where the documentation can be found. The format is:
 # EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 EXTRA_SEARCH_MAPPINGS  =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the LaTeX output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
 # The default value is: YES.
 
 GENERATE_LATEX         = NO
 
 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
 # it.
 # The default directory is: latex.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_OUTPUT           = latex
 
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
 # invoked.
 #
 # Note that when enabling USE_PDFLATEX this option is only used for generating
 # bitmaps for formulas in the HTML output, but not in the Makefile that is
 # written to the output directory.
 # The default file is: latex.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_CMD_NAME         = latex
 
 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
 # index for LaTeX.
 # The default file is: makeindex.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 MAKEINDEX_CMD_NAME     = makeindex
 
 # If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
 # documents. This may be useful for small projects and may help to save some
 # trees in general.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 COMPACT_LATEX          = NO
 
 # The PAPER_TYPE tag can be used to set the paper type that is used by the
 # printer.
 # Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
 # 14 inches) and executive (7.25 x 10.5 inches).
 # The default value is: a4.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 PAPER_TYPE             = a4
 
 # The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
 # that should be included in the LaTeX output. To get the times font for
 # instance you can specify
 # EXTRA_PACKAGES=times
 # If left blank no extra packages will be included.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 EXTRA_PACKAGES         = amssymb
 
 # The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
 # generated LaTeX document. The header should contain everything until the first
 # chapter. If it is left blank doxygen will generate a standard header. See
 # section "Doxygen usage" for information on how to let doxygen write the
 # default header to a separate file.
 #
 # Note: Only use a user-defined header if you know what you are doing! The
 # following commands have a special meaning inside the header: $title,
 # $datetime, $date, $doxygenversion, $projectname, $projectnumber,
 # $projectbrief, $projectlogo. Doxygen will replace $title with the empy string,
 # for the replacement values of the other commands the user is refered to
 # HTML_HEADER.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_HEADER           =
 
 # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
 # generated LaTeX document. The footer should contain everything after the last
 # chapter. If it is left blank doxygen will generate a standard footer. See
 # LATEX_HEADER for more information on how to generate a default footer and what
 # special commands can be used inside the footer.
 #
 # Note: Only use a user-defined footer if you know what you are doing!
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_FOOTER           =
 
 # The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the LATEX_OUTPUT output
 # directory. Note that the files will be copied as-is; there are no commands or
 # markers available.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_EXTRA_FILES      =
 
 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
 # prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
 # contain links (just like the HTML output) instead of page references. This
 # makes the output suitable for online browsing using a PDF viewer.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 PDF_HYPERLINKS         = NO
 
 # If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
 # the PDF file directly from the LaTeX files. Set this option to YES to get a
 # higher quality PDF documentation.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 USE_PDFLATEX           = NO
 
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
 # command to the generated LaTeX files. This will instruct LaTeX to keep running
 # if errors occur, instead of asking the user for help. This option is also used
 # when generating formulas in HTML.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_BATCHMODE        = NO
 
 # If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
 # index chapters (such as File Index, Compound Index, etc.) in the output.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_HIDE_INDICES     = NO
 
 # If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
 # code with syntax highlighting in the LaTeX output.
 #
 # Note that which sources are shown also depends on other settings such as
 # SOURCE_BROWSER.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_SOURCE_CODE      = NO
 
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. See
 # http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
 # The default value is: plain.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_BIB_STYLE        = plain
 
 #---------------------------------------------------------------------------
 # Configuration options related to the RTF output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
 # RTF output is optimized for Word 97 and may not look too pretty with other RTF
 # readers/editors.
 # The default value is: NO.
 
 GENERATE_RTF           = NO
 
 # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
 # it.
 # The default directory is: rtf.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_OUTPUT             = rtf
 
 # If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
 # documents. This may be useful for small projects and may help to save some
 # trees in general.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
 COMPACT_RTF            = NO
 
 # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
 # contain hyperlink fields. The RTF file will contain links (just like the HTML
 # output) instead of page references. This makes the output suitable for online
 # browsing using Word or some other Word compatible readers that support those
 # fields.
 #
 # Note: WordPad (write) and others do not support links.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_HYPERLINKS         = NO
 
 # Load stylesheet definitions from file. Syntax is similar to doxygen's config
 # file, i.e. a series of assignments. You only have to provide replacements,
 # missing definitions are set to their default value.
 #
 # See also section "Doxygen usage" for information on how to generate the
 # default style sheet that doxygen normally uses.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_STYLESHEET_FILE    =
 
 # Set optional variables used in the generation of an RTF document. Syntax is
 # similar to doxygen's config file. A template extensions file can be generated
 # using doxygen -e rtf extensionFile.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_EXTENSIONS_FILE    =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the man page output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
 # classes and files.
 # The default value is: NO.
 
 GENERATE_MAN           = NO
 
 # The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
 # it. A directory man3 will be created inside the directory specified by
 # MAN_OUTPUT.
 # The default directory is: man.
 # This tag requires that the tag GENERATE_MAN is set to YES.
 
 MAN_OUTPUT             = man
 
 # The MAN_EXTENSION tag determines the extension that is added to the generated
 # man pages. In case the manual section does not start with a number, the number
 # 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
 # optional.
 # The default value is: .3.
 # This tag requires that the tag GENERATE_MAN is set to YES.
 
 MAN_EXTENSION          = .3
 
 # The MAN_SUBDIR tag determines the name of the directory created within
 # MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
 # MAN_EXTENSION with the initial . removed.
 # This tag requires that the tag GENERATE_MAN is set to YES.
 
 MAN_SUBDIR             =
 
 # If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
 # will generate one additional man file for each entity documented in the real
 # man page(s). These additional files only source the real man page, but without
 # them the man command would be unable to find the correct page.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_MAN is set to YES.
 
 MAN_LINKS              = NO
 
 #---------------------------------------------------------------------------
 # Configuration options related to the XML output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
 # captures the structure of the code including all documentation.
 # The default value is: NO.
 
 GENERATE_XML           = NO
 
 # The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
 # it.
 # The default directory is: xml.
 # This tag requires that the tag GENERATE_XML is set to YES.
 
 XML_OUTPUT             = xml
 
 # If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
 # listings (including syntax highlighting and cross-referencing information) to
 # the XML output. Note that enabling this will significantly increase the size
 # of the XML output.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_XML is set to YES.
 
 XML_PROGRAMLISTING     = YES
 
 #---------------------------------------------------------------------------
 # Configuration options related to the DOCBOOK output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
 # that can be used to generate PDF.
 # The default value is: NO.
 
 GENERATE_DOCBOOK       = NO
 
 # The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
 # front of it.
 # The default directory is: docbook.
 # This tag requires that the tag GENERATE_DOCBOOK is set to YES.
 
 DOCBOOK_OUTPUT         = docbook
 
 # If the DOCBOOK_PROGRAMLISTING tag is set to YES doxygen will include the
 # program listings (including syntax highlighting and cross-referencing
 # information) to the DOCBOOK output. Note that enabling this will significantly
 # increase the size of the DOCBOOK output.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_DOCBOOK is set to YES.
 
 DOCBOOK_PROGRAMLISTING = NO
 
 #---------------------------------------------------------------------------
 # Configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
 # Definitions (see http://autogen.sf.net) file that captures the structure of
 # the code including all documentation. Note that this feature is still
 # experimental and incomplete at the moment.
 # The default value is: NO.
 
 GENERATE_AUTOGEN_DEF   = NO
 
 #---------------------------------------------------------------------------
 # Configuration options related to the Perl module output
 #---------------------------------------------------------------------------
 
 # If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
 # file that captures the structure of the code including all documentation.
 #
 # Note that this feature is still experimental and incomplete at the moment.
 # The default value is: NO.
 
 GENERATE_PERLMOD       = NO
 
 # If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
 # Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
 # output from the Perl module output.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
 
 PERLMOD_LATEX          = NO
 
 # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
 # formatted so it can be parsed by a human reader. This is useful if you want to
 # understand what is going on. On the other hand, if this tag is set to NO the
 # size of the Perl module output will be much smaller and Perl will parse it
 # just the same.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
 
 PERLMOD_PRETTY         = YES
 
 # The names of the make variables in the generated doxyrules.make file are
 # prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
 # so different doxyrules.make files included by the same Makefile don't
 # overwrite each other's variables.
 # This tag requires that the tag GENERATE_PERLMOD is set to YES.
 
 PERLMOD_MAKEVAR_PREFIX =
 
 #---------------------------------------------------------------------------
 # Configuration options related to the preprocessor
 #---------------------------------------------------------------------------
 
 # If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
 # C-preprocessor directives found in the sources and include files.
 # The default value is: YES.
 
 ENABLE_PREPROCESSING   = YES
 
 # If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
 # in the source code. If set to NO only conditional compilation will be
 # performed. Macro expansion can be done in a controlled way by setting
 # EXPAND_ONLY_PREDEF to YES.
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 MACRO_EXPANSION        = YES
 
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
 # the macro expansion is limited to the macros specified with the PREDEFINED and
 # EXPAND_AS_DEFINED tags.
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 EXPAND_ONLY_PREDEF     = NO
 
 # If the SEARCH_INCLUDES tag is set to YES the includes files in the
 # INCLUDE_PATH will be searched if a #include is found.
 # The default value is: YES.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 SEARCH_INCLUDES        = YES
 
 # The INCLUDE_PATH tag can be used to specify one or more directories that
 # contain include files that are not input files but should be processed by the
 # preprocessor.
 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
 
 INCLUDE_PATH           =
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the
 # directories. If left blank, the patterns specified with FILE_PATTERNS will be
 # used.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 INCLUDE_FILE_PATTERNS  =
 
 # The PREDEFINED tag can be used to specify one or more macro names that are
 # defined before the preprocessor is started (similar to the -D option of e.g.
 # gcc). The argument of the tag is a list of macros of the form: name or
 # name=definition (no spaces). If the definition and the "=" are omitted, "=1"
 # is assumed. To prevent a macro definition from being undefined via #undef or
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 PREDEFINED             = itkNotUsed(x)= \
                          "itkSetMacro(name,type)=virtual void Set##name (type _arg);" \
                          "itkGetMacro(name,type)=virtual type Get##name ();" \
                          "itkGetConstMacro(name,type)=virtual type Get##name () const;" \
                          "itkSetStringMacro(name)=virtual void Set##name (const char* _arg);" \
                          "itkGetStringMacro(name)=virtual const char* Get##name () const;" \
                          "itkSetClampMacro(name,type,min,max)=virtual void Set##name (type _arg);" \
                          "itkSetObjectMacro(name,type)=virtual void Set##name (type* _arg);" \
                          "itkGetObjectMacro(name,type)=virtual type* Get##name ();" \
                          "itkSetConstObjectMacro(name,type)=virtual void Set##name ( const type* _arg);" \
                          "itkGetConstObjectMacro(name,type)=virtual const type* Get##name ();" \
                          "itkGetConstReferenceMacro(name,type)=virtual const type& Get##name ();" \
                          "itkGetConstReferenceObjectMacro(name,type)=virtual const type::Pointer& Get##name () const;" \
                          "itkBooleanMacro(name)=virtual void name##On (); virtual void name##Off ();" \
                          "itkSetVector2Macro(name,type)=virtual void Set##name (type _arg1, type _arg2) virtual void Set##name (type _arg[2]);" \
                          "itkGetVector2Macro(name,type)=virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2) const; virtual void Get##name (type _arg[2]) const;" \
                          "itkSetVector3Macro(name,type)=virtual void Set##name (type _arg1, type _arg2, type _arg3) virtual void Set##name (type _arg[3]);" \
                          "itkGetVector3Macro(name,type)=virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3) const; virtual void Get##name (type _arg[3]) const;" \
                          "itkSetVector4Macro(name,type)=virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4) virtual void Set##name (type _arg[4]);" \
                          "itkGetVector4Macro(name,type)=virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4) const; virtual void Get##name (type _arg[4]) const;" \
                          "itkSetVector6Macro(name,type)=virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4, type _arg5, type _arg6) virtual void Set##name (type _arg[6]);" \
                          "itkGetVector6Macro(name,type)=virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4, type& _arg5, type& _arg6) const; virtual void Get##name (type _arg[6]) const;" \
                          "itkSetVectorMacro(name,type,count)=virtual void Set##name(type data[]);" \
                          "itkGetVectorMacro(name,type,count)=virtual type* Get##name () const;" \
                          "itkNewMacro(type)=static Pointer New();" \
                          "itkFactorylessNewMacro(type)=static Pointer New();" \
                          "itkCloneMacro(type)=Pointer Clone() const;" \
                          "itkTypeMacro(thisClass,superclass)=virtual const char *GetClassName() const;" \
                          "itkConceptMacro(name,concept)=enum { name = 0 };" \
                          "ITK_NUMERIC_LIMITS=std::numeric_limits" \
                          "ITK_TYPENAME=typename" \
                          "FEM_ABSTRACT_CLASS(thisClass,parentClass)=public: /** Standard Self typedef.*/ typedef thisClass Self; /** Standard Superclass typedef. */ typedef parentClass Superclass; /** Pointer or SmartPointer to an object. */ typedef Self* Pointer; /** Const pointer or SmartPointer to an object. */ typedef const Self* ConstPointer; private:" \
                          "FEM_CLASS(thisClass,parentClass)=FEM_ABSTRACT_CLASS(thisClass,parentClass) public: /** Create a new object from the existing one  */ virtual Baseclass::Pointer Clone() const; /** Class ID for FEM object factory */ static const int CLID; /** Virtual function to access the class ID */ virtual int ClassID() const { return CLID; /** Object creation in an itk compatible way */ static Self::Pointer New() { return new Self(); } private:" \
                          FREEVERSION \
                          ERROR_CHECKING \
                          HAS_TIFF \
                          HAS_JPEG \
                          HAS_NETLIB \
                          HAS_PNG \
                          HAS_ZLIB \
                          HAS_GLUT \
                          HAS_QT \
                          VCL_USE_NATIVE_STL=1 \
                          VCL_USE_NATIVE_COMPLEX=1 \
                          VCL_HAS_BOOL=1 \
                          VXL_BIG_ENDIAN=1 \
                          VXL_LITTLE_ENDIAN=0 \
                          VNL_DLL_DATA= \
                          size_t=vcl_size_t \
                          "US_PREPEND_NAMESPACE(x)=us::x" \
                          "US_BEGIN_NAMESPACE= namespace us {" \
                          "US_END_NAMESPACE=}" \
                          "US_BASECLASS_NAME=itk::LightObject" \
                          US_EXPORT= \
                          "DEPRECATED(func)=func" \
                          @US_PLATFORM@
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The
 # macro definition that is found in the sources will be used. Use the PREDEFINED
 # tag if you want to use a different macro definition that overrules the
 # definition found in the source code.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 EXPAND_AS_DEFINED      =
 
 # If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
 # remove all references to function-like macros that are alone on a line, have
 # an all uppercase name, and do not end with a semicolon. Such function macros
 # are typically used for boiler-plate code, and will confuse the parser if not
 # removed.
 # The default value is: YES.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 SKIP_FUNCTION_MACROS   = YES
 
 #---------------------------------------------------------------------------
 # Configuration options related to external references
 #---------------------------------------------------------------------------
 
 # The TAGFILES tag can be used to specify one or more tag files. For each tag
 # file the location of the external documentation should be added. The format of
 # a tag file without this location is as follows:
 # TAGFILES = file1 file2 ...
 # Adding location for the tag files is done as follows:
 # TAGFILES = file1=loc1 "file2 = loc2" ...
 # where loc1 and loc2 can be relative or absolute paths or URLs. See the
 # section "Linking to external documentation" for more information about the use
 # of tag files.
 # Note: Each tag file must have a unique name (where the name does NOT include
 # the path). If a tag file is not located in the directory in which doxygen is
 # run, you must also specify the path to the tagfile here.
 
 TAGFILES               =
 
 # When a file name is specified after GENERATE_TAGFILE, doxygen will create a
 # tag file that is based on the input files it reads. See section "Linking to
 # external documentation" for more information about the usage of tag files.
 
 GENERATE_TAGFILE       = @MITK_DOXYGEN_TAGFILE_NAME@
 
 # If the ALLEXTERNALS tag is set to YES all external class will be listed in the
 # class index. If set to NO only the inherited external classes will be listed.
 # The default value is: NO.
 
 ALLEXTERNALS           = NO
 
 # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
 # the modules index. If set to NO, only the current project's groups will be
 # listed.
 # The default value is: YES.
 
 EXTERNAL_GROUPS        = NO
 
 # If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
 # the related pages index. If set to NO, only the current project's pages will
 # be listed.
 # The default value is: YES.
 
 EXTERNAL_PAGES         = YES
 
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
 # If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
 # (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
 # NO turns the diagrams off. Note that this option also works with HAVE_DOT
 # disabled, but it is recommended to install and use dot, since it yields more
 # powerful graphs.
 # The default value is: YES.
 
 CLASS_DIAGRAMS         = YES
 
 # You can include diagrams made with dia in doxygen documentation. Doxygen will
 # then run dia to produce the diagram and insert it in the documentation. The
 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
 # If left empty dia is assumed to be found in the default search path.
 
 DIA_PATH               =
 
 # If set to YES, the inheritance and collaboration graphs will hide inheritance
 # and usage relations if the target is undocumented or is not a class.
 # The default value is: YES.
 
 HIDE_UNDOC_RELATIONS   = YES
 
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz (see:
 # http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
 # Bell Labs. The other options in this section have no effect if this option is
 # set to NO
 # The default value is: NO.
 
 HAVE_DOT               = @HAVE_DOT@
 
 # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
 # to run in parallel. When set to 0 doxygen will base this on the number of
 # processors available in the system. You can set it explicitly to a value
 # larger than 0 to get control over the balance between CPU load and processing
 # speed.
 # Minimum value: 0, maximum value: 32, default value: 0.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_NUM_THREADS        = @MITK_DOXYGEN_DOT_NUM_THREADS@
 
 # When you want a differently looking font in the dot files that doxygen
 # generates you can specify the font name using DOT_FONTNAME. You need to make
 # sure dot is able to find the font, which can be done by putting it in a
 # standard location or by setting the DOTFONTPATH environment variable or by
 # setting DOT_FONTPATH to the directory containing the font.
 # The default value is: Helvetica.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_FONTNAME           = Helvetica
 
 # The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
 # dot graphs.
 # Minimum value: 4, maximum value: 24, default value: 10.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_FONTSIZE           = 10
 
 # By default doxygen will tell dot to use the default font as specified with
 # DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
 # the path where dot can find it using this tag.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_FONTPATH           =
 
 # If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
 # each documented class showing the direct and indirect inheritance relations.
 # Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 CLASS_GRAPH            = YES
 
 # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
 # graph for each documented class showing the direct and indirect implementation
 # dependencies (inheritance, containment, and class references variables) of the
 # class with other documented classes.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 COLLABORATION_GRAPH    = YES
 
 # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
 # groups, showing the direct groups dependencies.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 GROUP_GRAPHS           = YES
 
 # If the UML_LOOK tag is set to YES doxygen will generate inheritance and
 # collaboration diagrams in a style similar to the OMG's Unified Modeling
 # Language.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 UML_LOOK               = @MITK_DOXYGEN_UML_LOOK@
 
 # If the UML_LOOK tag is enabled, the fields and methods are shown inside the
 # class node. If there are many fields or methods and many nodes the graph may
 # become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
 # number of items for each type to make the size more manageable. Set this to 0
 # for no limit. Note that the threshold may be exceeded by 50% before the limit
 # is enforced. So when you set the threshold to 10, up to 15 fields may appear,
 # but if the number exceeds 15, the total amount of fields shown is limited to
 # 10.
 # Minimum value: 0, maximum value: 100, default value: 10.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
 # collaboration graphs will show the relations between templates and their
 # instances.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 TEMPLATE_RELATIONS     = YES
 
 # If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
 # YES then doxygen will generate a graph for each documented file showing the
 # direct and indirect include dependencies of the file with other documented
 # files.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 INCLUDE_GRAPH          = NO
 
 # If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
 # set to YES then doxygen will generate a graph for each documented file showing
 # the direct and indirect include dependencies of the file with other documented
 # files.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 INCLUDED_BY_GRAPH      = NO
 
 # If the CALL_GRAPH tag is set to YES then doxygen will generate a call
 # dependency graph for every global function or class method.
 #
 # Note that enabling this option will significantly increase the time of a run.
 # So in most cases it will be better to enable call graphs for selected
 # functions only using the \callgraph command.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 CALL_GRAPH             = NO
 
 # If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
 # dependency graph for every global function or class method.
 #
 # Note that enabling this option will significantly increase the time of a run.
 # So in most cases it will be better to enable caller graphs for selected
 # functions only using the \callergraph command.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 CALLER_GRAPH           = NO
 
 # If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
 # hierarchy of all classes instead of a textual one.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 GRAPHICAL_HIERARCHY    = NO
 
 # If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
 # dependencies a directory has on other directories in a graphical way. The
 # dependency relations are determined by the #include relations between the
 # files in the directories.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DIRECTORY_GRAPH        = YES
 
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot.
 # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
 # to make the SVG files visible in IE 9+ (other browsers do not have this
 # requirement).
 # Possible values are: png, jpg, gif and svg.
 # The default value is: png.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_IMAGE_FORMAT       = png
 
 # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
 # enable generation of interactive SVG images that allow zooming and panning.
 #
 # Note that this requires a modern browser other than Internet Explorer. Tested
 # and working are Firefox, Chrome, Safari, and Opera.
 # Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
 # the SVG files visible. Older versions of IE do not have SVG support.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 INTERACTIVE_SVG        = NO
 
 # The DOT_PATH tag can be used to specify the path where the dot tool can be
 # found. If left blank, it is assumed the dot tool can be found in the path.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_PATH               = "@DOXYGEN_DOT_PATH@"
 
 # The DOTFILE_DIRS tag can be used to specify one or more directories that
 # contain dot files that are included in the documentation (see the \dotfile
 # command).
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOTFILE_DIRS           =
 
 # The MSCFILE_DIRS tag can be used to specify one or more directories that
 # contain msc files that are included in the documentation (see the \mscfile
 # command).
 
 MSCFILE_DIRS           =
 
 # The DIAFILE_DIRS tag can be used to specify one or more directories that
 # contain dia files that are included in the documentation (see the \diafile
 # command).
 
 DIAFILE_DIRS           =
 
 # When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
 # path where java can find the plantuml.jar file. If left blank, it is assumed
 # PlantUML is not used or called during a preprocessing step. Doxygen will
 # generate a warning when it encounters a \startuml command in this case and
 # will not generate output for the diagram.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 PLANTUML_JAR_PATH      =
 
 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
 # that will be shown in the graph. If the number of nodes in a graph becomes
 # larger than this value, doxygen will truncate the graph, which is visualized
 # by representing a node as a red box. Note that doxygen if the number of direct
 # children of the root node in a graph is already larger than
 # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
 # the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
 # Minimum value: 0, maximum value: 10000, default value: 50.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_GRAPH_MAX_NODES    = 50
 
 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
 # generated by dot. A depth value of 3 means that only nodes reachable from the
 # root by following a path via at most 3 edges will be shown. Nodes that lay
 # further from the root node will be omitted. Note that setting this option to 1
 # or 2 may greatly reduce the computation time needed for large code bases. Also
 # note that the size of a graph can be further restricted by
 # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
 # Minimum value: 0, maximum value: 1000, default value: 0.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 MAX_DOT_GRAPH_DEPTH    = 0
 
 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
 # background. This is disabled by default, because dot on Windows does not seem
 # to support this out of the box.
 #
 # Warning: Depending on the platform used, enabling this option may lead to
 # badly anti-aliased labels on the edges of a graph (i.e. they become hard to
 # read).
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_TRANSPARENT        = NO
 
 # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10) support
 # this, this feature is disabled by default.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_MULTI_TARGETS      = NO
 
 # If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
 # explaining the meaning of the various boxes and arrows in the dot generated
 # graphs.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 GENERATE_LEGEND        = YES
 
 # If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
 # files that are used to generate the various graphs.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_CLEANUP            = YES
diff --git a/Documentation/mitk_doxygen_extra.css b/Documentation/mitk_doxygen_extra.css
index dd1235b00c..2e2cef5271 100644
--- a/Documentation/mitk_doxygen_extra.css
+++ b/Documentation/mitk_doxygen_extra.css
@@ -1,203 +1,140 @@
 /* Main Doxygen CSS overrides */
 
 @import url(http://fonts.googleapis.com/css?family=Open+Sans);
 
 body, table, div, p, dl {
   font-family: 'Open Sans', Lucida Grande, Verdana, Geneva, Arial, sans-serif;
 }
 
 a {
   color: #2d5c88;
 }
 
 #top {
   border-bottom: 1px solid #e1e1e1;
 }
 
 .navpath ul {
   background-image:none;
   color:#dddddd;
 }
 
 .navpath li.navelem a {
   color: inherit;
   font-family: inherit;
   text-shadow: none;
 }
 
 #projectname {
   visibility: hidden;
   height: 70px;
   margin-left: -520px;
 }
 
 #projectbrief {
   display: none;
 }
 
 #projectnumber {
   font: inherit;
   visibility: visible;
   font-size: 12px;
   position: relative;
   top: 17px;
   left: 80px;
 }
 
 #titlearea table tbody>tr:first-child>td:first-child {
   background: url(mitkLogo.jpg) 0 0 no-repeat;
   padding-right: 15px;
 }
 
 /* Doxygen navtree.css overrides */
 
 #nav-tree .label {
   font: inherit;
 }
 
 #nav-tree {
   background-color: inherit;
 }
 
 #nav-tree {
   background-image:none;
   background-color: inherit;
 }
 
 /* Doxygen tabs.css overrides */
 
 .tabs, .tabs2, .tabs3 {
   background-image: none;
   font-family: inherit;
 }
 
 .tabs2 {
   font-size: 12px;
 }
 
 .tablist {
   margin: 0 auto;
 }
 
 .tablist li {
   background-image: none;
 }
 
 .tablist a {
   background-image:none;
   color: #808080;
   transition:all .3s ease-out;
   border-bottom:2px solid transparent;
 }
 
 .tablist a:hover {
   background-image:none;
   text-shadow: none;
   color: #333333;
   border-bottom: 2px solid #2d5c88;
 }
 
 .tablist li.current a {
   background-image:none;
   text-shadow: none;
   color: #333333;
   border-bottom: 2px solid #2d5c88;
 }
 
 /* Search field */
 
 #MSearchBox .left {
   border-style: solid none solid solid;
   border-width: 1px;
   background: none;
   border-color: #000000;
 }
 
 #MSearchField {
   margin-top: -1px;
   border-style: solid none;
   border-width: 1px;
   border-color: #000000;
   background: none;
   padding-top: 0px;
   padding-bottom: 0px;
 }
 
 #MSearchBox .right {
   border-style: solid solid solid none;
   border-width: 1px;
   background: none;
   border-color: #000000;
 }
 
 #MSearchResultsWindow {
   background-color: #ffffff;
 }
 
 #MSearchSelectWindow {
   border-color: #000000;
   background-color: #ffffff;
 }
-
-/* CSS for the generated extension point documentation, copied from schema.css */
-
-H6.SchemaHeader {
-  font-size:16px;
-  display:inline
-}
-
-P.SchemaCopyright {
-  font-size: smaller;
-  font-style: normal;
-  color: #336699;
-  display:inline;
-  margin-top: 3.000000pt;
-  margin-bottom: 11.000000pt;
-  margin-right: 0.000000pt;
-  margin-left: 0.000000pt;
-}
-
-P.SchemaDtd {
-  color: #800000;
-  margin-top: 0.000000pt;
-  margin-bottom: 0.000000pt;
-  margin-right: 0.000000pt;
-  margin-left: 10.000000pt;
-}
-
-P.SchemaDtdAttlist {
-  color: #800000;
-  margin-top: 0.000000pt;
-  margin-bottom: 0.000000pt;
-  margin-right: 0.000000pt;
-  margin-left: 20.000000pt;
-}
-
-span.SchemaTag {
-  color: #000080;
-}
-
-span.SchemaCstring {
-  color: #008000;
-}
-
-pre.Example {
-  margin-top: 0.000000pt;
-}
-
-.ConfigMarkupElementDesc {
-  color: black;
-  margin-top: 0.000000pt;
-  margin-bottom: 0.000000pt;
-  margin-right: 0.000000pt;
-  margin-left: 10.000000pt;
-}
-
-.ConfigMarkupAttlistDesc {
-  color: black;
-  margin-top: 0.000000pt;
-  margin-bottom: 0.000000pt;
-  margin-right: 0.000000pt;
-  margin-left: 32.000000pt;
-}
-
diff --git a/Documentation/schema.css b/Documentation/schema.css
deleted file mode 100644
index fb2028d7b6..0000000000
--- a/Documentation/schema.css
+++ /dev/null
@@ -1,71 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2003 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-
-H6.SchemaHeader {
-	font-size:16px; 
-	display:inline
-}
-
-P.SchemaCopyright {
-	font-size: smaller; 
-	font-style: normal;
-	color: #336699; 
-	display:inline;
-	margin-top: 3.000000pt;
-	margin-bottom: 11.000000pt;
-	margin-right: 0.000000pt;
-	margin-left: 0.000000pt;
-}
-
-P.SchemaDtd {
-	color: #800000; 
-	margin-top: 0.000000pt;
-	margin-bottom: 0.000000pt;
-	margin-right: 0.000000pt;
-	margin-left: 10.000000pt;
-}
-
-P.SchemaDtdAttlist {
-	color: #800000; 
-	margin-top: 0.000000pt;
-	margin-bottom: 0.000000pt;
-	margin-right: 0.000000pt;
-	margin-left: 20.000000pt;
-}
-
-span.SchemaTag {
-	color: #000080;
-}
-
-span.SchemaCstring {
-	color: #008000;
-}
-
-pre.Example {
-	margin-top: 0.000000pt;
-}
-
-.ConfigMarkupElementDesc {
-	color: black;
-	margin-top: 0.000000pt;
-	margin-bottom: 0.000000pt;
-	margin-right: 0.000000pt;
-	margin-left: 10.000000pt;
-}
-
-.ConfigMarkupAttlistDesc {
-	color: black;
-	margin-top: 0.000000pt;
-	margin-bottom: 0.000000pt;
-	margin-right: 0.000000pt;
-	margin-left: 32.000000pt;
-}
-
diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/DicomView.cpp b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/DicomView.cpp
index dc1420cf5a..9f644721bb 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/DicomView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/DicomView.cpp
@@ -1,103 +1,105 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "DicomView.h"
 
 #include "org_mitk_example_gui_customviewer_views_Activator.h"
 
 #include "mitkIOUtil.h"
 #include "mitkIDataStorageService.h"
 #include "mitkImage.h"
 
 #include <berryIWorkbench.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIWorkbenchWindow.h>
 
 #include "QDockWidget"
 
 const std::string DicomView::VIEW_ID = "org.mitk.customviewer.views.dicomview";
 
 DicomView::DicomView() : m_Parent(nullptr)
 {
 }
 
 DicomView::~DicomView()
 {
 }
 
 // //! [DicomViewCreatePartControl]
 void DicomView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets
   m_Parent = parent;
   m_Controls.setupUi(parent);
 
   // remove unused widgets
   QPushButton *downloadButton = parent->findChild<QPushButton *>("downloadButton");
   downloadButton->setVisible(false);
 
   connect(m_Controls.importButton, SIGNAL(clicked()), m_Controls.widget, SLOT(OnFolderCDImport()));
   connect(m_Controls.widget,
           SIGNAL(SignalDicomToDataManager(const QHash<QString, QVariant> &)),
           this,
           SLOT(AddDataNodeFromDICOM(const QHash<QString, QVariant> &)));
 
   m_Parent->setEnabled(true);
 }
 // //! [DicomViewCreatePartControl]
 
 // //! [DicomViewCreateAddDataNodeInformation]
 void DicomView::AddDataNodeFromDICOM(QHash<QString, QVariant> eventProperties)
 {
   QStringList listOfFilesForSeries;
   std::vector<std::string> seriesToLoad;
 
   listOfFilesForSeries = eventProperties["FilesForSeries"].toStringList();
 
   if (!listOfFilesForSeries.isEmpty())
   {
     QStringListIterator it(listOfFilesForSeries);
 
     while (it.hasNext())
     {
       seriesToLoad.push_back(it.next().toStdString());
     }
 
     auto results = mitk::IOUtil::Load(seriesToLoad, *(this->GetDataStorage().GetPointer()));
 
     if (results->empty())
     {
       MITK_ERROR << "Error loading Dicom series";
     }
     // //! [DicomViewCreateAddDataNodeLoadSeries]
     else
     {
       // //! [DicomViewCreateAddDataNode]
       mitk::DataStorage::Pointer ds = this->GetDataStorage();
       // //! [DicomViewCreateAddDataNode]
       mitk::RenderingManager::GetInstance()->SetDataStorage(ds);
       auto geometry = ds->ComputeBoundingGeometry3D(ds->GetAll());
       mitk::RenderingManager::GetInstance()->InitializeViews(geometry);
 
       // //! [DicomViewCreateAddDataNodeActivatePersp]
       berry::IWorkbenchWindow::Pointer window = this->GetSite()->GetWorkbenchWindow();
       QString perspectiveId = "org.mitk.example.viewerperspective";
       window->GetWorkbench()->ShowPerspective(perspectiveId, berry::IWorkbenchWindow::Pointer(window));
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
       // //! [DicomViewCreateAddDataNodeActivatePersp]
     }
+    // //! [DicomViewCreateAddDataNodeLoadSeries]
   }
 }
+// //! [DicomViewCreateAddDataNodeInformation]
 
 void DicomView::SetFocus()
 {
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/documentation/doxygen/ExampleExtensionPoint.dox b/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/documentation/doxygen/ExampleExtensionPoint.dox
index f1f8a1a109..f701c5ba4a 100644
--- a/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/documentation/doxygen/ExampleExtensionPoint.dox
+++ b/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/documentation/doxygen/ExampleExtensionPoint.dox
@@ -1,55 +1,55 @@
 /**
 
 \page ExtensionPointDefinition Extension Point Definition
 
   This example plugin defines an extension point and collects extensions.
   \image html ExtensionPointWithoutExtension.png
 
   In this example the extension point concept is used to define an extension point and extend the plugin functionality with it. The GUI consists of a view with two group boxes. In the right box the user can insert text in an input text field. The left box is the area where extensions for this plugin are displayed.
 
   In the plugin.xml file of this application the extension point is defined as follows:
   \image html DefinitionXML.png
 
   The according schema (\github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/schema/changetext.exsd,changetext.exsd}) defines attributes for extensions of this extension point like a description.
 
   In the view of this plugin the registry is used to find all available extensions. For each found descriptor a push button is created that holds the functionality extension.
   \snippet MinimalView.cpp Collect extensions through registry
 
   These created push buttons are connected to the ChangeText method that alters the input text (in the way the extension defines) and outputs the changed text in another text field.
   \snippet MinimalView.cpp Use extended functionality to alter input text
 
   The plugin can now be extened by extensions provided by other plugins.
 
   View complete source files:
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/src/internal/ChangeTextDescriptor.cpp,ChangeTextDescriptor.cpp}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/src/internal/ChangeTextDescriptor.h,ChangeTextDescriptor.h}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/src/internal/ChangeTextRegistry.cpp,ChangeTextRegistry.cpp}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/src/internal/ChangeTextRegistry.h,ChangeTextRegistry.h}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/src/internal/ExtensionPointDefinition.cpp,ExtensionPointDefinition.cpp}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/src/internal/ExtensionPointDefinition.h,ExtensionPointDefinition.h}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/src/internal/ExtensionPointDefinitionConstants.cpp,ExtensionPointDefinitionConstants.cpp}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/src/internal/ExtensionPointDefinitionConstants.h,ExtensionPointDefinitionConstants.h}
 
 [\ref BlueBerryExampleExtensionPoint] [Next: \ref ExtensionContribution] [\ref BlueBerryExamples]
 
 \page ExtensionContribution Extension Contribution
 
   This example plugin holds no GUI. It just extends the Extension Point Definition plugin.
   \image html ExtensionPointWithExtension.png
 
   Through the extension of the Extension Point Definition plugin two functionalities are added by implementing the minimal IChangeText interface of the plugin.
 
   In the plugin.xml file of the plugin the extensions are defined as follows:
   \image html ContributionXML.png
-  The extension point ID in the plugin.xml matches the ID of the extension point and is therefore found by the registry as a valid extension. A description is given for each extension although the schema for the extension point allows an extension without a description (<element ref="description" minOccurs="0" maxOccurs="1"/>).
+  The extension point ID in the plugin.xml matches the ID of the extension point and is therefore found by the registry as a valid extension. A description is given for each extension although the schema for the extension point allows an extension without a description (\c \<element ref="description" minOccurs="0" maxOccurs="1"/\>).
 
   The GUI now holds two buttons that change the input text of the user to upper or lower case. This is done by two simple methods.
 
   View complete source files:
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointcontribution/src/internal/ChangeTextToLowerCase.cpp,ChangeTextToLowerCase.cpp}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointcontribution/src/internal/ChangeTextToLowerCase.h,ChangeTextToLowerCase.h}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointcontribution/src/internal/ChangeTextToUpperCase.cpp,ChangeTextToUpperCase.cpp}
   \li \github{Examples/Plugins/org.mitk.example.gui.extensionpointcontribution/src/internal/ChangeTextToUpperCase.h,ChangeTextToUpperCase.h}
 
 [\ref BlueBerryExampleExtensionPoint] [Previous: \ref ExtensionPointDefinition] [\ref BlueBerryExamples]
 */
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/ColorImageProcessing.png b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/ColorImageProcessing-dox.png
similarity index 100%
rename from Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/ColorImageProcessing.png
rename to Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/ColorImageProcessing-dox.png
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/QmitkColourImageProcessing.dox b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/QmitkColourImageProcessing.dox
index 284abac1eb..d8a5195d1b 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/QmitkColourImageProcessing.dox
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/QmitkColourImageProcessing.dox
@@ -1,34 +1,34 @@
 /**
 \page org_mitk_views_colourimageprocessing The Colour Image Processing Module
 
-\imageMacro{ColorImageProcessing.png,"Icon of the Colour Image Processing Module",2.00}
+\imageMacro{ColorImageProcessing-dox.png,"Icon of the Colour Image Processing Module",2.00}
 
 \section QmitkColourImageProcessingUserManualSummary Summary
 
 This module allows the user to create coloured images from medical images. Generally, these coloured images would be used in presentations, research papers, or as a teaching aide. 
 
 \section QmitkColourImageProcessingUserManualOverview Overview
 
 The purpose of this module is to create coloured images, which can then be later used in presentations, research papers, or anything else the user desires. Furthermore, different body sections can be assigned a different colour.
 These images are not particularly useful for further image processing, but provide nice, clear, diagrams. Please note that ultrasound images cannot be coloured.  
 
 
 
 \section QmitkColourImageProcessingUserManualFilters Creating Coloured Images
 Open an image in mitk, then click on the colour wheel button. Make sure the image you loaded is selected. 
 
   
 <H2>\ Image -> RGBAimage</H2>
 Clicking on this button creates an RGBA image from your medical image, which should appear in your data manager. 
 
 <H2>\ Image + mask -> RGBAimage</H2>
 Before clicking on this button, a mask is needed. A mask is generally created using the segmentation tool. Make sure both the mask and image are selected, then click on the image + mask -> RGBA image button. This creates an
 RGBA image that is coloured only in section defined by the mask. 
 
 <H2>\ Image + mask + color-> RGBAimage</H2>
 This functions the same way as the Image + mask -> RGBAimage. The difference is that the user can select the colour of the section represented by the mask. This is done by clicking on the colour next to the Image + mask + color-> RGBAimage button
 If multiple RGBA images are created with different colours, they can be combined into one image. Ensure that the desired coloured images are selected, then click on the combine RGBA images button. 
 
 
 
 */
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/QmitkSimpleExampleUserManual.dox b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/QmitkSimpleExampleUserManual.dox
index ad170db4e3..e3493b2926 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/QmitkSimpleExampleUserManual.dox
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/QmitkSimpleExampleUserManual.dox
@@ -1,20 +1,20 @@
 /**
 \page org_mitk_views_simpleexample The Simple Example module
 
-\imageMacro{SimpleExample.png,"Icon of the Simple Example Module",2.00}
+\imageMacro{SimpleExample-dox.png,"Icon of the Simple Example Module",2.00}
 
 \section QmitkSimpleExampleViewUserManualSummary Summary
 
 This module is namely a simple example for simple image interaction.
 It offers:
 <ul>
 <li>Sliders to navigate through the different slice stacks (Axial, Sagittal, Coronal) and the time steps
 <li>A "player" for image time series. It automatically steps through all time series with a speed defined by the slider on the right.
 <li>A button "Re-Initialize Navigators" to reinitialize those sliders to their initial position (Slice and time position 0)
 <li>A button "Take Screenshot" to take a screenshot of the chosen window (Axial, Sagittal, Coronal, 3D)
 <li>A button "Take HighDef 3D Screenshot" to take an high resolution screenshot of the 3D scene
 <li>A button "Generate Movie" whichs takes a movie of the chosen window by scrolling either through all slices (Axial, Sagittal, Coronal). Please use the MovieMaker view for recording a movie of a rotating 3D scene.
 <li>A selection box where the 3D view can be transformed into either a red-blue stereo or a D4D stereo view
 </ul>
 */
 
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/SimpleExample.png b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/SimpleExample-dox.png
similarity index 100%
rename from Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/SimpleExample.png
rename to Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/SimpleExample-dox.png
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox
index 73ff748694..43ce41c22d 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/org_mitk_gui_qt_viewinitialization.dox
@@ -1,8 +1,8 @@
 /**
 \page org_mitk_views_viewinitialitzation The View Initialization Module
 
-\imageMacro{viewInitializationIcon.png,"Icon of the View Initialization Module",2.00}
+\imageMacro{viewInitializationIcon-dox.png,"Icon of the View Initialization Module",2.00}
 
 This view serves as a sandbox for understanding and experimenting with the geometry initialization parameters. For example, to view the axial slices from above instead of from below. It is not intended for end users, but for developers.
 
 */
\ No newline at end of file
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/regiongrowing.xpm b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/regiongrowing.xpm
deleted file mode 100644
index 45304646ee..0000000000
--- a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/regiongrowing.xpm
+++ /dev/null
@@ -1,53 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"28 26 24 1",
-" 	c None",
-".	c #000000",
-"+	c #639A31",
-"@	c #316500",
-"#	c #6B9A31",
-"$	c #94CF63",
-"%	c #396500",
-"&	c #9CCB6B",
-"*	c #94CB63",
-"=	c #9CCB63",
-"-	c #6B9639",
-";	c #316900",
-">	c #949A94",
-",	c #9C969C",
-"'	c #6B656B",
-")	c #CECBCE",
-"!	c #9C9A9C",
-"~	c #393039",
-"{	c #313431",
-"]	c #C6CFC6",
-"^	c #636963",
-"/	c #636563",
-"(	c #9C6500",
-"_	c #946500",
-"                ..          ",
-"               .+@.         ",
-"              .#$%.         ",
-"              .&+.   ....   ",
-"              .+.   .+&*@.  ",
-"               .   .=$#+%.  ",
-"                   .$....   ",
-"                    .       ",
-"     ............           ",
-"   ..+*&=+&++-+++..         ",
-"  .=-;%;@%@%;@@%;-+.   ...  ",
-"  .+@@@@%;@;%;%;@@&+. .++-. ",
-"  .%@-+=&+-++#++-*#+.  .&+@.",
-"  .>>@;@;;@;#+%+;@;-.   .&%.",
-"  .,'))>!'>'=+%;'~{+.    .;.",
-"  .>!])'!^!{-+;//{{-@.    . ",
-"  .!'))>!'{~;&@'{/~+@.      ",
-" .(>>)]'>{{/'@/{'{{+%.      ",
-"._{{{{{{~{,'^'/'/{~@@.      ",
-" .(,>))/>/!//^'^{'{..       ",
-"  .>/])>,/>'/'/~^{{.        ",
-"  .!,>>'>'>/^/^'/~{./^      ",
-"  .{{!'!!'>''''/~{{.''//'/  ",
-"  /..{{~{{~{{{{{{../^^/'^'' ",
-"   ^/............'^/''^'//  ",
-"       /'^'/^'//^//'//      "};
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/viewInitializationIcon.png b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/viewInitializationIcon-dox.png
similarity index 100%
rename from Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/viewInitializationIcon.png
rename to Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/viewInitializationIcon-dox.png
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/viewInitializationIcon.xpm b/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/viewInitializationIcon.xpm
deleted file mode 100644
index 819882324c..0000000000
--- a/Examples/Plugins/org.mitk.example.gui.imaging/documentation/UserManual/viewInitializationIcon.xpm
+++ /dev/null
@@ -1,17 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"11 11 3 1",
-" 	c None",
-".	c #CBCBCB",
-"+	c #404040",
-"+++++++++++",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+..+...+..+",
-"+++++++++++",
-"+..+...+..+",
-"+++++++++++"};
diff --git a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/documentation/doxygen/MultiplePerspectives.dox b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/documentation/doxygen/MultiplePerspectives.dox
index 61c0eb9440..0fd2354c43 100644
--- a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/documentation/doxygen/MultiplePerspectives.dox
+++ b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/documentation/doxygen/MultiplePerspectives.dox
@@ -1,36 +1,36 @@
 /**
 
 \page BlueBerryExampleMultiplePerspectives Multiple perspectives and views
 
   \image html MultiplePerspectives.png
 
   The second example creates two perspectives. The first perspective has a visible editor area and uses a folder to bring the first view to the left side. The second perspective sets the editor area to invisible. The two views are filled with an empty QListWidget. The perspective bar is enabled.
 
   The visibility of the editor area is set in the corresponding perspective cpp file by:
-  \snippet MinimalPerspective.cpp Visibility of editor area
+  \snippet MinimumPerspective.cpp Visibility of editor area
 
   The visibility of the perspective bar is set in the applications MultiplePerspectives.cpp:
   \snippet MultiplePerspectives.cpp Visibility of perspective bar
 
   Here we can also set/change some other general preferences (e.g. the initial size):
   \snippet MultiplePerspectives.cpp initial window size
 
   The perspective bar:
   \image html Perspectivebar.png
 
   The icons of the perspectives are definded by the extension declaration in the plugin.xml
   of the example and lie in the resources directory of the plug-in:
   \include org.mitk.example.gui.multipleperspectives/plugin.xml
 
 
   View complete source files:
   \li \github{Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MultiplePerspectives.cpp,MultiplePerspectives.cpp}
   \li \github{Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MultiplePerspectives.h,MultiplePerspectives.h}
-  \li \github{Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimalPerspective.cpp,MinimalPerspective.cpp}
-  \li \github{Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimalPerspective.h,MinimalPerspective.h}
+  \li \github{Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimumPerspective.cpp,MinimumPerspective.cpp}
+  \li \github{Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimumPerspective.h,MinimumPerspective.h}
   \li \github{Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/ExtendedPerspective.cpp,ExtendedPerspective.cpp}
   \li \github{Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/ExtendedPerspective.h,ExtendedPerspective.h}
 
-\ref [\ref BlueBerryIntro] [Previous: \ref BlueBerryExampleMinimalApplication] [Next: \ref BlueBerrySelectionServiceIntro]
+  [\ref BlueBerryIntro] [Previous: \ref BlueBerryExampleMinimalApplication] [Next: \ref BlueBerrySelectionServiceIntro]
 
 */
diff --git a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/files.cmake b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/files.cmake
index 0b6c74c4c4..bafc5cf0f5 100644
--- a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/files.cmake
+++ b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/files.cmake
@@ -1,43 +1,43 @@
 set(SRC_CPP_FILES
 )
 
 set(INTERNAL_CPP_FILES
   org_mitk_example_gui_multipleperspectives_Activator.cpp
   MultiplePerspectives.cpp
-  MinimalPerspective.cpp
+  MinimumPerspective.cpp
   ExtendedPerspective.cpp
   EmptyView1.cpp
   EmptyView2.cpp
 )
 
 set(UI_FILES
   src/internal/EmptyView1Controls.ui
   src/internal/EmptyView2Controls.ui
 )
 
 set(MOC_H_FILES
   src/internal/org_mitk_example_gui_multipleperspectives_Activator.h
   src/internal/MultiplePerspectives.h
-  src/internal/MinimalPerspective.h
+  src/internal/MinimumPerspective.h
   src/internal/ExtendedPerspective.h
   src/internal/EmptyView1.h
   src/internal/EmptyView2.h
 )
 
 set(CACHED_RESOURCE_FILES
   plugin.xml
   resources/perspectiveIcon1.png
   resources/perspectiveIcon2.png
   resources/viewIcon1.png
   resources/viewIcon2.png
 )
 
 set(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/plugin.xml b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/plugin.xml
index fdd885a25b..a9789fc661 100644
--- a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/plugin.xml
+++ b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/plugin.xml
@@ -1,46 +1,46 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <plugin>
   <extension id="org.mitk.example.multipleperspectives" point="org.blueberry.osgi.applications">
     <application>
       <run class="MultiplePerspectives"/>
     </application>
   </extension>
 
   <extension point="org.blueberry.ui.perspectives">
     <perspective
       id="org.mitk.example.minimalperspective"
       name="Minimal Perspective 1"
       icon="resources/perspectiveIcon1.png"
-      class="MinimalPerspective">
+      class="MinimumPerspective">
     </perspective>
   </extension>
 
   <extension point="org.blueberry.ui.perspectives">
     <perspective
       id="org.mitk.example.extendedperspective"
       name="Minimal Perspective 2"
       icon="resources/perspectiveIcon2.png"
       class="ExtendedPerspective">
     </perspective>
   </extension>
 
 <extension point="org.blueberry.ui.views">
     <view
       id="org.mitk.views.emptyview1"
       name="Empty View 1"
       icon="resources/viewIcon1.png"
       class="EmptyView1">
     </view>
   </extension>
 
 <extension point="org.blueberry.ui.views">
     <view
       id="org.mitk.views.emptyview2"
       name="Empty View 2"
       icon="resources/viewIcon2.png"
       class="EmptyView2">
     </view>
   </extension>
 
 </plugin>
diff --git a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimalPerspective.cpp b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimumPerspective.cpp
similarity index 87%
rename from Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimalPerspective.cpp
rename to Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimumPerspective.cpp
index 45f8ea1c47..bac0c58abb 100644
--- a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimalPerspective.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimumPerspective.cpp
@@ -1,39 +1,39 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
-#include "MinimalPerspective.h"
+#include "MinimumPerspective.h"
 
 // berry includes
 #include "berryIViewLayout.h"
 
-MinimalPerspective::MinimalPerspective()
+MinimumPerspective::MinimumPerspective()
 {
 }
 
-void MinimalPerspective::CreateInitialLayout(berry::IPageLayout::Pointer layout)
+void MinimumPerspective::CreateInitialLayout(berry::IPageLayout::Pointer layout)
 {
   // Editors are placed for free.
   QString editorAreaId = layout->GetEditorArea();
 
   //! [Visibility of editor area]
   // set editor area to visible
   layout->SetEditorAreaVisible(true);
   //! [Visibility of editor area]
 
   // create folder with alignment "left"
   berry::IFolderLayout::Pointer left = layout->CreateFolder("left", berry::IPageLayout::LEFT, 0.5f, editorAreaId);
 
   // add emptyview1 to the folder
   left->AddView("org.mitk.views.emptyview1");
   // add emptyview2 to the folder
   left->AddView("org.mitk.views.emptyview2");
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimalPerspective.h b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimumPerspective.h
similarity index 77%
rename from Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimalPerspective.h
rename to Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimumPerspective.h
index aea5c70c7e..5689a2386b 100644
--- a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimalPerspective.h
+++ b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/MinimumPerspective.h
@@ -1,33 +1,33 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
-#ifndef MINIMALPERSPECTIVE_H_
-#define MINIMALPERSPECTIVE_H_
+#ifndef MINIMUMPERSPECTIVE_H_
+#define MINIMUMPERSPECTIVE_H_
 
 // berry includes
 #include <berryIPerspectiveFactory.h>
 
 // Qt includes
 #include <QObject>
 
-class MinimalPerspective : public QObject, public berry::IPerspectiveFactory
+class MinimumPerspective : public QObject, public berry::IPerspectiveFactory
 {
   Q_OBJECT
   Q_INTERFACES(berry::IPerspectiveFactory)
 
 public:
-  MinimalPerspective();
+  MinimumPerspective();
 
   void CreateInitialLayout(berry::IPageLayout::Pointer layout) override;
 };
 
-#endif /* MINIMALPERSPECTIVE_H_ */
+#endif /* MINIMUMPERSPECTIVE_H_ */
diff --git a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/org_mitk_example_gui_multipleperspectives_Activator.cpp b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/org_mitk_example_gui_multipleperspectives_Activator.cpp
index 0c92def3f6..95a588c67c 100644
--- a/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/org_mitk_example_gui_multipleperspectives_Activator.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.multipleperspectives/src/internal/org_mitk_example_gui_multipleperspectives_Activator.cpp
@@ -1,33 +1,33 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "org_mitk_example_gui_multipleperspectives_Activator.h"
 
 #include "EmptyView1.h"
 #include "EmptyView2.h"
 #include "ExtendedPerspective.h"
-#include "MinimalPerspective.h"
+#include "MinimumPerspective.h"
 #include "MultiplePerspectives.h"
 
 void org_mitk_example_gui_multipleperspectives_Activator::start(ctkPluginContext *context)
 {
   BERRY_REGISTER_EXTENSION_CLASS(MultiplePerspectives, context)
-  BERRY_REGISTER_EXTENSION_CLASS(MinimalPerspective, context)
+  BERRY_REGISTER_EXTENSION_CLASS(MinimumPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(ExtendedPerspective, context)
   BERRY_REGISTER_EXTENSION_CLASS(EmptyView1, context)
   BERRY_REGISTER_EXTENSION_CLASS(EmptyView2, context)
 }
 
 void org_mitk_example_gui_multipleperspectives_Activator::stop(ctkPluginContext *context)
 {
   Q_UNUSED(context)
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.opencv/documentation/UserManual/VideoPlayerUserManual.dox b/Examples/Plugins/org.mitk.example.gui.opencv/documentation/UserManual/VideoPlayerUserManual.dox
index dfd99dd8f2..9a7cdcfbb5 100644
--- a/Examples/Plugins/org.mitk.example.gui.opencv/documentation/UserManual/VideoPlayerUserManual.dox
+++ b/Examples/Plugins/org.mitk.example.gui.opencv/documentation/UserManual/VideoPlayerUserManual.dox
@@ -1,16 +1,16 @@
 /**
 \page org_videoplayer The Video Player Module
 
-\imageMacro{videoplayer.gif,"Icon of the Module",2.00}
+\imageMacro{videoplayer-dox.gif,"Icon of the Module",2.00}
 
 Available sections:
   - \ref QmitkVideoPlayerUserManualOverview 
 <!-- - \ref QmitkVideoPlayerUserManualFeatures -->
 <!--  - \ref QmitkVideoPlayerUserManualUsage  -->
 
 \section QmitkVideoPlayerUserManualOverview Overview
 
 VideoPlayer is a program module that allows to play video files or grab frames directly from a connected camera with an intuitive user interface. Its main purpose is to demonstrate the usage of the OpenCV toolkit in MITK.
 
 */
 
diff --git a/Examples/Plugins/org.mitk.example.gui.opencv/documentation/UserManual/videoplayer.gif b/Examples/Plugins/org.mitk.example.gui.opencv/documentation/UserManual/videoplayer-dox.gif
similarity index 100%
rename from Examples/Plugins/org.mitk.example.gui.opencv/documentation/UserManual/videoplayer.gif
rename to Examples/Plugins/org.mitk.example.gui.opencv/documentation/UserManual/videoplayer-dox.gif
diff --git a/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/UserManual/Manual.dox b/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/UserManual/Manual.dox
deleted file mode 100644
index d7db668df3..0000000000
--- a/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_mitk_example_gui_pcaexample The PCA example
-
-\imageMacro{icon.png,"Icon of Pcaexample",2.00}
-
-\tableofcontents
-
-\section org_mitk_example_gui_pcaexampleOverview Overview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/UserManual/icon.xpm b/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/doxygen/modules.dox b/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/doxygen/modules.dox
deleted file mode 100644
index 244d3df107..0000000000
--- a/Examples/Plugins/org.mitk.example.gui.pcaexample/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mitk_example_gui_pcaexample org.mitk.example.gui.pcaexample
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mitk_example_gui_pcaexample_internal Internal
-  \ingroup org_mitk_example_gui_pcaexample
-
-  \brief This subcategory includes the internal classes of the org.mitk.example.gui.pcaexample plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Modules/BasicImageProcessing/documentation/UserManual/mitkBasicImageProcessingMiniAppsPortalPage.dox b/Modules/BasicImageProcessing/documentation/UserManual/mitkBasicImageProcessingMiniAppsPortalPage.dox
index 93627d40be..822131b53a 100644
--- a/Modules/BasicImageProcessing/documentation/UserManual/mitkBasicImageProcessingMiniAppsPortalPage.dox
+++ b/Modules/BasicImageProcessing/documentation/UserManual/mitkBasicImageProcessingMiniAppsPortalPage.dox
@@ -1,45 +1,45 @@
 /**
 \page mitkBasicImageProcessingMiniAppsPortalPage MITK Basic Image Processing Mini Apps
 
 \tableofcontents
 
 The Basic Image Processing Mini Apps bundle the functionality that is commonly neeeded for the processing of medical images. As all other MiniApps, they follow the <a href="http://www.slicer.org/slicerWiki/index.php/Slicer3:Execution_Model_Documentation">Slicer Execution Model</a> in describing themselves via xml. You can simply obtain a description by calling the MiniApp without any parameter. If the MiniApp is calles with the option "--xml" a XML description of all possible parameter is added.
 
 \section bipmasec1 Description of Mini Apps
 
 \subsection bipmasub1 mitkFileConverter
 Allows to convert a file from one type to another file type, for example to convert an image, saved in the nifti format to an image saved in the .nrrd format. 
 
 \subsection bipmasub2 mitkForwardWavelet
-Calculates the forward wavelet transformation of an image. The output will consist of multiple images, which will be saved in the format <output>%id%<output-extension>, where <output> and <output-extension> are specified by the user and %id% is a consecutive number.
+Calculates the forward wavelet transformation of an image. The output will consist of multiple images, which will be saved in the format \<output\>%id%\<output-extension\>, where \<output\> and \<output-extension\> are specified by the user and %id% is a consecutive number.
 
 \subsection bipmasub3 mitkImageAndValueArithmetic
 Mathematical operations with two operants, the individual voxels of the image and a specified floating point value. By default, the floating point value is the right operand.
 
 \subsection bipmasub4 mitkImageTypeCovnerter
 Convert the data fromat that is used to save a voxel of an image. 
 
 \subsection bipmasub5 mitkLaplacianOfGaussian
 Calculate the Laplacian of Gaussian of an image with the specified sigma value.
 
 \subsection bipmasub6 mitkMaskOutlierFiltering
 Can be used to clean an segmentation. The mean and standard deviation of the intensities which are masked is calculated and then all mask voxels are removed that cover image voxels which are not within a 3 sigma range. 
 
 \subsection bipmasub7 mitkMaskRangeBasedFiltering
 Removing all voxels from a mask that cover image voxels which are outside of a given range. The range can be either specified by a lower limit, a upper limit, or both at the same time. 
 
 \subsection bipmasub8 mitkMultiResolutionPyramid
 Calculate a Multi-Resolution Pyramid of the given image. The resolution is reduced by factor 2 for each step. 
 
 \subsection bipmasub9 mitkResampleImage
 Resample a mask to a new spacing
 
 \subsection bipmasub10 mitkResampleMask
 Similar to mitkResampleImage, but specificly tailored to resampling a mask. 
 
 \subsection bipmasub11 mitkSingleImageArithmetic 
 Applies single operand mathematical operations to each voxel of an image
 
 \subsection bipmasub12 mitkTwoImageArithmetic 
 Applied two operand mathematical operations to each voxels of two images.
 */
diff --git a/Modules/Chart/documentation/mitkChart.dox b/Modules/Chart/documentation/mitkChart.dox
index af69c4dc5e..a1a7e98a13 100644
--- a/Modules/Chart/documentation/mitkChart.dox
+++ b/Modules/Chart/documentation/mitkChart.dox
@@ -1,256 +1,256 @@
 /**
 
 \page ChartModule Chart Module
 
 \tableofcontents
 
 \section ChartModule_brief Description
 The MITK chart module is able to show different types of charts in a widget with customizable labels.
 
 \imageMacro{complexExample.png,"Example chart",10}
 
 
 \subsection Chart_Technical Technical background 
 
 The module uses the java script library <a href="https://plot.ly/javascript/">plotly</a> to display the chart in a <a href="http://doc.qt.io/qt-5/qwebengineview.html">QWebEngineView</a> (that renders html/js content). 
 
 For examples, please visit https://plot.ly/javascript/.
 
 \subsection Chart_GUI GUI
 
 \note Be sure that the dependency to the Chart Module is resolved in the CMakeLists.txt of the plugin: <code>MODULE_DEPENDS MitkChart</code>.
 
 Open the ui file of the plugin. Then add a widget (we always use the name <code>chartWidget</code> in the following) at the desired position. Change the class of the widget to a user-defined widget (right click &rarr; user defined classes, see http://doc.qt.io/qt-5/designer-using-custom-widgets.html). Set "QWidget" as base class. Set "QmitkChartWidget" as class name and "QmitkChartWidget.h" as include file.
 
 \imageMacro{userDefinedWidget.png,"User defined widget",10}
 
 \subsection Chart_data Data
 
 The most important functionality is to add data to the chartWidget. Either one dimensional or two dimensional data can be used. One-dimensional data has the same interval between values on the x-axis (and no x-axis values) while the two-dimensional data has arbitrary x-axis difference values (and given x-axis values). 
 
 An example for one-dimensional data is the temperature for each month of a year: <code>std::vector<double> temperatureHD = {1.8, 3.1, 6.3, 10.2, 14.5, 17.4, 19.4, 18.9, 15.5, 11.2, 5.8, 2.6}</code>. The first entry corresponds (implicitly) to the temperature in january, two second to the temperature in february the last entry to the temperature in december. Thus, the x values have same intervals. The given temperature values are defined as y-axis values.
 
 An example for two-dimensional data is the people living in a city in different years: <code>std::map<double,double> peopleHeidelberg={{1975, 129368 }, { 1985, 134724 },{ 1990, 136796 },{ 2010, 147312 }}.</code>
 
 Thus, the x-values are given as their intervals are different (10 years, 5 years, 10 years). Each x value is connected to an y-value that represents the amount of people (1975 &rarr; 129368, 1985 &rarr; 134724, ...).
 
 Data is added by calling <code>chartWidget->AddData1D(temperatureHD, "Heidelberg")</code> or <code>chartWidget->AddData2D(peopleHeidelberg, "Heidelberg")</code>, where the second argument is a label for the data entry.
 
 \imageMacro{2DDataExample.png,"2D data example: Heidelberg has fewer entries and their x-range (years) is smaller than Freiburg",8}
 
 As the data labels are used as identifier, they have to be unique. This is checked. If non-unique entries are entered, they are made unique by adding numbers. Example: 
 \code{.cpp}
 chartWidget->AddData1D(temperatureHD, "Heidelberg")
 chartWidget->AddData1D(temperatureOslo, "Heidelberg")
 \endcode
 
 will result in the labels "Heidelberg" and "Heidelberg0", whereas "Heidelberg0" refers to <code>temperatureOslo</code>.
 
 If you want to add more data, just call <code>chartWidget->AddData1D(data, label, chartType)</code> or <code>chartWidget->AddData2D(data, label, chartType)</code> as often as desired. Then, call <code>chartWidget->Show()</code>. The ranges of x- and y-axis are adjusted automatically.
 
 To delete single data entries, call <code>chartWidget->RemoveData(label)</code> and update the chart area with <code>chartWidget->Show()</code>. All data can be cleared by calling <code>chartWidget->Clear()</code>.
 
 \subsection Chart_type Chart type
 
 The default chart type is <code>bar</code>. To use a different type, you have to change it.
 
 Seven chart types are available:
 
 <ul>
   <li> <code>bar</code>
   <li> <code>line</code>
   <li> <code>spline</code>
   <li> <code>pie</code>
   <li> <code>are</code>
   <li> <code>area_spline</code>
   <li> <code>scatter</code>
 </ul>
 
 See below examples of all types:
 
 \imageMacro{barChartTemperature.png,"Example bar chart",4}
 \imageMacro{lineChartTemperature.png,"Example line chart",4}
 \imageMacro{splineChartTemperature.png,"Example spline chart",4}
 \imageMacro{pieChartExample.png,"Example pie chart",4}
 \imageMacro{areaChartTemperature.png,"Example area chart",4}
 \imageMacro{areaSplineChartTemperature.png,"Example spline area chart",4}
 \imageMacro{scatterChartTemperature.png,"Example scatter chart",4}
 
 Call e.g. <code>chartWidget->SetChartType(label, QmitkChartWidget::ChartType::line)</code> for changing the chart type. Note that it is not directly displayed. To change the chart type for all data entries and display the result, call <code>chartWidget->SetChartTypeForAllDataAndReload(QmitkChartWidget::ChartType::line)</code>.
 
 All chart types except pie chart can be also used mixed (different chart types in the same chart). Pie charts are handled differently. The input data sum is regarded as 100%. The values of all data entries are summed. Example:
 \code{.cpp}
 chartWidget->AddData1D({5}, "entry1", QmitkChartWidget::ChartType::pie);
 chartWidget->AddData1D({2}, "entry2", QmitkChartWidget::ChartType::pie);
 chartWidget->AddData1D({3}, "entry3", QmitkChartWidget::ChartType::pie);
 \endcode
 
 The pie chart has then entries of 50%, 20% and 30%. Calling <code>chartWidget->AddData1D({5,2,3}, "entry", QmitkChartWidget::ChartType::pie)</code> leads to a pie chart with one class having 100%. Calling
 \code{.cpp}
 chartWidget->AddData1D({2,2,1}, "entry1", QmitkChartWidget::ChartType::pie);
 chartWidget->AddData1D({1,1}, "entry2", QmitkChartWidget::ChartType::pie);
 chartWidget->AddData1D({3}, "entry3", QmitkChartWidget::ChartType::pie);
 \endcode
 leads to the first result again (50%, 20% and 30%) as entries are summed.
 
 \warning pie charts differ significantly from the other chart types. Be aware of the differences.
 
 \subsection Chart_labels Labels
 
 Four labels can be set to custom strings. These are
 
 <ul>
   <li> the data labels,
   <li> the x-axis label,
   <li> the y-axis label and
   <li> the title of the chart
 </ul>
 
 Data labels provide the name for data legend entries ("Heidelberg" for our 1D data \ref{Chart_data} as it is the average temperature in Heidelberg) and are given by the second argument of AddData1D and AddData2D. They are also displayed in the legend. An example x-Axis and y-axis label would be <i>month</i> and <i>temperature</i>, respectively.
 
 The data label argument is mandatory. All other labels are optional and empty strings by default.
 
 <code>chartWidget->SetXAxisLabel("month")</code> and <code>chartWidget->SetYAxisLabel("temperature")</code> ensures the labeling of x- and y-Axis in the chart. No labels are defined as default.
 
 <code>chartWidget->SetTitle("temperature chart")</code> adds a title to the chart.
 
 \note The legend position (of data labels) can be set by <code>chartWidget->SetLegendPosition(QmitkChartWidget::LegendPosition::bottom)</code>.
 \note To hide the legend, call <code>chartWidget->SetShowLegend(false)</code>.
 
 \subsection Chart_show Displaying the chart
 
 Finally, the chart is displayed by calling <code>chartWidget->Show(bool)</code>. If the optional parameter is set to true, a subchart is shown additionally. That's useful for ensuring the overview if the user wants to zoom in.
 
 \subsection Chart_dataAttributes Changing visualization attributes of data
 
 Besides the chart type, the following attributes of a data entry can be changed:
 
 <ul>
   <li>color,
   <li>linesyle and
   <li>data points shown
 </ul>
 
 this is done by referencing the data entry by its label (e.g. "Heidelberg" above): <code>chartWidget->SetColor("Heidelberg", "green")</code>, <code>chartWidget->SetColor("Heidelberg", "#FF4500")</code>, <code>chartWidget->SetLineStyle("Heidelberg", LineStyle::dashed)</code> and <code>chartWidget->SetShowDataPoints(false)</code>.
 
 \note SetShowDataPoints is a global attribute and valid for all data entries due to technical reasons.
 
-Colors are chosen automatically by plotly if not given. However, if some data entries have given colors and some have not, same colors may appear for different data entries. Color can be given as strings (natural names like <i>red</i> or hexadecimal numbers like <i>#FF0000</i>. For color selection, the following reference is helpful: https://www.w3schools.com/cssref/css_colors.asp)
+Colors are chosen automatically by plotly if not given. However, if some data entries have given colors and some have not, same colors may appear for different data entries. Color can be given as strings (natural names like <i>red</i> or hexadecimal numbers like \c \#FF0000 . For color selection, the following reference is helpful: https://www.w3schools.com/cssref/css_colors.asp)
 
 Line style only can be set if ChartType is <code>QmitkChartWidget::ChartType::line</code>. It is ignored otherwise. Also, if a non-existing label is given, the command is ignored. The default linestyle is <code>LineStyle::solid</code>.
 
 \section Chart_example Example
 
 \subsection Chart_exampleBarChart Bar chart
 
 To create and visualize a bar chart with two data sets, x/y-axis labels and data labels, the following code is used:
 
 \code{.cpp}
 std::vector<double> temperatureHD = {1.8, 3.1, 6.3, 10.2, 14.5, 17.4, 19.4, 18.9, 15.5, 11.2, 5.8, 2.6};
 std::vector<double> temperatureOslo = {-4.3, -4, -0.2, 4.6, 10.8, 15.2, 16.4, 15.2, 10.8, 6.4, 0.7, -2.8};
 chartWidget->AddData1D(temperatureHD, "Heidelberg", QmitkChartWidget::ChartType::bar);
 chartWidget->AddData1D(temperatureOslo, "Oslo", QmitkChartWidget::ChartType::bar);
 chartWidget->SetXAxisLabel("month");
 chartWidget->SetYAxisLabel("temperature");
 chartWidget->Show();
 \endcode
 
 The order when AddData1D() is called  influences the colors of the bars and the order of the shown data. The third argument of <code>chartWidget->AddData1D()</code> is superfluous and only for completeness as <code>QmitkChartWidget::ChartType::bar</code> is the default chart type. After <code>Show()</code> is called, the chart is visualized.
 
 The chart type for all data entries can be changed to spline and directly showed:
 
 \code{.cpp}
 chartWidget->SetChartTypeForAllDataAndReload(QmitkChartWidget::ChartType::spline);
 \endcode
 
 the equivalent code is:
 \code{.cpp}
 chartWidget->SetChartType("Heidelberg", QmitkChartWidget::ChartType::spline);
 chartWidget->SetChartType("Oslo", QmitkChartWidget::ChartType::spline);
 chartWidget->Show();
 \endcode
 
 The temperature of another city can be added:
 \code{.cpp}
 std::vector<double> temperatureRome = {8.1, 8.7, 8.7, 11.6, 18.8, 22.8, 25.4, 25.7, 21.4, 17.6, 12.6, 8.9};
 chartWidget->AddData1D(temperatureRome, "Rome");
 chartWidget->Show(true);
 \endcode
 
 As <code>Show(true)</code> is used, a subchart is shown.
 
 \subsection Chart_examplePieChart Pie chart
 
-A pie chart (the same as in \ref Chart_type) can be generated with the following code:
+A pie chart (the same as in \ref Chart_type ) can be generated with the following code:
 
 \code{.cpp}
 chartWidget->AddData1D({5}, "Heidelberg", QmitkChartWidget::ChartType::pie);
 chartWidget->AddData1D({3}, "Oslo", QmitkChartWidget::ChartType::pie);
 chartWidget->AddData1D({2}, "New York", QmitkChartWidget::ChartType::pie);
 chartWidget->Show();
 \endcode
 
 \note Only one pie chart at a time can be displayed.
 
 \subsection Chart_exampleMixedChart Mixed chart
 
-Chart types and attributes like colors and line styles can be mixed as seen in the code example below (example result is the chart in \ref ChartModule_brief):
+Chart types and attributes like colors and line styles can be mixed as seen in the code example below (example result is the chart in \ref ChartModule_brief ):
 
 \code{.cpp}
 std::vector<double> temperatureHD = {1.8, 3.1, 6.3, 10.2, 14.5, 17.4, 19.4, 18.9, 15.5, 11.2, 5.8, 2.6};
 std::vector<double> temperatureOslo = {-4.3, -4, -0.2, 4.6, 10.8, 15.2, 16.4, 15.2, 10.8, 6.4, 0.7, -2.8};
 chartWidget->AddData1D(temperatureHD, "Heidelberg", QmitkChartWidget::ChartType::line);
 chartWidget->AddData1D(temperatureOslo, "Oslo", QmitkChartWidget::ChartType::area);
 chartWidget->SetColor("Heidelberg", "green");
 chartWidget->SetColor("Oslo", "blue");
 chartWidget->SetLineStyle("Heidelberg", QmitkChartWidget::LineStyle::dashed);
 chartWidget->SetXAxisLabel("month");
 chartWidget->SetYAxisLabel("temperature");
 chartWidget->Show();
 \endcode
 
 \note Pie chart as chart type is an exception. Pie charts can't be displayed with other data entries having other chart types.
 
 \subsection Chart_exampleRemoveData Removing data
 
 Data also can be removed again (using the previous example \ref Chart_exampleMixedChart as base):
 
 \code{.cpp}
 chartWidget->RemoveData("Heidelberg");
 chartWidget->Show();
 \endcode
 
 Only the date entries labeled "Oslo" remain.
 
 Also all data can be removed:
 
 \code{.cpp}
 chartWidget->Clear();
 chartWidget->Show();
 \endcode
 
 The chart is empty now.
 
 \subsection Chart_example2DData Chart with 2D data
 
-A line chart with two-dimensional data is the following example (the same as in \ref Chart_data):
+A line chart with two-dimensional data is the following example (the same as in \ref Chart_data ):
 
 \code{.cpp}
       std::map<double, double> peopleHD = { {1975, 129368 }, { 1985, 134724 },{ 1990, 136796 },{ 2010, 147312 } };
       std::map<double, double> peopleFreiburg = { { 1969, 165960 },{ 1973, 174997 },{ 1982, 178545 },{ 2001, 208294 },{ 2015, 222203 } };
       chartWidget->AddData2D(peopleHD, "Heidelberg", QmitkChartWidget::ChartType::line);
       chartWidget->AddData2D(peopleFreiburg, "Freiburg", QmitkChartWidget::ChartType::line);
       chartWidget->SetXAxisLabel("year");
       chartWidget->SetYAxisLabel("people");
       chartWidget->Show();
 \endcode
 
 Hence, 2D data is having the following assignment: year &rarr; people. In the vector peopleHD, four values are defined, in the vector peopleFreiburg, five values are defined. The defined years are different for Heidelberg (1975-2010) than for Freiburg (1969-2015).
 
 \warning mixing AddData2D and AddData1D in a chart is strongly discouraged. It will work, however the visualization may be odd due to implicit and explicit given x values.
 
 \subsection Chart_imageStatistics image statistics plugin
 
-An example of the use of QmitkChartWidget in MITK can be found in the image statistics plugin (<code>org.mitk.gui.qt.measurementtoolbox\QmitkImageStatisticsView</code>). The <code>chartWidget</code> is named <code>m_Controls->m_JSHistogram</code> there.
+An example of the use of QmitkChartWidget in MITK can be found in the image statistics plugin. The \c chartWidget is named \c m_Controls->m_JSHistogram there.
 
  */
diff --git a/Modules/ContourModel/DataManagement/mitkContourModel.h b/Modules/ContourModel/DataManagement/mitkContourModel.h
index 3620737c86..581768c89a 100644
--- a/Modules/ContourModel/DataManagement/mitkContourModel.h
+++ b/Modules/ContourModel/DataManagement/mitkContourModel.h
@@ -1,452 +1,452 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef _MITK_CONTOURMODEL_H_
 #define _MITK_CONTOURMODEL_H_
 
 #include "mitkBaseData.h"
 #include "mitkCommon.h"
 #include <MitkContourModelExports.h>
 
 #include <mitkContourElement.h>
 
 namespace mitk
 {
   /**
   \brief ContourModel is a structure of linked vertices defining a contour in 3D space.
   The vertices are stored in a mitk::ContourElement is stored for each timestep.
   The contour line segments are implicitly defined by the given linked vertices.
   By default two control points are are linked by a straight line.It is possible to add
   vertices at front and end of the contour and to iterate in both directions.
 
   Points are specified containing coordinates and additional (data) information,
   see mitk::ContourElement.
   For accessing a specific vertex either an index or a position in 3D Space can be used.
   The vertices are best accessed by using a VertexIterator.
   Interaction with the contour is thus available without any mitk interactor class using the
   api of ContourModel. It is possible to shift single vertices also as shifting the whole
   contour.
 
   A contour can be either open like a single curved line segment or
   closed. A closed contour can for example represent a jordan curve.
 
   \section mitkContourModelDisplayOptions Display Options
 
   The default mappers for this data structure are mitk::ContourModelGLMapper2D and
   mitk::ContourModelMapper3D. See these classes for display options which can
   can be set via properties.
   */
   class MITKCONTOURMODEL_EXPORT ContourModel : public BaseData
   {
   public:
     mitkClassMacro(ContourModel, BaseData);
 
     itkFactorylessNewMacro(Self);
 
     itkCloneMacro(Self);
 
       /*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
       typedef mitk::ContourElement::VertexType VertexType;
     typedef mitk::ContourElement::VertexListType VertexListType;
     typedef mitk::ContourElement::VertexIterator VertexIterator;
     typedef mitk::ContourElement::ConstVertexIterator ConstVertexIterator;
     typedef std::vector<mitk::ContourElement::Pointer> ContourModelSeries;
     /*+++++++++++++++ END typedefs ++++++++++++++++++++++++++++*/
 
     /** \brief Possible interpolation of the line segments between control points */
     enum LineSegmentInterpolation
     {
       LINEAR,
       B_SPLINE
     };
 
     /*++++++++++++++++  inline methods  +++++++++++++++++++++++*/
 
     /** \brief Get the current selected vertex.
     */
     VertexType *GetSelectedVertex() { return this->m_SelectedVertex; }
     /** \brief Deselect vertex.
     */
     void Deselect() { this->m_SelectedVertex = nullptr; }
     /** \brief Set selected vertex as control point
     */
     void SetSelectedVertexAsControlPoint(bool isControlPoint = true)
     {
       if (this->m_SelectedVertex)
       {
         m_SelectedVertex->IsControlPoint = isControlPoint;
         this->Modified();
       }
     }
 
     /** \brief Set the interpolation of the line segments between control points.
     */
     void SetLineSegmentInterpolation(LineSegmentInterpolation interpolation)
     {
       this->m_lineInterpolation = interpolation;
       this->Modified();
     }
 
     /** \brief Get the interpolation of the line segments between control points.
     */
     LineSegmentInterpolation GetLineSegmentInterpolation() { return this->m_lineInterpolation; }
     /*++++++++++++++++  END inline methods  +++++++++++++++++++++++*/
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertex(mitk::Point3D &vertex, int timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertex(VertexType &vertex, int timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeSlicedGeometry will not be expanded.
     */
     void AddVertex(const VertexType *vertex, int timestep = 0);
 
     /** \brief Add a vertex to the contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
     \param isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
     will be rendered).
 
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
     The vertex is added at the FRONT of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertexAtFront(mitk::Point3D &vertex, int timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
     The vertex is added at the FRONT of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertexAtFront(VertexType &vertex, int timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
     \param isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
     will be rendered).
 
 
     @Note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
     void AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep = 0);
 
     /** \brief Insert a vertex at given index.
     */
     void InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint = false, int timestep = 0);
 
     /** \brief Set a coordinates for point at given index.
     */
     bool SetVertexAt(int pointId, const mitk::Point3D &point, unsigned int timestep = 0);
 
     /** \brief Set a coordinates for point at given index.
     */
     bool SetVertexAt(int pointId, const VertexType *vertex, unsigned int timestep = 0);
 
     /** \brief Return if the contour is closed or not.
     */
     bool IsClosed(int timestep = 0) const;
 
     /** \brief Concatenate two contours.
     The starting control point of the other will be added at the end of the contour.
-    \pararm timestep - the timestep at which the vertex will be add ( default 0)
-    \pararm check - check for intersections ( default false)
+    \param timestep - the timestep at which the vertex will be add ( default 0)
+    \param check - check for intersections ( default false)
     */
     void Concatenate(mitk::ContourModel *other, int timestep = 0, bool check = false);
 
     /** \brief Returns a const VertexIterator at the start element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
     VertexIterator Begin(int timestep = 0) const;
 
     /** \brief Returns a const VertexIterator at the start element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
     VertexIterator IteratorBegin(int timestep = 0) const;
 
     /** \brief Returns a const VertexIterator at the end element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
     VertexIterator End(int timestep = 0) const;
 
     /** \brief Returns a const VertexIterator at the end element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
     VertexIterator IteratorEnd(int timestep = 0) const;
 
     /** \brief Close the contour.
     The last control point will be linked with the first point.
     */
     virtual void Close(int timestep = 0);
 
     /** \brief Set isClosed to false contour.
     The link between the last control point the first point will be removed.
     */
     virtual void Open(int timestep = 0);
 
     /** \brief Set closed property to given boolean.
 
     false - The link between the last control point the first point will be removed.
     true - The last control point will be linked with the first point.
     */
     virtual void SetClosed(bool isClosed, int timestep = 0);
 
     /** \brief Returns the number of vertices at a given timestep.
     \param timestep - default = 0
     */
     int GetNumberOfVertices(int timestep = 0) const;
 
     /** \brief Returns whether the contour model is empty at a given timestep.
-    \pararm timestep - default = 0
+    \param timestep - default = 0
     */
     virtual bool IsEmpty(int timestep) const;
 
     /** \brief Returns whether the contour model is empty.
     */
     bool IsEmpty() const override;
 
     /** \brief Returns the vertex at the index position within the container.
     */
     virtual const VertexType *GetVertexAt(int index, int timestep = 0) const;
 
     /** \brief Remove a vertex at given timestep within the container.
 
     \return index of vertex. -1 if not found.
     */
     int GetIndex(const VertexType *vertex, int timestep = 0);
 
     /** \brief Check if there isn't something at this timestep.
     */
     bool IsEmptyTimeStep(unsigned int t) const override;
 
     /** \brief Check if mouse cursor is near the contour.
     */
     virtual bool IsNearContour(mitk::Point3D &point, float eps, int timestep);
 
     /** \brief Mark a vertex at an index in the container as selected.
     */
     bool SelectVertexAt(int index, int timestep = 0);
 
     /** \brief Mark a vertex at an index in the container as control point.
     */
     bool SetControlVertexAt(int index, int timestep = 0);
 
     /** \brief Mark a vertex at a given position in 3D space.
 
     \param point - query point in 3D space
     \param eps - radius for nearest neighbour search (error bound).
     \param timestep - search at this timestep
 
     @return true = vertex found;  false = no vertex found
     */
     bool SelectVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
     /*
         \pararm point - query point in 3D space
         \pararm eps - radius for nearest neighbour search (error bound).
         \pararm timestep - search at this timestep
 
         @return true = vertex found;  false = no vertex found
         */
     bool SetControlVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
 
     /** \brief Remove a vertex at given index within the container.
 
     @return true = the vertex was successfuly removed;  false = wrong index.
     */
     bool RemoveVertexAt(int index, int timestep = 0);
 
     /** \brief Remove a vertex at given timestep within the container.
 
     @return true = the vertex was successfuly removed.
     */
     bool RemoveVertex(const VertexType *vertex, int timestep = 0);
 
     /** \brief Remove a vertex at a query position in 3D space.
 
     The vertex to be removed will be search by nearest neighbour search.
     Note that possibly no vertex at this position and eps is stored inside
     the contour.
 
     @return true = the vertex was successfuly removed;  false = no vertex found.
     */
     bool RemoveVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
 
     /** \brief Shift the currently selected vertex by a translation vector.
 
     \param translate - the translation vector.
     */
     void ShiftSelectedVertex(mitk::Vector3D &translate);
 
     /** \brief Shift the whole contour by a translation vector at given timestep.
 
     \param translate - the translation vector.
     \param timestep - at this timestep the contour will be shifted.
     */
     void ShiftContour(mitk::Vector3D &translate, int timestep = 0);
 
     /** \brief Clear the storage container at given timestep.
 
     All control points are removed at
     timestep.
     */
     virtual void Clear(int timestep);
 
     /** \brief Initialize all data objects
     */
     void Initialize() override;
 
     /** \brief Initialize object with specs of other contour.
     Note: No data will be copied.
     */
     void Initialize(mitk::ContourModel &other);
 
     /*++++++++++++++++++ method inherit from base data +++++++++++++++++++++++++++*/
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     void SetRequestedRegionToLargestPossibleRegion() override;
 
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
 
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     bool VerifyRequestedRegion() override;
 
     /**
     \brief Get the updated geometry with recomputed bounds.
     */
     virtual const mitk::BaseGeometry *GetUpdatedGeometry(int t = 0);
 
     /**
     \brief Get the BaseGeometry for timestep t.
     */
     virtual mitk::BaseGeometry *GetGeometry(int t = 0) const;
 
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     void SetRequestedRegion(const itk::DataObject *data) override;
 
     /**
     \brief Expand the timebounds of the TimeGeometry to given number of timesteps.
     */
     void Expand(unsigned int timeSteps) override;
 
     /**
     \brief Update the OutputInformation of a ContourModel object
 
     The BoundingBox of the contour will be updated, if necessary.
     */
     void UpdateOutputInformation() override;
 
     /**
     \brief Clear the storage container.
 
     The object is set to initial state. All control points are removed and the number of
     timesteps are set to 1.
     */
     void Clear() override;
 
     /**
     \brief overwrite if the Data can be called by an Interactor (StateMachine).
     */
     void ExecuteOperation(Operation *operation) override;
 
     /** \brief Redistributes ontrol vertices with a given period (as number of vertices)
     \param period - the number of vertices between control points.
     \param timestep - at this timestep all lines will be rebuilt.
     */
     virtual void RedistributeControlVertices(int period, int timestep);
 
   protected:
     mitkCloneMacro(Self);
 
     ContourModel();
     ContourModel(const mitk::ContourModel &other);
     ~ContourModel() override;
 
     // inherit from BaseData. called by Clear()
     void ClearData() override;
 
     // inherit from BaseData. Initial state of a contour with no vertices and a single timestep.
     void InitializeEmpty() override;
 
     // Shift a vertex
     void ShiftVertex(VertexType *vertex, mitk::Vector3D &vector);
 
     // Storage with time resolved support.
     ContourModelSeries m_ContourSeries;
 
     // The currently selected vertex.
     VertexType *m_SelectedVertex;
 
     // The interpolation of the line segment between control points.
     LineSegmentInterpolation m_lineInterpolation;
 
     // only update the bounding geometry if necessary
     bool m_UpdateBoundingBox;
   };
 
   itkEventMacro(ContourModelEvent, itk::AnyEvent);
   itkEventMacro(ContourModelShiftEvent, ContourModelEvent);
   itkEventMacro(ContourModelSizeChangeEvent, ContourModelEvent);
   itkEventMacro(ContourModelAddEvent, ContourModelSizeChangeEvent);
   itkEventMacro(ContourModelRemoveEvent, ContourModelSizeChangeEvent);
   itkEventMacro(ContourModelExpandTimeBoundsEvent, ContourModelEvent);
   itkEventMacro(ContourModelClosedEvent, ContourModelEvent);
 }
 #endif
diff --git a/Modules/Core/include/mitkBaseGeometry.h b/Modules/Core/include/mitkBaseGeometry.h
index 8d2e4feb85..32940d3d80 100644
--- a/Modules/Core/include/mitkBaseGeometry.h
+++ b/Modules/Core/include/mitkBaseGeometry.h
@@ -1,763 +1,765 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef BaseGeometry_H_HEADER_INCLUDED
 #define BaseGeometry_H_HEADER_INCLUDED
 
 #include "mitkOperationActor.h"
 #include <MitkCoreExports.h>
 #include <mitkCommon.h>
 
 #include "itkScalableAffineTransform.h"
 #include "mitkNumericTypes.h"
 #include <itkAffineGeometryFrame.h>
 #include <itkBoundingBox.h>
 #include <itkIndex.h>
 #include <itkQuaternionRigidTransform.h>
 #include <mitkAffineTransform3D.h>
 
 #include <mitkGeometryTransformHolder.h>
 #include <vtkTransform.h>
 
 class vtkMatrix4x4;
 class vtkMatrixToLinearTransform;
 class vtkLinearTransform;
 
 namespace mitk
 {
   //##Documentation
   //## @brief Standard 3D-BoundingBox typedef
   //##
   //## Standard 3D-BoundingBox typedef to get rid of template arguments (3D, type).
   typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBox;
 
   //##Documentation
   //## @brief Standard typedef for time-bounds
   typedef itk::FixedArray<ScalarType, 2> TimeBounds;
   typedef itk::FixedArray<ScalarType, 3> FixedArrayType;
 
   typedef itk::AffineGeometryFrame<ScalarType, 3> AffineGeometryFrame3D;
 
   //##Documentation
   //## @brief BaseGeometry Describes the geometry of a data object
   //##
   //## The class holds
   //## \li a bounding box which is axes-parallel in intrinsic coordinates
   //## (often integer indices of pixels), to be accessed by
   //## GetBoundingBox()
   //## \li a transform to convert intrinsic coordinates into a
   //## world-coordinate system with coordinates in millimeters
   //## and milliseconds (all are floating point values), to
   //## be accessed by GetIndexToWorldTransform()
   //## \li an origin and spacing to define the geometry
   //##
   //## BaseGeometry and its sub-classes allow converting between
   //## intrinsic coordinates (called index or unit coordinates)
   //## and world-coordinates (called world or mm coordinates),
   //## e.g. WorldToIndex.
   //## In case you need integer index coordinates, provide an
   //## mitk::Index3D (or itk::Index) as target variable to
   //## WorldToIndex, otherwise you will get a continuous index
   //## (floating point values).
   //##
   //## An important sub-class is SlicedGeometry3D, which descibes
   //## data objects consisting of slices, e.g., objects of type Image.
   //## Conversions between world coordinates (in mm) and unit coordinates
   //## (e.g., pixels in the case of an Image) can be performed.
   //##
   //## For more information on related classes, see \ref Geometry.
   //##
   //## BaseGeometry instances referring to an Image need a slightly
   //## different definition of corners, see SetImageGeometry. This
   //## is usualy automatically called by Image.
   //##
   //## BaseGeometry have to be initialized in the method GenerateOutputInformation()
   //## of BaseProcess (or CopyInformation/ UpdateOutputInformation of BaseData,
   //## if possible, e.g., by analyzing pic tags in Image) subclasses. See also
   //## itk::ProcessObject::GenerateOutputInformation(),
   //## itk::DataObject::CopyInformation() and
   //## itk::DataObject::UpdateOutputInformation().
   //##
   //## At least, it can return the bounding box of the data object.
   //##
   //## The BaseGeometry class is an abstract class. The most simple implementation
   //## is the sublass Geometry3D.
   //##
   //## Rule: everything is in mm (ms) if not stated otherwise.
   //## @ingroup Geometry
   class MITKCORE_EXPORT BaseGeometry : public itk::Object, public OperationActor
   {
   public:
     mitkClassMacroItkParent(BaseGeometry, itk::Object);
     itkCloneMacro(Self);
 
       // ********************************** TypeDef **********************************
 
       typedef GeometryTransformHolder::TransformType TransformType;
     typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
     typedef BoundingBoxType::BoundsArrayType BoundsArrayType;
     typedef BoundingBoxType::Pointer BoundingBoxPointer;
 
     // ********************************** Origin, Spacing **********************************
 
     //##Documentation
     //## @brief Get the origin, e.g. the upper-left corner of the plane
     const Point3D GetOrigin() const;
 
     //##Documentation
     //## @brief Set the origin, i.e. the upper-left corner of the plane
     //##
     void SetOrigin(const Point3D &origin);
 
     //##Documentation
     //## @brief Get the spacing (size of a pixel).
     //##
     const mitk::Vector3D GetSpacing() const;
 
     //##Documentation
     //## @brief Set the spacing (m_Spacing).
     //##
     //##The spacing is also changed in the IndexToWorldTransform.
     void SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing = false);
 
     //##Documentation
     //## @brief Get the origin as VnlVector
     //##
     //## \sa GetOrigin
     VnlVector GetOriginVnl() const;
 
     // ********************************** other functions **********************************
 
     //##Documentation
     //## @brief Get the DICOM FrameOfReferenceID referring to the
     //## used world coordinate system
     itkGetConstMacro(FrameOfReferenceID, unsigned int);
     //##Documentation
     //## @brief Set the DICOM FrameOfReferenceID referring to the
     //## used world coordinate system
     itkSetMacro(FrameOfReferenceID, unsigned int);
 
     itkGetConstMacro(IndexToWorldTransformLastModified, unsigned long);
 
     //##Documentation
     //## @brief Overload of function Modified() to prohibit several calls of Modified() using the ModifiedLock class.
     //##
     //## For the use of Modified(), see class ModifiedLock.
     void Modified() const override;
 
     friend class ModifiedLock;
 
     //##Documentation
     //## @brief Is this BaseGeometry in a state that is valid?
     //##
     //## This function returns always true in the BaseGeometry class. Other implementations are possible in subclasses.
     virtual bool IsValid() const;
 
     // ********************************** Initialize **********************************
 
     //##Documentation
     //## @brief Initialize the BaseGeometry
     void Initialize();
 
     void InitializeGeometry(Self *newGeometry) const;
 
     // ********************************** Transformations Set/Get **********************************
 
     //##Documentation
     //## @brief Get the transformation used to convert from index
     //## to world coordinates
     mitk::AffineTransform3D *GetIndexToWorldTransform();
 
     //##Documentation
     //## @brief Get the transformation used to convert from index
     //## to world coordinates
     const mitk::AffineTransform3D *GetIndexToWorldTransform() const;
 
     //## @brief Set the transformation used to convert from index
     //## to world coordinates. The spacing of the new transform is
     //## copied to m_spacing.
     void SetIndexToWorldTransform(mitk::AffineTransform3D *transform);
 
     //##Documentation
     //## @brief Convenience method for setting the ITK transform
     //## (m_IndexToWorldTransform) via an vtkMatrix4x4.The spacing of
     //## the new transform is copied to m_spacing.
     //## \sa SetIndexToWorldTransform
     void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4 *vtkmatrix);
 
     //## @brief Set the transformation used to convert from index
     //## to world coordinates.This function keeps the original spacing.
     void SetIndexToWorldTransformWithoutChangingSpacing(mitk::AffineTransform3D *transform);
 
     //##Documentation
     //## @brief Convenience method for setting the ITK transform
     //## (m_IndexToWorldTransform) via an vtkMatrix4x4. This function keeps the original spacing.
     //## \sa SetIndexToWorldTransform
     void SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkMatrix4x4 *vtkmatrix);
 
     //## Get the Vtk Matrix which describes the transform.
     vtkMatrix4x4 *GetVtkMatrix();
 
     //##Documentation
     //## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
     vtkLinearTransform *GetVtkTransform() const;
 
     //##Documentation
     //## @brief Set the transform to identity, the spacing to 1 and origin to 0
     //##
     void SetIdentity();
 
     // ********************************** Transformations **********************************
 
     //##Documentation
     //## @brief Compose new IndexToWorldTransform with a given transform.
     //##
     //## This method composes m_IndexToWorldTransform with another transform,
     //## modifying self to be the composition of self and other.
     //## If the argument pre is true, then other is precomposed with self;
     //## that is, the resulting transformation consists of first applying
     //## other to the source, followed by self. If pre is false or omitted,
     //## then other is post-composed with self; that is the resulting
     //## transformation consists of first applying self to the source,
     //## followed by other.
     //## This method also changes m_spacing.
     void Compose(const TransformType *other, bool pre = false);
 
     //##Documentation
     //## @brief Compose new IndexToWorldTransform with a given vtkMatrix4x4.
     //##
     //## Converts the vtkMatrix4x4 into a itk-transform and calls the previous method.
     void Compose(const vtkMatrix4x4 *vtkmatrix, bool pre = false);
 
     //##Documentation
     //## @brief Translate the origin by a vector
     //##
     void Translate(const Vector3D &vector);
 
     //##Documentation
     //##@brief executes affine operations (translate, rotate, scale)
     void ExecuteOperation(Operation *operation) override;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em point to (continuous!) index coordinates
     //## \warning If you need (discrete) integer index coordinates (e.g., for iterating easily over an image),
     //## use WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index).
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em point to (discrete!) index coordinates.
     //## This method rounds to integer indices!
     //## For further information about coordinates types, please see the Geometry documentation
     template <unsigned int VIndexDimension>
     void WorldToIndex(const mitk::Point3D &pt_mm, itk::Index<VIndexDimension> &index) const
     {
       typedef itk::Index<VIndexDimension> IndexType;
       mitk::Point3D pt_units;
       this->WorldToIndex(pt_mm, pt_units);
       int i, dim = index.GetIndexDimension();
       if (dim > 3)
       {
         index.Fill(0);
         dim = 3;
       }
       for (i = 0; i < dim; ++i)
       {
         index[i] = itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType>(pt_units[i]);
       }
     }
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em point to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const;
 
     //##Documentation
     //## @brief Convert (discrete) index coordinates of a \em point to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     template <unsigned int VIndexDimension>
     void IndexToWorld(const itk::Index<VIndexDimension> &index, mitk::Point3D &pt_mm) const
     {
       mitk::Point3D pt_units;
       pt_units.Fill(0);
       int i, dim = index.GetIndexDimension();
       if (dim > 3)
       {
         dim = 3;
       }
       for (i = 0; i < dim; ++i)
       {
         pt_units[i] = index[i];
       }
 
       IndexToWorld(pt_units, pt_mm);
     }
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## @deprecated First parameter (Point3D) is not used. If possible, please use void IndexToWorld(const
     // mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const.
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Point3D &atPt3d_units, const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## @deprecated First parameter (Point3D) is not used. If possible, please use void WorldToIndex(const
     // mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const.
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Point3D &atPt3d_mm, const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const;
 
     //##Documentation
     //## @brief Deprecated for use with ITK version 3.10 or newer.
     //## Convert ITK physical coordinates of a \em point (in mm,
     //## but without a rotation) into MITK world coordinates (in mm)
     //##
     //## For more information, see WorldToItkPhysicalPoint.
     template <class TCoordRep>
     void ItkPhysicalPointToWorld(const itk::Point<TCoordRep, 3> &itkPhysicalPoint, mitk::Point3D &pt_mm) const
     {
       mitk::vtk2itk(itkPhysicalPoint, pt_mm);
     }
 
     //##Documentation
     //## @brief Deprecated for use with ITK version 3.10 or newer.
     //## Convert world coordinates (in mm) of a \em point to
     //## ITK physical coordinates (in mm, but without a possible rotation)
     //##
     //## This method is useful if you have want to access an mitk::Image
     //## via an itk::Image. ITK v3.8 and older did not support rotated (tilted)
     //## images, i.e., ITK images are always parallel to the coordinate axes.
     //## When accessing a (possibly rotated) mitk::Image via an itk::Image
     //## the rotational part of the transformation in the BaseGeometry is
     //## simply discarded; in other word: only the origin and spacing is
     //## used by ITK, not the complete matrix available in MITK.
     //## With WorldToItkPhysicalPoint you can convert an MITK world
     //## coordinate (including the rotation) into a coordinate that
     //## can be used with the ITK image as a ITK physical coordinate
     //## (excluding the rotation).
     template <class TCoordRep>
     void WorldToItkPhysicalPoint(const mitk::Point3D &pt_mm, itk::Point<TCoordRep, 3> &itkPhysicalPoint) const
     {
       mitk::vtk2itk(pt_mm, itkPhysicalPoint);
     }
 
     // ********************************** BoundingBox **********************************
 
     /** Get the bounding box */
     itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
 
 // a bit of a misuse, but we want only doxygen to see the following:
 #ifdef DOXYGEN_SKIP
     //##Documentation
     //## @brief Get bounding box (in index/unit coordinates)
     itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
     //##Documentation
     //## @brief Get bounding box (in index/unit coordinates) as a BoundsArrayType
     const BoundsArrayType GetBounds() const;
 #endif
     const BoundsArrayType GetBounds() const;
 
     //##Documentation
     //## \brief Set the bounding box (in index/unit coordinates)
     //##
     //## Only possible via the BoundsArray to make clear that a
     //## copy of the bounding-box is stored, not a reference to it.
     void SetBounds(const BoundsArrayType &bounds);
 
     //##Documentation
     //## @brief Set the bounding box (in index/unit coordinates) via a float array
     void SetFloatBounds(const float bounds[6]);
     //##Documentation
     //## @brief Set the bounding box (in index/unit coordinates) via a double array
     void SetFloatBounds(const double bounds[6]);
 
     //##Documentation
     //## @brief Get a VnlVector along bounding-box in the specified
     //## @a direction, length is spacing
     //##
     //## \sa GetAxisVector
     VnlVector GetMatrixColumn(unsigned int direction) const;
 
     //##Documentation
     //## @brief Calculates a bounding-box around the geometry relative
     //## to a coordinate system defined by a transform
     //##
     mitk::BoundingBox::Pointer CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D *transform) const;
 
 //##Documentation
 //## @brief Set the time bounds (in ms)
 // void SetTimeBounds(const TimeBounds& timebounds);
 
 // ********************************** Geometry **********************************
 
 #ifdef DOXYGEN_SKIP
     //##Documentation
     //## @brief Get the extent of the bounding box (in index/unit coordinates)
     //##
     //## To access the extent in mm use GetExtentInMM
     ScalarType GetExtent(unsigned int direction) const;
 #endif
 
     /** Get the extent of the bounding box */
     ScalarType GetExtent(unsigned int direction) const;
 
     //##Documentation
     //## @brief Get the extent of the bounding-box in the specified @a direction in mm
     //##
     //## Equals length of GetAxisVector(direction).
     ScalarType GetExtentInMM(int direction) const;
 
     //##Documentation
     //## @brief Get vector along bounding-box in the specified @a direction in mm
     //##
     //## The length of the vector is the size of the bounding-box in the
     //## specified @a direction in mm
     //## \sa GetMatrixColumn
     Vector3D GetAxisVector(unsigned int direction) const;
 
     //##Documentation
     //## @brief Checks, if the given geometry can be converted to 2D without information loss
     //## e.g. when a 2D image is saved, the matrix is usually cropped to 2x2, and when you load it back to MITK
     //## it will be filled with standard values. This function checks, if information would be lost during this
     //## procedure
     virtual bool Is2DConvertable();
 
     //##Documentation
     //## @brief Get the center of the bounding-box in mm
     //##
     Point3D GetCenter() const;
 
     //##Documentation
     //## @brief Get the squared length of the diagonal of the bounding-box in mm
     //##
     double GetDiagonalLength2() const;
 
     //##Documentation
     //## @brief Get the length of the diagonal of the bounding-box in mm
     //##
     double GetDiagonalLength() const;
 
     //##Documentation
     //## @brief Get the position of the corner number \a id (in world coordinates)
     //##
     //## See SetImageGeometry for how a corner is defined on images.
     Point3D GetCornerPoint(int id) const;
 
     //##Documentation
     //## @brief Get the position of a corner (in world coordinates)
     //##
     //## See SetImageGeometry for how a corner is defined on images.
     Point3D GetCornerPoint(bool xFront = true, bool yFront = true, bool zFront = true) const;
 
     //##Documentation
     //## @brief Set the extent of the bounding-box in the specified @a direction in mm
     //##
     //## @note This changes the matrix in the transform, @a not the bounds, which are given in units!
     void SetExtentInMM(int direction, ScalarType extentInMM);
 
     //##Documentation
     //## @brief Test whether the point \a p (world coordinates in mm) is
     //## inside the bounding box
     bool IsInside(const mitk::Point3D &p) const;
 
     //##Documentation
     //## @brief Test whether the point \a p ((continous!)index coordinates in units) is
     //## inside the bounding box
     bool IsIndexInside(const mitk::Point3D &index) const;
 
     //##Documentation
     //## @brief Convenience method for working with ITK indices
     template <unsigned int VIndexDimension>
     bool IsIndexInside(const itk::Index<VIndexDimension> &index) const
     {
       int i, dim = index.GetIndexDimension();
       Point3D pt_index;
       pt_index.Fill(0);
       for (i = 0; i < dim; ++i)
       {
         pt_index[i] = index[i];
       }
       return IsIndexInside(pt_index);
     }
 
     // ********************************* Image Geometry ********************************
     //##Documentation
     //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to
     //change
     // the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and
     // changes the origin respectively.
     virtual void ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry);
 
     //##Documentation
     //## @brief Is this an ImageGeometry?
     //##
     //## For more information, see SetImageGeometry
     itkGetConstMacro(ImageGeometry, bool)
       //##Documentation
       //## @brief Define that this BaseGeometry is refering to an Image
       //##
       //## A geometry referring to an Image needs a slightly different
       //## definition of the position of the corners (see GetCornerPoint).
       //## The position of a voxel is defined by the position of its center.
       //## If we would use the origin (position of the (center of) the first
       //## voxel) as a corner and display this point, it would seem to be
       //## \em not at the corner but a bit within the image. Even worse for
       //## the opposite corner of the image: here the corner would appear
       //## outside the image (by half of the voxel diameter). Thus, we have
       //## to correct for this and to be able to do that, we need to know
       //## that the BaseGeometry is referring to an Image.
       itkSetMacro(ImageGeometry, bool);
       itkBooleanMacro(ImageGeometry);
 
         const GeometryTransformHolder *GetGeometryTransformHolder() const;
 
   protected:
     // ********************************** Constructor **********************************
     BaseGeometry();
     BaseGeometry(const BaseGeometry &other);
     ~BaseGeometry() override;
 
     //##Documentation
     //## @brief clones the geometry
     //##
     //## Overwrite in all sub-classes.
     //## Normally looks like:
     //## \code
     //##  Self::Pointer newGeometry = new Self(*this);
     //##  newGeometry->UnRegister();
     //##  return newGeometry.GetPointer();
     //## \endcode
     itk::LightObject::Pointer InternalClone() const override = 0;
 
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     static const std::string GetTransformAsString(TransformType *transformType);
 
     itkGetConstMacro(NDimensions, unsigned int);
 
       bool IsBoundingBoxNull() const;
 
     bool IsIndexToWorldTransformNull() const;
 
     void SetVtkMatrixDeepCopy(vtkTransform *vtktransform);
 
     void _SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing = false);
 
     //##Documentation
     //## @brief PreSetSpacing
     //##
     //## These virtual function allows a different beahiour in subclasses.
     //## Do implement them in every subclass of BaseGeometry. If not needed, use
     //## {Superclass::PreSetSpacing();};
     virtual void PreSetSpacing(const mitk::Vector3D & /*aSpacing*/){};
 
     //##Documentation
     //## @brief CheckBounds
     //##
     //## This function is called in SetBounds. Assertions can be implemented in this function (see PlaneGeometry.cpp).
     //## If you implement this function in a subclass, make sure, that all classes were your class inherits from
     //## have an implementation of CheckBounds
     //## (e.g. inheritance BaseGeometry <- A <- B. Implementation of CheckBounds in class B needs implementation in A as
     // well!)
     virtual void CheckBounds(const BoundsArrayType & /*bounds*/){};
 
     //##Documentation
     //## @brief CheckIndexToWorldTransform
     //##
     //## This function is called in SetIndexToWorldTransform. Assertions can be implemented in this function (see
     // PlaneGeometry.cpp).
     //## In Subclasses of BaseGeometry, implement own conditions or call Superclass::CheckBounds(bounds);.
     virtual void CheckIndexToWorldTransform(mitk::AffineTransform3D * /*transform*/){};
 
   private:
     GeometryTransformHolder *m_GeometryTransform;
 
     void InitializeGeometryTransformHolder(const BaseGeometry *otherGeometry);
 
     //##Documentation
     //## @brief Bounding Box, which is axes-parallel in intrinsic coordinates
     //## (often integer indices of pixels)
     BoundingBoxPointer m_BoundingBox;
 
     unsigned int m_FrameOfReferenceID;
 
     // mitk::TimeBounds m_TimeBounds;
 
     static const unsigned int m_NDimensions = 3;
 
     mutable TransformType::Pointer m_InvertedTransform;
 
     mutable unsigned long m_IndexToWorldTransformLastModified;
 
     bool m_ImageGeometry;
 
     //##Documentation
     //## @brief ModifiedLockFlag is used to prohibit the call of Modified()
     //##
     //## For the use of this Flag, see class ModifiedLock. This flag should only be set
     //## by the ModifiedLock class!
     bool m_ModifiedLockFlag;
 
     //##Documentation
     //## @brief ModifiedcalledFlag is used to collect calls of Modified().
     //##
     //## For the use of this Flag, see class ModifiedLock. This flag should only be set
     //## by the Modified() function!
     mutable bool m_ModifiedCalledFlag;
   };
 
   // ********************************** Equal Functions **********************************
   //
   // Static compare functions mainly for testing
   //
   /**
   * @brief Equal A function comparing two geometries for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the spacing, origin, axisvectors, extents, the matrix of the
   * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * If you want to use different tolerance values for different parts of the geometry, feel free to use
   * the other comparison methods and write your own implementation of Equal.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param coordinateEps Tolerance for comparison of all spatial aspects (spacing, origin and grid alignment).
   * You can use mitk::eps in most cases.
   * @param directionEps Tolerance for comparison of all directional aspects (axis). You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry& leftHandSide,
     const mitk::BaseGeometry& rightHandSide,
     ScalarType coordinateEps,
     ScalarType directionEps,
     bool verbose = false);
 
   /**
   * @brief Equal A function comparing two geometries for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
-  * @overload This is an overloaded version that uses a single tolerance for spatial and directional aspects. For more details,
+  * This is an overloaded version that uses a single tolerance for spatial and directional aspects. For more details,
   * see the other overloaded version.
+  *
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry &leftHandSide,
                              const mitk::BaseGeometry &rightHandSide,
                              ScalarType eps = mitk::eps,
                              bool verbose = false);
 
   /**
   * @brief Equal A function comparing two transforms (TransformType) for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the IndexToWorldTransform (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry::TransformType &leftHandSide,
                              const mitk::BaseGeometry::TransformType &rightHandSide,
                              ScalarType eps,
                              bool verbose);
 
   /**
   * @brief Equal A function comparing two bounding boxes (BoundingBoxType) for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the bounds (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry::BoundingBoxType &leftHandSide,
                              const mitk::BaseGeometry::BoundingBoxType &rightHandSide,
                              ScalarType eps,
                              bool verbose);
 
   /**
   * @brief A function checks if a test geometry is a sub geometry of
   * a given reference geometry.
   *
   * Sub geometry means that both geometries have the same voxel grid (same spacing, same axes,
   * orgin is on voxel grid), but the bounding box of the checked geometry is contained or equal
   * to the bounding box of the reference geometry.\n
   * By this definition equal geometries are always sub geometries of each other.
   *
   * The function checks the spacing, origin, axis vectors, extents, the matrix of the
   * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
   *
   * The parameter eps is a tolerance value for all methods which are internally used for comparison.
   * @param testGeo Geometry that should be checked if it is a sub geometry of referenceGeo.
   * @param referenceGeo Geometry that should contain testedGeometry as sub geometry.
   * @param coordinateEps Tolerance for comparison of all spatial aspects (spacing, origin and grid alignment).
   * You can use mitk::eps in most cases.
   * @param directionEps Tolerance for comparison of all directional aspects (axis). You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparisons are true. False otherwise.
   */
   MITKCORE_EXPORT bool IsSubGeometry(const mitk::BaseGeometry& testGeo,
     const mitk::BaseGeometry& referenceGeo,
     ScalarType coordinateEps,
     ScalarType directionEps,
     bool verbose = false);
 
   /**
   * @brief A function checks if a test geometry is a sub geometry of
   * a given reference geometry.
   *
-  * @overload This is a overloaded version that uses a single tolerance for spatial and directional aspects. For more details,
+  * This is a overloaded version that uses a single tolerance for spatial and directional aspects. For more details,
   * see the other overloaded version.
+  *
   * @param testGeo Geometry that should be checked if it is a sub geometry of referenceGeo.
   * @param referenceGeo Geometry that should contain testedGeometry as sub geometry.
   * @param eps Tolarence for comparison (both spatial and directional). You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False otherwise.
   */
   MITKCORE_EXPORT bool IsSubGeometry(const mitk::BaseGeometry& testGeo,
     const mitk::BaseGeometry& referenceGeo,
     ScalarType eps = mitk::eps,
     bool verbose = false);
 
 } // namespace mitk
 
 #endif /* BaseGeometry_H_HEADER_INCLUDED */
diff --git a/Modules/Core/include/mitkDataStorage.h b/Modules/Core/include/mitkDataStorage.h
index b4f451a46c..8e6771b65f 100644
--- a/Modules/Core/include/mitkDataStorage.h
+++ b/Modules/Core/include/mitkDataStorage.h
@@ -1,447 +1,443 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKDATASTORAGE_H
 #define MITKDATASTORAGE_H
 
 #include "itkObject.h"
 #include "itkSimpleFastMutexLock.h"
 #include "itkVectorContainer.h"
 #include "mitkDataNode.h"
 #include "mitkGeometry3D.h"
 #include "mitkMessage.h"
 #include <MitkCoreExports.h>
 #include <map>
 
 namespace mitk
 {
   class NodePredicateBase;
   class DataNode;
   class BaseRenderer;
 
   //##Documentation
   //## @brief Data management class that handles 'was created by' relations
   //##
   //## The DataStorage provides data storage and management functionality.
   //## It handles a 'was created by' relation by associating each data object with a
   //## set of source objects, that this object was created from.
   //## Thus, nodes are stored in a noncyclical directed graph data structure.
   //## If a new node is added to the DataStorage, AddNodeEvent is emitted.
   //## If a node is removed, RemoveNodeEvent is emitted.
   //##
   //##
   //## \ingroup DataStorage
   class MITKCORE_EXPORT DataStorage : public itk::Object
   {
   public:
     mitkClassMacroItkParent(DataStorage, itk::Object);
 
     //##Documentation
     //## @brief A Container of objects that is used as a result set of GetSubset() query operations (Set of
     //SmartPointers
     // to DataNodes).
     typedef itk::VectorContainer<unsigned int, DataNode::Pointer> SetOfObjects;
 
     //##Documentation
     //## @brief Adds a DataNode containing a data object to its internal storage
     //##
     //## This Method adds a new data object to the DataStorage. The new object is
     //## passed in the first parameter. The second parameter is a set
     //## of source objects, that were used to create this object. The new object will have
     //## a 'was created from' relation to its source objects.
     //## the addition of a new object will fire the notification mechanism.
     //## If the node parameter is nullptr or if the DataNode has already been added,
     //## an exception will be thrown.
     virtual void Add(DataNode *node, const DataStorage::SetOfObjects *parents = nullptr) = 0;
 
     //##Documentation
     //## @brief Convenience method to add a node that has one parent
     //##
     void Add(DataNode *node, DataNode *parent);
 
     //##Documentation
     //## @brief Removes node from the DataStorage
     //##
     virtual void Remove(const DataNode *node) = 0;
 
     //##Documentation
     //## @brief Checks if a node exists in the DataStorage
     //##
     virtual bool Exists(const DataNode *node) const = 0;
 
     //##Documentation
     //## @brief Removes a set of nodes from the DataStorage
     //##
     void Remove(const DataStorage::SetOfObjects *nodes);
 
     //##Documentation
     //## @brief returns a set of data objects that meet the given condition(s)
     //##
     //## GetSubset returns a set of objects  with a specific data type that meet the condition(s)
     //## specified in the condition parameter. Conditions can be
     //##  - data type of the data object
     //##  - is source object of specific object (e.g. all source objects of node x)
     //##  - has property with specific value (e.g. OrganType is Liver)
     //##  - negation of any condition
     //##  - conjunction of a set of conditions
     //##  - disjunction of a set of conditions
     //## Conditions are implemented as predicates using the Composite Design Pattern
     //## (see definition of NodePredicateBase for details).
     //## The method returns a set of SmartPointers to the DataNodes that fulfill the
     //## conditions. A set of all objects can be retrieved with the GetAll() method;
     SetOfObjects::ConstPointer GetSubset(const NodePredicateBase *condition) const;
 
     //##Documentation
     //## @brief returns a set of source objects for a given node that meet the given condition(s).
     //##
     virtual SetOfObjects::ConstPointer GetSources(const DataNode *node,
                                                   const NodePredicateBase *condition = nullptr,
                                                   bool onlyDirectSources = true) const = 0;
 
     //##Documentation
     //## @brief returns a set of derived objects for a given node.
     //##
     //## GetDerivations() returns a set of objects that are derived from the DataNode node.
     //## This means, that node was used to create the returned objects. If the parameter
     //## onlyDirectDerivations is set to true (default value), only objects that directly have
     //## node as one of their source objects will be returned. Otherwise, objects that are
     //## derived from derivations of node are returned too.
     //## The derived objects can be filtered with a predicate object as described in the GetSubset()
     //## method by providing a predicate as the condition parameter.
     virtual SetOfObjects::ConstPointer GetDerivations(const DataNode *node,
                                                       const NodePredicateBase *condition = nullptr,
                                                       bool onlyDirectDerivations = true) const = 0;
 
     //##Documentation
     //## @brief returns a set of all data objects that are stored in the data storage
     //##
     virtual SetOfObjects::ConstPointer GetAll() const = 0;
 
     //##Documentation
     //## @brief Convenience method to get the first node that matches the predicate condition
     //##
     DataNode *GetNode(const NodePredicateBase *condition = nullptr) const;
 
     //##Documentation
     //## @brief Convenience method to get the first node with a given name
     //##
     DataNode *GetNamedNode(const char *name) const;
 
     //##Documentation
     //## @brief Convenience method to get the first node with a given name
     //##
     DataNode *GetNamedNode(const std::string name) const { return this->GetNamedNode(name.c_str()); }
     //##Documentation
     //## @brief Convenience method to get the first node with a given name that is derived from sourceNode
     //##
     DataNode *GetNamedDerivedNode(const char *name,
                                   const DataNode *sourceNode,
                                   bool onlyDirectDerivations = true) const;
 
     //##Documentation
     //## @brief Convenience method to get the first data object of a given data type with a given name
     //##
     template <class DataType>
     DataType *GetNamedObject(const char *name) const
     {
       if (name == nullptr)
         return nullptr;
       DataNode *n = this->GetNamedNode(name);
       if (n == nullptr)
         return nullptr;
       else
         return dynamic_cast<DataType *>(n->GetData());
     }
     //##Documentation
     //## @brief Convenience method to get the first data object of a given data type with a given name
     //##
     template <class DataType>
     DataType *GetNamedObject(const std::string name) const
     {
       return this->GetNamedObject<DataType>(name.c_str());
     }
 
     //##Documentation
     //## @brief Convenience method to get the first data object of a given data type with a given name that is derived
     // from a specific node
     //##
     template <class DataType>
     DataType *GetNamedDerivedObject(const char *name,
                                     const DataNode *sourceNode,
                                     bool onlyDirectDerivations = true) const
     {
       if (name == nullptr)
         return nullptr;
       DataNode *n = this->GetNamedDerivedNode(name, sourceNode, onlyDirectDerivations);
       if (n == nullptr)
         return nullptr;
       else
         return dynamic_cast<DataType *>(n->GetData());
     }
 
     //##Documentation
     //## @brief Returns a list of used grouptags
     //##
     const DataNode::GroupTagList GetGroupTags() const;
 
     /*ITK Mutex */
     mutable itk::SimpleFastMutexLock m_MutexOne;
 
     /* Public Events */
     typedef Message1<const DataNode*> DataStorageEvent;
     //##Documentation
     //## @brief AddEvent is emitted whenever a new node has been added to the DataStorage.
     //##
     //## Observers should register to this event by calling myDataStorage->AddNodeEvent.AddListener(myObject,
     // MyObject::MyMethod).
     //## After registering, myObject->MyMethod() will be called every time a new node has been added to the DataStorage.
     //## Observers should unregister by calling myDataStorage->AddNodeEvent.RemoveListener(myObject,
     //MyObject::MyMethod).
     //## Note: AddEvents are _not_ emitted if a node is added to DataStorage by adding it to the the underlying
     //DataTree!
 
     // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef
     // for
     // a Message1 object which is thread safe
     DataStorageEvent AddNodeEvent;
 
     //##Documentation
     //## @brief RemoveEvent is emitted directly before a node is removed from the DataStorage.
     //##
     //## Observers should register to this event by calling myDataStorage->RemoveNodeEvent.AddListener(myObject,
     // MyObject::MyMethod).
     //## After registering, myObject->MyMethod() will be called every time a new node has been added to the DataStorage.
     //## Observers should unregister by calling myDataStorage->RemoveNodeEvent.RemoveListener(myObject,
     // MyObject::MyMethod).
     //## Note: RemoveEvents are also emitted if a node was removed from the DataStorage by deleting it from the
     //underlying
     // DataTree
 
     // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef
     // for
     // a Message1 object which is thread safe
     DataStorageEvent RemoveNodeEvent;
 
     //##Documentation
     //## @brief ChangedEvent is emitted directly after a node was changed.
     //##
     //## Observers should register to this event by calling myDataStorage->ChangedNodeEvent.AddListener(myObject,
     // MyObject::MyMethod).
     //## After registering, myObject->MyMethod() will be called every time a new node has been changed.
     //## Observers should unregister by calling myDataStorage->ChangedNodeEvent.RemoveListener(myObject,
     // MyObject::MyMethod).
     //## Internally the DataStorage listens to itk::ModifiedEvents on the nodes and forwards them
     //## to the listeners of this event.
 
     // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef
     // for
     // a Message1 object which is thread safe
     DataStorageEvent ChangedNodeEvent;
 
     //##Documentation
     //## @brief DeleteNodeEvent is emitted directly before a node is deleted.
     //##
     //## Observers should register to this event by calling myDataStorage->DeleteNodeEvent.AddListener(myObject,
     // MyObject::MyMethod).
     //## After registering, myObject->MyMethod() will be called when a node is deleted.
     //## Observers should unregister by calling myDataStorage->DeleteNodeEvent.RemoveListener(myObject,
     // MyObject::MyMethod).
     //## Internally the DataStorage listens to itk::DeleteEvents on the nodes and forwards them
     //## to the listeners of this event.
 
     // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef
     // for
     // a Message1 object which is thread safe
     DataStorageEvent DeleteNodeEvent;
 
     DataStorageEvent InteractorChangedNodeEvent;
 
     //##Documentation
     //## @brief Compute the axis-parallel bounding geometry of the input objects
     //##
     //## Throws std::invalid_argument exception if input is nullptr
     //## @param input set of objects of the DataStorage to be included in the bounding geometry
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
     //## @param renderer see @a boolPropertyKey
     //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
     TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const SetOfObjects *input,
                                                          const char *boolPropertyKey = nullptr,
                                                          const BaseRenderer *renderer = nullptr,
                                                          const char *boolPropertyKey2 = nullptr) const;
 
     //##Documentation
     //## @brief Compute the axis-parallel bounding geometry of the data tree
     //## (bounding box, minimal spacing of the considered nodes, live-span)
     //##
     //## it -> an iterator to a data tree structure
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
     //## @param renderer see @a boolPropertyKey
     //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
     TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const char *boolPropertyKey = nullptr,
                                                          const BaseRenderer *renderer = nullptr,
                                                          const char *boolPropertyKey2 = nullptr) const;
 
     //##Documentation
     //## @brief Compute the axis-parallel bounding geometry of all visible parts of the
     //## data tree bounding box, minimal spacing of the considered nodes, live-span)
     //##
     //## Simply calls ComputeBoundingGeometry3D(it, "visible", renderer, boolPropertyKey).
     //## it -> an iterator of a data tree structure
     //## @param renderer the reference to the renderer
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
     TimeGeometry::ConstPointer ComputeVisibleBoundingGeometry3D(const BaseRenderer *renderer = nullptr,
                                                                 const char *boolPropertyKey = nullptr);
 
     //##Documentation
     //## @brief Compute the bounding box of data tree structure
     //## it -> an iterator to a data tree structure
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
     //## @param renderer see @a boolPropertyKey
     //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
     BoundingBox::Pointer ComputeBoundingBox(const char *boolPropertyKey = nullptr,
                                             const BaseRenderer *renderer = nullptr,
                                             const char *boolPropertyKey2 = nullptr);
 
     //##Documentation
     //## \brief Compute the bounding box of all visible parts of the data tree structure, for general
     //## rendering or renderer specific visibility property checking
     //##
     //## Simply calls ComputeBoundingBox(it, "visible", renderer, boolPropertyKey).
     //## it -> an iterator of a data tree structure
     //## @param renderer the reference to the renderer
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the bounding-box calculation.
     BoundingBox::Pointer ComputeVisibleBoundingBox(const BaseRenderer *renderer = nullptr,
                                                    const char *boolPropertyKey = nullptr)
     {
       return ComputeBoundingBox("visible", renderer, boolPropertyKey);
     }
 
     //##Documentation
     //## @brief Compute the time-bounds of the contents of a data tree structure
     //##
     //## The methods returns only [-infinity, +infinity], if all data-objects have an infinite live-span. Otherwise,
     //## all data-objects with infinite live-span are ignored.
     //## it -> an iterator to a data tree structure
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the time-bounds calculation.
     //## @param renderer see @a boolPropertyKey
     //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
     TimeBounds ComputeTimeBounds(const char *boolPropertyKey,
                                  const BaseRenderer *renderer,
                                  const char *boolPropertyKey2);
 
     //##Documentation
     //## @brief Compute the time-bounds of all visible parts of the data tree structure, for general
     //## rendering or renderer specific visibility property checking
     //##
     //## The methods returns only [-infinity, +infinity], if all data-objects have an infinite live-span. Otherwise,
     //## all data-objects with infinite live-span are ignored.
     //## Simply calls ComputeTimeBounds(it, "visible", renderer, boolPropertyKey).
     //## @param it an iterator to a data tree structure
     //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
     //## and is set to @a false, the node is ignored for the time-bounds calculation.
     //## @param renderer see @a boolPropertyKey
     TimeBounds ComputeTimeBounds(const BaseRenderer *renderer, const char *boolPropertyKey)
     {
       return ComputeTimeBounds("visible", renderer, boolPropertyKey);
     }
 
     //##Documentation
     //## @brief Defines whether or not NodeChangedEvent is invoked .
     //##
     //## This method can be used to set m_BlockNodeModifiedEvents.
     //##
     //## If this flag is true, NodeChangedEvent is not invoked when a
     //## DataNode is modified. This might be undesired when setting
     //## many properties on a datanode and you do not want anyone to
     //## react.
     void BlockNodeModifiedEvents(bool block);
 
   protected:
     //##Documentation
     //## @brief  EmitAddNodeEvent emits the AddNodeEvent
     //##
     //## This method should be called by subclasses to emit the AddNodeEvent
     void EmitAddNodeEvent(const DataNode *node);
 
     //##Documentation
     //## @brief  EmitRemoveNodeEvent emits the RemoveNodeEvent
     //##
     //## This method should be called by subclasses to emit the RemoveNodeEvent
     void EmitRemoveNodeEvent(const DataNode *node);
 
     void OnNodeInteractorChanged(itk::Object *caller, const itk::EventObject &event);
 
     //##Documentation
     //## @brief  OnNodeModified listens to modified events of DataNodes.
     //##
     //## The node is hidden behind the caller parameter, which has to be casted first.
     //## If the cast succeeds the ChangedNodeEvent is emitted with this node.
     void OnNodeModifiedOrDeleted(const itk::Object *caller, const itk::EventObject &event);
 
     //##Documentation
     //## @brief  Adds a Modified-Listener to the given Node.
     void AddListeners(const DataNode *_Node);
 
     //##Documentation
     //## @brief  Removes a Modified-Listener from the given Node.
     void RemoveListeners(const DataNode *_Node);
 
     //##Documentation
     //## @brief  Saves Modified-Observer Tags for each node in order to remove the event listeners again.
     std::map<const DataNode *, unsigned long> m_NodeModifiedObserverTags;
 
     std::map<const DataNode *, unsigned long> m_NodeInteractorChangedObserverTags;
 
     //##Documentation
     //## @brief  Saves Delete-Observer Tags for each node in order to remove the event listeners again.
     std::map<const DataNode *, unsigned long> m_NodeDeleteObserverTags;
 
     //##Documentation
     //## @brief If this class changes nodes itself, set this to TRUE in order
     //## to suppress NodeChangedEvent to be emitted.
     bool m_BlockNodeModifiedEvents;
 
-    //##Documentation
-    //## @brief Standard Constructor for ::New() instantiation
     DataStorage();
-    //##Documentation
-    //## @brief Standard Destructor
     ~DataStorage() override;
 
     //##Documentation
     //## @brief Filters a SetOfObjects by the condition. If no condition is provided, the original set is returned
     SetOfObjects::ConstPointer FilterSetOfObjects(const SetOfObjects *set, const NodePredicateBase *condition) const;
 
     //##Documentation
     //## @brief Prints the contents of the DataStorage to os. Do not call directly, call ->Print() instead
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
   };
 
   //##Documentation
   //## @brief returns the topmost visible node of a given list of nodes.
   //## The function returns a node that is visible and has the highest layer of a set of given nodes.
   //## The property list, which is used to find the visibility- and layer-property is is specified by the
   //## given base renderer.
   //##
   MITKCORE_EXPORT DataNode::Pointer FindTopmostVisibleNode(const DataStorage::SetOfObjects::ConstPointer nodes,
                                                            const Point3D worldPosition,
                                                            const TimePointType timePoint,
                                                            const BaseRenderer* baseRender);
 } // namespace mitk
 
 #endif // MITKDATASTORAGE_H
diff --git a/Modules/Core/include/mitkDisplayActionEventFunctions.h b/Modules/Core/include/mitkDisplayActionEventFunctions.h
index a2ca0f0351..22d0f352d9 100644
--- a/Modules/Core/include/mitkDisplayActionEventFunctions.h
+++ b/Modules/Core/include/mitkDisplayActionEventFunctions.h
@@ -1,86 +1,86 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKDISPLAYACTIONEVENTFUNCTIONS_H
 #define MITKDISPLAYACTIONEVENTFUNCTIONS_H
 
 #include <MitkCoreExports.h>
 
 #include "mitkStdFunctionCommand.h"
 
 namespace mitk
 {
   namespace DisplayActionEventFunctions
   {
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplayMoveEvent'.
     *   The function performs a move of the camera controller of the sending renderer by a vector
     *   that was previously determined by the mouse interaction event.
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction MoveSenderCameraAction();
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplaySetCrosshairEvent'.
     *   The function performs a slice selection of the slice navigation controller and will set
     *   the cross hair for all 2D-render windows.
     *   The new position was previously determined by the mouse interaction event.
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction SetCrosshairAction();
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplayZoomEvent'.
     *   The function performs a zoom of the camera controller of the sending renderer by a zoom factor
     *   that was previously determined by the mouse interaction event.
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction ZoomSenderCameraAction();
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplayScrollEvent'.
     *   The function performs a slice scrolling of the slice navigation controller of the sending renderer.
     *   The new position was previously determined by the mouse interaction event.
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction ScrollSliceStepperAction();
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplaySetLevelWindowEvent'.
     *   The function sets the 'levelwindow' property of the topmost visible image that is display by the sending renderer.
     *   The level and window value for this property were previously determined by the mouse interaction event.
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction SetLevelWindowAction();
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplayMoveEvent'.
     *   The function performs a move of the camera controller of all renderer (synchronized)
     *   by a vector that was previously determined by the mouse interaction event.
     *   The renderer need to be managed by the same rendering manager.
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction MoveCameraSynchronizedAction();
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplaySetCrosshairEvent'.
     *   The function performs a slice selection of the slice navigation controller and will set
     *   the cross hair for all 2D-render windows.
     *   The new position was previously determined by the mouse interaction event.
-    *   #TODO: currently there is no need to distinguish between this and the non-synchronized version
+    * @todo Currently there is no need to distinguish between this and the non-synchronized version
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction SetCrosshairSynchronizedAction();
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplayZoomEvent'.
     *   The function performs a zoom of the camera controller of all 2D-renderer (synchronized)
     *   by a zoom factor that was previously determined by the mouse interaction event.
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction ZoomCameraSynchronizedAction();
     /**
     * @brief Returns an 'std::function' that can be used  to react on the 'DisplayScrollEvent'.
     *   The function performs a slice scrolling of the slice navigation controller of all 2D-renderer (synchronized).
     *   The new position was previously determined by the mouse interaction event.
     */
     MITKCORE_EXPORT StdFunctionCommand::ActionFunction ScrollSliceStepperSynchronizedAction();
 
   } // end namespace DisplayActionEventFunctions
 } // end namespace mitk
 
 #endif // MITKDISPLAYACTIONEVENTFUNCTIONS_H
diff --git a/Modules/Core/include/mitkStandaloneDataStorage.h b/Modules/Core/include/mitkStandaloneDataStorage.h
index adf6b52e48..88e17af581 100644
--- a/Modules/Core/include/mitkStandaloneDataStorage.h
+++ b/Modules/Core/include/mitkStandaloneDataStorage.h
@@ -1,133 +1,129 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKSTANDALONEDATASTORAGE_H_HEADER_INCLUDED_
 #define MITKSTANDALONEDATASTORAGE_H_HEADER_INCLUDED_
 
 #include "itkVectorContainer.h"
 #include "mitkDataStorage.h"
 #include "mitkMessage.h"
 #include <map>
 
 namespace mitk
 {
   class NodePredicateBase;
   class DataNode;
 
   //##Documentation
   //## @brief Data management class that handles 'was created by' relations
   //##
   //## The StandaloneDataStorage provides data storage and management functionality.
   //## It handles a 'was created by' relation by associating each data object with a
   //## set of source objects that were used to create the new object was created from.
   //## Thus, nodes are stored in a noncyclical directed graph data structure.
   //## It is derived from mitk::DataStorage and implements its interface,
   //## including AddNodeEvent and RemoveNodeEvent.
   //## @ingroup StandaloneDataStorage
   class MITKCORE_EXPORT StandaloneDataStorage : public mitk::DataStorage
   {
   public:
     mitkClassMacro(StandaloneDataStorage, mitk::DataStorage);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       //##Documentation
       //## @brief Adds a DataNode containing a data object to its internal storage
       //##
       //## This Method adds a new data object to the StandaloneDataStorage. The new object is
       //## passed in the first parameter. The second parameter is a set
       //## of source objects, that were used to create this object. The new object will have
       //## a 'was created from' relation to its source objects.
       //## the addition of a new object will fire the notification mechanism.
       //## If the node parameter is nullptr or if the DataNode has already been added,
       //## an exception will be thrown.
       void Add(mitk::DataNode *node, const mitk::DataStorage::SetOfObjects *parents = nullptr) override;
 
     //##Documentation
     //## @brief Removes node from the StandaloneDataStorage
     //##
     void Remove(const mitk::DataNode *node) override;
 
     //##Documentation
     //## @brief Checks if a node exists in the StandaloneDataStorage
     //##
     bool Exists(const mitk::DataNode *node) const override;
 
     //##Documentation
     //## @brief returns a set of source objects for a given node that meet the given condition(s).
     //##
     SetOfObjects::ConstPointer GetSources(const mitk::DataNode *node,
                                           const NodePredicateBase *condition = nullptr,
                                           bool onlyDirectSources = true) const override;
 
     //##Documentation
     //## @brief returns a set of derived objects for a given node.
     //##
     //## GetDerivations() returns a set of objects that are derived from the DataNode node.
     //## This means, that node was used to create the returned objects. If the parameter
     //## onlyDirectDerivations is set to true (default value), only objects that directly have
     //## node as one of their source objects will be returned. Otherwise, objects that are
     //## derived from derivations of node are returned too.
     //## The derived objects can be filtered with a predicate object as described in the GetSubset()
     //## method by providing a predicate as the condition parameter.
     SetOfObjects::ConstPointer GetDerivations(const mitk::DataNode *node,
                                               const NodePredicateBase *condition = nullptr,
                                               bool onlyDirectDerivations = true) const override;
 
     //##Documentation
     //## @brief returns a set of all data objects that are stored in the data storage
     //##
     SetOfObjects::ConstPointer GetAll() const override;
 
     /*ITK Mutex */
     mutable itk::SimpleFastMutexLock m_Mutex;
 
   protected:
     //##Documentation
     //## @brief noncyclical directed graph data structure to store the nodes with their relation
     typedef std::map<mitk::DataNode::ConstPointer, SetOfObjects::ConstPointer> AdjacencyList;
 
-    //##Documentation
-    //## @brief Standard Constructor for ::New() instantiation
     StandaloneDataStorage();
-    //##Documentation
-    //## @brief Standard Destructor
     ~StandaloneDataStorage() override;
 
     //##Documentation
     //## @brief convenience method to check if the object has been initialized (i.e. a data tree has been set)
     bool IsInitialized() const;
 
     //##Documentation
     //## @brief Traverses the Relation graph and extracts a list of related elements (e.g. Sources or Derivations)
     SetOfObjects::ConstPointer GetRelations(const mitk::DataNode *node,
                                             const AdjacencyList &relation,
                                             const NodePredicateBase *condition = nullptr,
                                             bool onlyDirectlyRelated = true) const;
 
     //##Documentation
     //## @brief deletes all references to a node in a given relation (used in Remove() and TreeListener)
     void RemoveFromRelation(const mitk::DataNode *node, AdjacencyList &relation);
 
     //##Documentation
     //## @brief Prints the contents of the StandaloneDataStorage to os. Do not call directly, call ->Print() instead
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     //##Documentation
     //## @brief Nodes and their relation are stored in m_SourceNodes
     AdjacencyList m_SourceNodes;
     //##Documentation
     //## @brief Nodes are stored in reverse relation for easier traversal in the opposite direction of the relation
     AdjacencyList m_DerivedNodes;
   };
 } // namespace mitk
 #endif /* MITKSTANDALONEDATASTORAGE_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/TrackingDevices/mitkOptitrackTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkOptitrackTrackingDevice.h
index f64edb5924..a575d23c11 100644
--- a/Modules/IGT/TrackingDevices/mitkOptitrackTrackingDevice.h
+++ b/Modules/IGT/TrackingDevices/mitkOptitrackTrackingDevice.h
@@ -1,320 +1,320 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef OptitrackTrackingDevice_H_HEADER_INCLUDED
 #define OptitrackTrackingDevice_H_HEADER_INCLUDED
 
 #include <MitkIGTExports.h>
 #include <mitkTrackingDevice.h>
 #include <itkMultiThreader.h>
 #include <mitkTrackingTypes.h>
 #include <mitkIGTTimeStamp.h>
 #include <itkFastMutexLock.h>
 #include <itksys/SystemTools.hxx>
 #include <itkMutexLockHolder.h>
 #include <string>
 #include <cstdlib>
 #include <cstdio>
 #include <ctime>
 
 /**
 * \brief IGT Exceptions
 */
 #include "mitkIGTIOException.h"
 #include "mitkIGTTimeStamp.h"
 #include "mitkIGTException.h"
 
 /**
 * \brief OptitrackTrackingTools
 */
 #include "mitkOptitrackTrackingTool.h"
 
 
 
 /**
 * \brief MutexHolder to keep rest of Mutex
 */
 typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
 
 
 
 
 namespace mitk
 {
   /** Documentation:
   *   \brief An object of this class represents the Optitrack device. You can add tools to this
   *          device, then open the connection and start tracking. The tracking device will then
   *          continuously update the tool coordinates. Remember that it will be necessary to
   *       to have a license for using the Optitrack System.
   *       See  http://www.naturalpoint.com/ for details.
   *   \author E. Marinetto (emarinetto@hggm.es) Instituto de Investigación Sanitaria Gregorio Marañón, Madrid, Spain. & M. Noll (matthias.noll@igd.fraunhofer.de) Cognitive Computing & Medical Imaging | Fraunhofer IGD
   *   \ingroup IGT
   */
   class MITKIGT_EXPORT OptitrackTrackingDevice : public mitk::TrackingDevice
   {
 
   friend class OptitrackTrackingTool;
 
   public:
     mitkClassMacro(OptitrackTrackingDevice, mitk::TrackingDevice);
     itkNewMacro(Self);
 
     /**
     * @returns Returns true if the Optitrack tracker is installed on this build (means activated in CMAKE). False if not.
     */
     bool IsDeviceInstalled() override;
 
     // Define the Type of Tracker as DefinitionOfTool (MITK)
     typedef mitk::TrackingDeviceType OptiTrackTrackingDeviceType;
 
     /**
     * \brief Open the Connection with the Tracker. Calls LoadCalibration function and set the system up with the calibration file.
     * Remember that you have to set a calibration file first to open a correct connection to the Optical Tracking System.
     * \return Returns true if the connection is well done. Throws an exception if an error occures related to the Optitrack API messages.
     * @throw mitk::IGTException Throws an exception if InitializeCameras or LoadCalibration failed.
     */
     bool OpenConnection() override;
 
     /**
     * \brief Close the Connection with the Tracker. Also CleanUp the Optitrack variables using the API: TT_CleanUp and TT_ShutDown.
     * Sometimes API does not work properly and some problems during the Clean Up has been reported.
     * \return Returns true if the cleaning up and shutdown worked correctly. Throws an exception if an error occures related to the Optitrack API messages.
     * @throw mitk::IGTException Throws an exception if the System cannot ShutDown now or was not initialized.
     */
     bool CloseConnection() override;
 
     /**
     * \brief Start to Track the tools already defined. If no tools are defined for this tracker, it returns an error.
     * Tools can be added using either AddToolByDescriptionFile or AddToolsByConfigurationFiles
     * \return Returns true at least one tool was defined and the tracking is correct
     * @throw mitk::IGTException Throws an exception if the System is not in State Ready .
     */
     bool StartTracking() override;
 
     /**
     * \brief Stop the Tracking Thread and tools will not longer be updated.
     * \return Returns true if Tracking thread could be stopped.
     * @throw mitk::IGTException Throws an exception if System is not in State Tracking.
     */
     bool StopTracking() override;
 
     /**
     * \brief Return the tool pointer of the tool number toolNumber
     * \param toolNumber The number of the tool which should be given back.
     * \return Returns the tool which the number "toolNumber". Returns nullptr, if there is
     * no tool with this number.
     */
     TrackingTool* GetTool(unsigned int toolNumber) const override;
 
     /**
     * \brief Return the tool pointer of the tool number toolNumber
     * \param toolNumber The number of the tool which should be given back.
     * \return Returns the tool which the number "toolNumber". Returns nullptr, if there is
     * no tool with this number.
     * @throw mitk::IGTException Throws an exception if there is the required tool does not exist.
     */
     OptitrackTrackingTool* GetOptitrackTool(unsigned int toolNumber) const;
 
     /**
     * \brief Returns the number of defined tools
     * \return Returns the number of defined tools in the Optitrack device.
     */
     unsigned int GetToolCount() const override;
 
 /** @brief Sets the directory where the calibration file of the MicronTracker can be found. */
     itkSetMacro(Exp,int);
 
   /** @brief Gets the current calibration directory. */
     itkGetMacro(Exp,int);
 
 /** @brief Sets the directory where the calibration file of the MicronTracker can be found. */
     itkSetMacro(Led,int);
 
   /** @brief Gets the current calibration directory. */
     itkGetMacro(Led,int);
 
 /** @brief Sets the directory where the calibration file of the MicronTracker can be found. */
     itkSetMacro(Thr,int);
 
   /** @brief Gets the current calibration directory. */
     itkGetMacro(Thr,int);
 
     /** @brief Sets the file where the calibration of the OptitrackTracker can be found. */
    void SetCalibrationPath(std::string calibrationPath);
 
     /** @brief Gets the current calibration file. */
     itkGetMacro(calibrationPath,std::string);
 
     /**
     * \brief Start the Tracking Thread for the tools
     * @throw mitk::IGTException Throws an exception if variable trackingDevice is nullptr
     */
     static ITK_THREAD_RETURN_TYPE ThreadStartTracking(void* data);
 
     /**
     * \brief Update each tool location in the list m_AllTools
     * @throw mitk::IGTException Throws an exception if the getting data operation failed for a defined tool
     */
     void TrackTools();
 
     /**
     * \brief Load the Calibration file to the Optitrack System and set the cameras in calibrated locations
     * \return Returns true if the calibration was uploaded correctly
     * @throw mitk::IGTException Throws an exception if Calibration Path is empty, the System cannot load a calibration file or System is not ready for load a calibration file because it has not been initialized yet
     */
     bool LoadCalibration();
 
     /**
     * \brief Set the Cameras Exposure, Threshold and Intensity of IR LEDs. By Default it set the Video type to 4: Precision Mode for tracking
     * //== VideoType:
         * //==     0 = Segment Mode
         * //==     1 = Grayscale Mode
         * //==     2 = Object Mode
         * //==     4 = Precision Mode
         * //==     6 = MJPEG Mode     (V100R2 only)
     * \return Returns true if all cameras were set up correctly
     * @throw mitk::IGTException Throws an exception if System is not Initialized
     */
     bool SetCameraParams(int exposure, int threshold, int intensity, int videoType = 4);
 
     /**
     * \brief Initialize the Optitrack System
     * \return Returns true if system was initialized correctly
     * @throw mitk::IGTException Throws an exception if the Optitrack Tracking System cannot be initialized
     */
     bool InitializeCameras();
 
     /**
     * \brief Add a new tool using a text file which described the tool.
     * The file must to have the next structure
     *    ToolName
-    *    #NumberOfMarkers
+    *    \#NumberOfMarkers
     *    X Y Z - for the first marker
     *    X Y Z - for the second marker
     *    ...
-    *    X Y Z - for the last marker, the number #NumberOfMarkers
+    *    X Y Z - for the last marker, the number \#NumberOfMarkers
     *    X Y Z - for the PIVOT point
     * \return Returns true if system was initialized correctly
     * @throw mitk::IGTException Throws an exception if Tool could not be added or System is not Initialized
     */
     bool AddToolByDefinitionFile(std::string fileName); // ^????? We should give an example of defined tool
 
     /**
     * \brief This function load a file with Tools definitions provided for the software
     * \return Returns true if file is correctly loaded with all the tools
     * @throw mitk::IGTException Throws an exception if there is an error during the Initialization
     */
 //    bool AddToolByConfigurationFil(std::string fileName); // For next release....
 
   protected:
     /**
     * \brief Constructor & Destructor of the class
     */
     OptitrackTrackingDevice();
     ~OptitrackTrackingDevice() override;
 
 
   private:
     /**
     * \brief The calibration file path. This file is produced by TrackingTools/Motive software.
     * This variable is used to determine what will be the calibration file absolute path.
     */
     std::string m_calibrationPath;
 
     /**
     * \brief The Cameras Exposition
     */
     int m_Exp;
 
     /**
     * \brief The Cameras LED power
     */
     int m_Led;
 
     /**
     * \brief The Cameras Thr
     */
     int m_Thr;
 
     /**
     * \brief Described if the system was initialized at least once during execution. This is due
     * to some reported problems during the clean up , shutdown and initialization again.
     */
     bool m_initialized;
 
     /**
     * \brief Vector of pointers pointing to all defined tools
     */
     std::vector<mitk::OptitrackTrackingTool::Pointer> m_AllTools;
 
     /**
     * \brief Mutex for coordinated access of tool container
     */
     itk::FastMutexLock::Pointer m_ToolsMutex;
 
     /**
     * \brief MultiThreader that starts continuous tracking update
     */
     itk::MultiThreader::Pointer m_MultiThreader;
 
     /**
     * \brief ThreadID number identification
     */
     int m_ThreadID;
 
 
 /* TODO:
 
 // For Tracking
 -bool AddToolByConfigurationFil(std::string fileName);
 TTAPI   NPRESULT TT_LoadTrackables (const char *filename); //== Load Trackables ======----
 TTAPI   NPRESULT TT_SaveTrackables (const char *filename); //== Save Trackables ======----
 TTAPI   NPRESULT TT_AddTrackables  (const char *filename); //== Add  Trackables ======----
 TTAPI   void     TT_ClearTrackableList();             //== Clear all trackables   =====---
 TTAPI   NPRESULT TT_RemoveTrackable(int Index);       //== Remove single trackable ====---
 TTAPI   void     TT_SetTrackableEnabled(int index, bool enabled);    //== Set Tracking   ====---
 TTAPI   bool     TT_TrackableEnabled(int index);                     //== Get Tracking   ====---
 TTAPI   int      TT_TrackableMarkerCount(int index);             //== Get marker count   ====---
 TTAPI   void     TT_TrackableMarker(int RigidIndex,              //== Get Trackable mrkr ====---
                         int MarkerIndex, float *x, float *y, float *z);
 
 //For projects
 TTAPI   NPRESULT TT_LoadProject(const char *filename); //== Load Project File ==========--
 TTAPI   NPRESULT TT_SaveProject(const char *filename); //== Save Project File ==========--
 
 // For VRPN connection
 TTAPI   NPRESULT TT_StreamVRPN(bool enabled, int port);//== Start/stop VRPN Stream ===----
 
 // For frame testing
 TTAPI   int      TT_FrameMarkerCount();               //== Returns Frame Markers Count ---
 TTAPI   float    TT_FrameMarkerX(int index);          //== Returns X Coord of Marker -----
 TTAPI   float    TT_FrameMarkerY(int index);          //== Returns Y Coord of Marker -----
 TTAPI   float    TT_FrameMarkerZ(int index);          //== Returns Z Coord of Marker -----
 TTAPI   int      TT_FrameMarkerLabel(int index);      //== Returns Label of Marker -------
 TTAPI   double   TT_FrameTimeStamp();                 //== Time Stamp of Frame (seconds) -
 
 // For cameras handling
 TTAPI   int      TT_CameraCount();                    //== Returns Camera Count =====-----
 TTAPI   float    TT_CameraXLocation(int index);       //== Returns Camera's X Coord =-----
 TTAPI   float    TT_CameraYLocation(int index);       //== Returns Camera's Y Coord =-----
 TTAPI   float    TT_CameraZLocation(int index);       //== Returns Camera's Z Coord =-----
 TTAPI   float    TT_CameraOrientationMatrix(int camera, int index); //== Orientation -----
 
 
 */
 
 
 };
 
 
 }
 #endif
diff --git a/Modules/IGT/TrackingDevices/mitkOptitrackTrackingTool.h b/Modules/IGT/TrackingDevices/mitkOptitrackTrackingTool.h
index 52cc463cb2..dce6567be1 100644
--- a/Modules/IGT/TrackingDevices/mitkOptitrackTrackingTool.h
+++ b/Modules/IGT/TrackingDevices/mitkOptitrackTrackingTool.h
@@ -1,217 +1,217 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef OptiTrackTrackingTool_H_HEADER_INCLUDED_
 #define OptiTrackTrackingTool_H_HEADER_INCLUDED_
 
 #include <MitkIGTExports.h>
 #include <itkMultiThreader.h>
 #include "itkFastMutexLock.h"
 #include "mitkTrackingDevice.h"
 #include "mitkTrackingTool.h"
 #include "mitkIGTTimeStamp.h"
 #include <cstdlib>
 #include <cstdio>
 #include <ctime>
 #include <itksys/SystemTools.hxx>
 #include <itkMutexLockHolder.h>
 #include "mitkCommon.h"
 #include <mitkTrackingTool.h>
 #include <mitkVector.h>
 #include <itkFastMutexLock.h>
 #include "mitkIGTException.h"
 
 
 
 /**
 * \brief Function to get the Error messages from API
 */
 #include <mitkOptitrackErrorMessages.h>
 
 
 namespace mitk
 {
 
   //class OptitrackTrackingDevice;
 
   /** Documentation:
   *   \brief An object of this class represents the a Tool tracked by Optitrack System. You can define
   *  the tool by the a definition file like in the example in ****. Remember that it will be necessary to
   *  to have a license for using the Optitrack System.
   *  See  http://www.naturalpoint.com/ for details.
   *   \author E. Marinetto (emarinetto@hggm.es) Instituto de Investigación Sanitaria Gregorio Marañón, Madrid, Spain. & M. Noll (matthias.noll@igd.fraunhofer.de) Cognitive Computing & Medical Imaging | Fraunhofer IGD
   *   \ingroup IGT
   */
   class MITKIGT_EXPORT OptitrackTrackingTool : public TrackingTool
   {
   public:
     friend class OptitrackTrackingDevice;
     mitkClassMacro(mitk::OptitrackTrackingTool, mitk::TrackingTool);
     itkNewMacro(Self);
 
 
 
     /**
     * \brief Define the tool by a calibration File.
     * The file must to have the next structure. Makers locations must to have "%fe %fe %fe\n" format and in (mm). See http://www.cplusplus.com/reference/cstdio/fscanf/
     *    ToolName
-    *    #NumberOfMarkers
+    *    \#NumberOfMarkers
     *    X Y Z - for the first marker
     *    X Y Z - for the second marker
     *    ...
-    *    X Y Z - for the last marker, the number #NumberOfMarkers
+    *    X Y Z - for the last marker, the number \#NumberOfMarkers
     *    X Y Z - for the PIVOT point
     * \return Returns true if the tool was set correctly
     * @throw mitk::IGTException Throws an exception if there exist any problem during the configuration file reading.
     */
     bool SetToolByFileName(std::string nameFile);
 
     /**
     * \brief Ask API the next number of defined tool
     * \return Returns the next ID (int) for a new tool in the device list for API
     * @throw mitk::IGTException Throws an exception if get_IDnext failed
     */
     int get_IDnext();
 
     /**
     * \brief Delete the tool from the list of tools inside API Optitrack
     * \return Returns true if the deletion was correct
     * @throw mitk::IGTException Throws an exception if
     */
     bool DeleteTrackable();
 
     /**
     * \brief Set the position to a given one
     * @throw mitk::IGTException Throws an exception if
     */
     using Superclass::SetPosition;
     void SetPosition(mitk::Point3D position, ScalarType eps=0.0);
 
     /**
     * \brief Set the orientation to a given one using a quaternion nomenclature
     * @throw mitk::IGTException Throws an exception if
     */
     using Superclass::SetOrientation;
     void SetOrientation(mitk::Quaternion orientation, ScalarType eps=0.0);
 
     /**
     * \brief Get the position of the tool
     * @throw mitk::IGTException Throws an exception if
     */
     void GetPosition(mitk::Point3D& position) const override;
 
     /**
     * \brief Get the orientation of the tool using quaternion nomenclature
     * @throw mitk::IGTException Throws an exception if
     */
     void GetOrientation(mitk::Quaternion& orientation) const override;
 
     /**
     * \brief Set the tool enabled for tracking.
   * \return Return true if the enabling was successfull
     * @throw mitk::IGTException Throws an exception if
     */
     bool Enable() override;
 
     /**
     * \brief Set the tool disabled for tracking.
   * \return Return true if the disabling was successfull
     * @throw mitk::IGTException Throws an exception if
     */
     bool Disable() override;
 
     /**
     * \brief Check if the tool is enabled (true) or not.
   * \return Return true if the tool is enabled for tracking
     * @throw mitk::IGTException Throws an exception if
     */
     bool IsEnabled() const override;
 
     /**
     * \brief Check if the data of the tool is valid.
   * \return Return true if location data is valid
     * @throw mitk::IGTException Throws an exception if
     */
     bool IsDataValid() const override;
 
     /**
     * \brief Get the expectated error in the tracked tool
   * \return Return the error location
     * @throw mitk::IGTException Throws an exception if
     */
     float GetTrackingError() const override;
 
     /**
     * \brief Set the FLE (Fiducial Localization Error) for the tool
     * @throw mitk::IGTException Throws an exception if
     */
     void SetTrackingError(float FLEerror) override;
 
     /**
     * \brief Set the valid flag for tracking data to true
     * @throw mitk::IGTException Throws an exception if
     */
     void SetDataValid(bool _arg) override;
 
     /**
     * \brief Update location and orientation of the tool
     * @throw mitk::IGTException Throws an exception if
     */
     void updateTool();
 
     /**
     * \brief Constructor of the class
     */
     OptitrackTrackingTool();
 
     /**
     * \brief Destructor of the class
     */
     ~OptitrackTrackingTool() override;
 
     /**
     * \brief File of the configuration for the tool
     */
     std::string m_fileConfiguration;
 
     /**
     * \brief ID number from Optitrack API
     */
     int m_ID;
 
     /**
     * \brief List of Markers locations in calibration position and orientation
     */
     float* m_calibrationPoints;
 
     /**
     * \brief location of the pivot point during calibration
     */
     float* m_pivotPoint;
 
     /**
     * \brief Number of Markers that blong to the tool
     */
     int m_numMarkers;
 
     /**
     * \brief Expected value of the fiducial localization error (rms)
     */
   float m_FLE;
 
   private:
     OptitrackTrackingTool(const OptitrackTrackingTool&);
     const OptitrackTrackingTool& operator=(const OptitrackTrackingTool&);
 
   };
 }
 #endif /* OptiTrackTrackingTool_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
index 0146b3d8e6..928cfc9fee 100644
--- a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
@@ -1,97 +1,97 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkInteractiveTransformationWidget_H
 #define QmitkInteractiveTransformationWidget_H
 
 //QT headers
 #include <QDialog>
 
 //Mitk headers
 #include "MitkIGTUIExports.h"
 #include "mitkVector.h"
 #include "mitkGeometry3D.h"
 #include "mitkNavigationTool.h"
 
 //ui header
 #include "ui_QmitkInteractiveTransformationWidgetControls.h"
 
  /** Documentation:
   *   \brief An object of this class offers an UI to create a widget to access the advanced tool creation options.
   *
   *   \ingroup IGTUI
   */
 class MITKIGTUI_EXPORT QmitkInteractiveTransformationWidget : public QDialog
 {
   Q_OBJECT
 
   public:
     static const std::string VIEW_ID;
 
     QmitkInteractiveTransformationWidget(QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     ~QmitkInteractiveTransformationWidget() override;
 
     /** This tool will be copied to m_ToolToEdit. It will not be changed.
         To apply any changes made by this widget, you will need to connect to the signal
         EditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip) and set this transfrom
         as calibrated tool tip.
         We do not directly modify the tool to allow to cancel/exit this widget without doing
         any harm.
      */
     void SetToolToEdit(const mitk::NavigationTool::Pointer _tool);
 
     /** The sliders and spinboxes will be set to these values.
         When clicking "Revert Changes", sliders will be reseted to these values.
     */
     void SetDefaultOffset(const mitk::Point3D _defaultValues);
     void SetDefaultRotation(const mitk::Quaternion _defaultValues);
 
   protected slots:
     void OnZTranslationValueChanged(double v);
     void OnYTranslationValueChanged(double v);
     void OnXTranslationValueChanged(double v);
     void OnZRotationValueChanged(double v);
     void OnYRotationValueChanged(double v);
     void OnXRotationValueChanged(double v);
     void OnResetGeometryToIdentity();
     void OnRevertChanges();
     void OnApplyManipulatedToolTip();
     void OnCancel();
 
 signals:
     void EditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip);
 
   protected:
 
     void reject() override;
 
     virtual void CreateConnections();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     /*! \brief Method performs the rotation.
-    \params rotateVector New rotation to be combined with geometry. */
+    \param rotateVector New rotation to be combined with geometry. */
     void Rotate(mitk::Vector3D rotateVector);
 
     // Member variables
     Ui::QmitkInteractiveTransformationWidgetControls* m_Controls;
 
     mitk::NavigationTool::Pointer m_ToolToEdit;     ///< \brief this member holds a copy of the tool that should be edited for visualization
     mitk::BaseGeometry::Pointer m_Geometry;         ///< \brief The geometry that is manipulated
     mitk::BaseGeometry::Pointer m_ResetGeometry;    ///< \brief Lifeline to reset to the original geometry
 
 private:
   void SetValuesToGUI(const mitk::AffineTransform3D::Pointer _defaultValues);
   void SetSynchronizedValuesToSliderAndSpinbox(QDoubleSpinBox* _spinbox, QSlider* _slider, double _value);
 
 };
 #endif // QmitkInteractiveTransformationWidget_H
diff --git a/Modules/LegacyIO/mitkItkPictureWrite.h b/Modules/LegacyIO/mitkItkPictureWrite.h
index 4de49ba9ff..d051855aa6 100644
--- a/Modules/LegacyIO/mitkItkPictureWrite.h
+++ b/Modules/LegacyIO/mitkItkPictureWrite.h
@@ -1,42 +1,44 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 /** @file mitkItkPictureWrite.h */
 
 #ifndef MITKITKPICTUREWRITE_H
 #define MITKITKPICTUREWRITE_H
 
 #include <itkImage.h>
 #include <mitkCommon.h>
 
 /**
  * @brief ITK-Like method to be called for writing an single-component image using the AccessByItk Macros
  *
  * @param itkImage an image with single-component pixel type
+ * @param fileName the filename
  *
  * @deprecatedSince{2014_10} Use mitk::IOUtils or mitk::FileReaderRegistry instead.
  */
 template <typename TPixel, unsigned int VImageDimension>
 DEPRECATED(void _mitkItkPictureWrite(itk::Image<TPixel, VImageDimension> *itkImage, const std::string &fileName));
 
 /**
  * @brief ITK-Like method to be called for writing an image
  *
  * @param itkImage an Image with single-component or composite pixel type
+ * @param fileName the filename
  *
  * @deprecatedSince{2014_10} Use mitk::IOUtils or mitk::FileReaderRegistry instead.
  */
 template <typename TPixel, unsigned int VImageDimension>
 DEPRECATED(void _mitkItkPictureWriteComposite(itk::Image<TPixel, VImageDimension> *itkImage,
                                               const std::string &fileName));
 
 #endif /* MITKITKPICTUREWRITE_H */
diff --git a/Modules/OpenCL/mitkOclFilter.h b/Modules/OpenCL/mitkOclFilter.h
index 30439db225..29aed74597 100644
--- a/Modules/OpenCL/mitkOclFilter.h
+++ b/Modules/OpenCL/mitkOclFilter.h
@@ -1,158 +1,158 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef __mitkOclFilter_h
 #define __mitkOclFilter_h
 
 #include "mitkOclUtils.h"
 #include "mitkCommon.h"
 
 #include <vector>
 #include <usModule.h>
 
 #include <MitkOpenCLExports.h>
 
 namespace mitk
 {
 /**
    @class OclFilter
    @brief Superclass for all OpenCL based filter.
 
    This class takes care of loading and compiling the external GPU program code.
   */
 class MITKOPENCL_EXPORT OclFilter
 {
 public:
   /**
     * @brief Add a source file from the resource files to the
     *        OpenCL shader file list. Multiple files can be added to the list.
     *
     *  @param name of the file in the resource system
     */
     void AddSourceFile(const char* filename);
 
   /**
     * @brief Set specific compilerflags to compile the CL source. Default is set to nullptr;
     *        example: "-cl-fast-relaxed-math -cl-mad-enable -cl-strict-aliasing"
     *
     *  @param flags to the modulefolder that contains the gpuSource
     */
   void SetCompilerFlags(const char* flags);
 
   /**
     * @brief Returns true if the initialization was successfull
     */
   virtual bool IsInitialized();
 
   /**
     * @brief Returns the amount of global memory of the used device in bytes
     */
   virtual unsigned long GetDeviceMemory();
 
   /** @brief Destructor */
   virtual ~OclFilter();
 
 protected:
 
   typedef std::vector<const char*> CStringList;
   typedef std::vector<size_t> ClSizeList;
 
   /** @brief Constructor */
   OclFilter();
 
   /** @brief Constructor ( overloaded ) */
   OclFilter(const char* filename);
 
   /** @brief String that contains the compiler flags */
   const char* m_ClCompilerFlags;
 
   /** @brief The compiled OpenCL program */
   cl_program m_ClProgram;
 
   /** @brief Command queue for the filter */
   cl_command_queue m_CommandQue;
 
   /** @brief Unique ID of the filter, needs to be specified in the constructor of the derived class */
   std::string m_FilterID;
 
-  /*! @brief source preambel for e.g. #define commands to be inserted into the OpenCL source */
+  /*! @brief source preambel for e.g. \c \#define commands to be inserted into the OpenCL source */
   const char* m_Preambel;
 
   /** @brief List of sourcefiles that will be compiled for this filter.*/
   CStringList m_ClFiles;
 
   /** @brief  status of the filter */
   bool m_Initialized;
 
   /** @brief The local work size fo the filter */
   size_t m_LocalWorkSize[3];
 
   /** @brief The global work size of the filter */
   size_t m_GlobalWorkSize[3];
 
   /** @brief Set the working size for the following OpenCL kernel call */
   void SetWorkingSize(unsigned int locx, unsigned int dimx,
                       unsigned int locy = 1, unsigned int dimy = 1,
                       unsigned int locz = 1, unsigned int dimz = 1);
 
   /** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes
       */
   bool ExecuteKernel( cl_kernel kernel, unsigned int workSizeDim );
 
   /** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes, but divide it into chunks of dimension chunksDim
       */
   bool ExecuteKernelChunks( cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim );
 
   /** @brief Execute the given kernel on the OpenCL Index-Space defined by the local and global work sizes, but divide it into chunks of dimension chunksDim and wait between
     * batches of batchSize chunks a time of waitTimems milliseconds
   */
   bool ExecuteKernelChunksInBatches(cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim, size_t batchSize, int waitTimems);
   /**
       * \brief Initialize all necessary parts of the filter
       *
       * The Initialize() method creates the command queue and the m_clProgram.
       * The program is either compiled from the given source or taken from the
       * OclResourceManager if the program was compiled already.
       */
   bool Initialize();
 
   /**
     * @brief Compile the program source
     *
     * @param preambel e.g. defines for the shader code
     */
   void CompileSource();
 
   /**
       * @brief Add some source code on the beginning of the loaded source
       *
       * In this way, some preprocessor flags for the CL compiler can at the beginning of the filter
       * @param preambel Source preambel for e.g. #define commands to be inserted into the OpenCL source
       */
   void SetSourcePreambel(const char* preambel);
 
   /**
    * @brief Get the Module of the filter. Needs to be implemented by every subclass.
    *        The filter will load the OpenCL sourcefiles from this module context.
    */
   virtual us::Module* GetModule() = 0;
 
   /**
    * @brief Helper functions that load sourcefiles from the module context in the Initialize function.
    * @param SourceCodeList holds the sourcecode for every file as string, the SourceCodeSizeList holst the
    *        size of every file in bytes.
    */
   void LoadSourceFiles(CStringList &SourceCodeList, ClSizeList &SourceCodeSizeList);
 };
 }
 #endif // __mitkOclFilter_h
diff --git a/Modules/PhotoacousticsAlgorithms/Documentation/doxygen/PAModule.dox b/Modules/PhotoacousticsAlgorithms/Documentation/doxygen/PAModule.dox
index 2244e8e7c8..9cbcf6d54a 100644
--- a/Modules/PhotoacousticsAlgorithms/Documentation/doxygen/PAModule.dox
+++ b/Modules/PhotoacousticsAlgorithms/Documentation/doxygen/PAModule.dox
@@ -1,45 +1,45 @@
 /**
 \page PAModulePage Photoacoustic Algorithms Module
 
 \tableofcontents
 
 \section PAModulePageOverview Overview
 
 The Photoacoustic Algorithms Module provides a <strong>set of filters for beamforming and post-processing of photoacoustic and ultrasound data</strong>.
 The main features are:
 <ul>
   <li> Management of all filters through a single class PhotoacousticImage
   <li> Beamforming of ultrasound and photoacoustic image data.
   <ul>
     <li> Beamforming using the DAS and DMAS Algorithms.
     <li> Optional real-time beamforming capabilities by the usage of openCL GPU computing
   </ul>
   <li> Post/Pre-Processing of any kind of images.
   <ul>
     <li> Crop Filter for removing artefacts in upper and lower edge of the image.
     <li> Multiple B-Mode Filter implementations with resampling and logarithmic filter.
     <li> Bandpass Filter
   </ul>
 </ul>
 
 To use the GPU capabilities of this module, openCL needs to be activated in CMAKE. The custom build option "camiPhotoacousticsWorkstation" activates all needed CMAKE options, as well as openCL.
 To build the project using openCL, the openCL libraries provided by your graphic card vendor need to be installed. The GPU capabilies of this module have been only tested using nvidia hardware, but, as openCL has been also implemented by AMD, this should work on either one. (Those are included in the CUDA package for nvidia graphic card owners)
 
 The \link org_mitk_gui_qt_photoacoustics_imageprocessing Photoacoustic Imageprocessing plugin \endlink provides a GUI to access all of thePhotoacoustic Algorithms Module's filters.
 
 \section PAModuleClasses The Photoacoustic Algorithms Module's Classes
 
 <ul>
   <li> mitk::PhotoacousticImage: The class where all filters are managed.
   <li> mitk::BeamformingSettings: The class used by many filters for storing the configuration to be used when applying them.
   <li> Five filters are currently implemented in the Photoacoustic Algorithms module:
   <ul>
-    <li> mitk::PhotoacousticBModeFilter/mitk::PhotoacousticOCLBModeFilter: Two classes for the B-Mode filter on GPU and CPU.
+    <li> mitk::PhotoacousticBModeFilter: A class for the B-Mode filter on GPU and CPU.
     <li> Resampling Filter: A resampling filter for post-processing.
     <li> mitk::BeamformingFilter: A filter with a switch for GPU/CPU computation, to compute the beamformed image out of raw ultrasound/photoacoustic data.
     <li> Crop Filter: A filter for cropping artifacts on the upper and lower edges of the image.
     <li> Bandpass Filter: A Filter to filter image data in the fourier domain, using a tukey window to cut off low or high frequency parts of the image.
   </ul>
   </li>
 </ul>
 */
\ No newline at end of file
diff --git a/Modules/PhotoacousticsLib/include/mitkPAIOUtil.h b/Modules/PhotoacousticsLib/include/mitkPAIOUtil.h
index 3135e135be..bc86c01a38 100644
--- a/Modules/PhotoacousticsLib/include/mitkPAIOUtil.h
+++ b/Modules/PhotoacousticsLib/include/mitkPAIOUtil.h
@@ -1,118 +1,119 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKPHOTOACOUSTICIO_H
 #define MITKPHOTOACOUSTICIO_H
 
 #include "MitkPhotoacousticsLibExports.h"
 
 #include <map>
 #include <mutex>
 #include <thread>
 
 //Includes for smart pointer usage
 #include "mitkCommon.h"
 #include "itkLightObject.h"
 
 #include "mitkPAVolume.h"
 #include <mitkPAInSilicoTissueVolume.h>
 #include <mitkPAFluenceYOffsetPair.h>
 
 namespace mitk {
   namespace pa {
     class MITKPHOTOACOUSTICSLIB_EXPORT IOUtil final
     {
     public:
 
       struct Position
       {
         int x, z;
 
         bool operator <(const Position& rhs) const
         {
           return (x < rhs.x || ((x == rhs.x) && z < rhs.z));
         }
       };
 
       /**
        * @brief LoadFluenceContributionMaps loads multiple nrrd files from a given folder
        * and sorts them into a position map if such meta information is available in
-       * the filename. </br>
+       * the filename.
+       * 
        * As this method was specifically designed to load many fluence files, the
-       * naming convention for the position values is: </br>
+       * naming convention for the position values is:
        *
        * <b>*_pN,N,NFluence*.nrrd</b>
        *
        * @param foldername
        * @param blur
        * @param progress
        *
        * @return
        */
       static std::map<Position, Volume::Pointer> LoadFluenceContributionMaps(
         std::string foldername, double blur, int* progress, bool log10 = false);
 
       /**
        * @brief loads a nrrd file from a given filename.
        * @param filename
        * @param sigma
        * @return nullptr if the given filename was invalid.
        */
       static Volume::Pointer LoadNrrd(std::string filename, double sigma = 0);
 
       /**
       *@brief returns the number of .nrrd files in a given directory
       */
       static int GetNumberOfNrrdFilesInDirectory(std::string directory);
 
       /**
       *@brief returns a list of all .nrrd files in a given directory
       */
       static std::vector<std::string> GetListOfAllNrrdFilesInDirectory(
         std::string directory, bool keepFileFormat = false);
 
       /**
       *@brief convenience method to check wether a given strings ends on a given substring.
       *@return false if the substring is longer than the string or if the strings are empty.
       */
       static bool DoesFileHaveEnding(std::string const &fullString, std::string const &ending);
 
       /**
       *@brief returns all child folders from a folder if there is no .nrrd file in the folder
       * If there IS a .nrrd file in the folder this method will return the given folder path.
       */
       static std::vector<std::string> GetAllChildfoldersFromFolder(std::string folderPath);
 
       /**
       *@brief loads an in silico tissue volume from a saved nrrd file.
       */
       static InSilicoTissueVolume::Pointer LoadInSilicoTissueVolumeFromNrrdFile(std::string filePath);
 
       /**
        * @brief LoadFluenceSimulation
        * Adds a MC Simulation nrrd file to this composed volume.
        * The given file needs to contain the meta information "y-offset".
        * This method ensures that all added slices are in the correct order
        * corresponding to their y-offset.
        *
        * @param nrrdFile path to the nrrd file on hard drive
        */
       static FluenceYOffsetPair::Pointer LoadFluenceSimulation(std::string fluenceSimulation);
 
     private:
 
       IOUtil();
       ~IOUtil();
     };
   }
 }
 #endif // MITKPHOTOACOUSTICIO_H
diff --git a/Modules/SceneSerialization/src/mitkSceneReaderV1.h b/Modules/SceneSerialization/src/mitkSceneReaderV1.h
index d8a937531b..900026b4b4 100644
--- a/Modules/SceneSerialization/src/mitkSceneReaderV1.h
+++ b/Modules/SceneSerialization/src/mitkSceneReaderV1.h
@@ -1,74 +1,74 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkSceneReader.h"
 
 namespace mitk
 {
   class SceneReaderV1 : public SceneReader
   {
   public:
     mitkClassMacro(SceneReaderV1, SceneReader);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       bool LoadScene(TiXmlDocument &document,
                              const std::string &workingDirectory,
                              DataStorage *storage) override;
 
   protected:
     /**
-      \brief tries to create one DataNode from a given XML <node> element
+      \brief tries to create one DataNode from a given XML \<node\> element
     */
     DataNode::Pointer LoadBaseDataFromDataTag(TiXmlElement *dataElement,
                                               const std::string &workingDirectory,
                                               bool &error);
 
     /**
       \brief reads all the properties from the XML document and recreates them in node
     */
     bool DecorateNodeWithProperties(DataNode *node, TiXmlElement *nodeElement, const std::string &workingDirectory);
 
     /**
       \brief Clear a default property list and handle some exceptions.
 
       Called after assigning a BaseData object to a fresh DataNode via SetData().
       This call to SetData() would create default properties that have not been
       there when saving the scene. Since they can produce problems, we clear the
       list and use only those properties that we read from the scene file.
 
       This method also handles some exceptions for backwards compatibility.
       Those exceptions are documented directly in the code of the method.
     */
     void ClearNodePropertyListWithExceptions(DataNode &node, PropertyList &propertyList);
 
     /**
       \brief reads all properties assigned to a base data element and assigns the list to the base data object
 
       The baseDataNodeElem is supposed to be the <properties file="..."> element.
     */
     bool DecorateBaseDataWithProperties(BaseData::Pointer data,
                                         TiXmlElement *baseDataNodeElem,
                                         const std::string &workingDir);
 
     typedef std::pair<DataNode::Pointer, std::list<std::string>> NodesAndParentsPair;
     typedef std::list<NodesAndParentsPair> OrderedNodesList;
     typedef std::map<std::string, DataNode *> IDToNodeMappingType;
     typedef std::map<DataNode *, std::string> NodeToIDMappingType;
 
     OrderedNodesList m_OrderedNodePairs;
     IDToNodeMappingType m_NodeForID;
     NodeToIDMappingType m_IDForNode;
 
     UIDGenerator m_UIDGen;
   };
 }
diff --git a/Modules/ToFHardware/Documentation/doxygen/GeneratingDeviceModules.dox b/Modules/ToFHardware/Documentation/doxygen/GeneratingDeviceModules.dox
index 2a588198f6..a68f66ab75 100644
--- a/Modules/ToFHardware/Documentation/doxygen/GeneratingDeviceModules.dox
+++ b/Modules/ToFHardware/Documentation/doxygen/GeneratingDeviceModules.dox
@@ -1,90 +1,90 @@
 /**
 \page GeneratingDeviceModulesPage How to generate ToF DeviceModules
 
 The <B> ToF-DeviceModule-Tutorial</B>  will help you implementing a new ToF-Device easily.
 Using MicroServices for this purpose will be one of our main goals, too.
 
 If you do not know much about MicroServices, please take a look at:
 
 \ref MicroServices_Overview
 
 \section GeneratingDeviceModulsPageSec1 Generating a ToF-Device-Module in MITK
 
 
  In order to implement your own device, you need to code the following objects:
  <ul>
     <li>device (the device itself)
     <li>device factory (a singleton which produces instances of your device)
     <li>controller (connection to the Hardware-SDK)
     <li>Module Activator (Important for the MicroServices. This class ensures the automatic loading of the device.)
 </ul>
 
  The following example shows how to implement a device, here we take the Kinect.
 
 <ol>
  <li> <B> Creating a Sub-Folder</B>
   \n Following the Kinect-DeviceModule as a prototype, create a <EM>MODULENAME-Sub-Folder</EM> in your source directory. This MODULENAME-Folder is going to hold all the necessary files we will create in the next steps.
 
  <li> <B> Create the <EM>CMake Files</EM> for our new camera-model in the MODULENAME-Folder <</B>
    <ul>
     <li>CMakeList.txt
 
        In this file, the module is generated via CMake commands. The module name is set, the necessary libraries will be searched here in order to link them with your module. For the Kinect, we chose OpenNI and need the XnCppWrapper.h. Your device must inherit from the mitkToFCameraDevice and consequently your module must depend on mitkToFHardware -> what is the reason for the <EM>DEPENDS mitkToFHardware</EM> -line. For autoloading your Module with mitkToFHardware, insert the following CMake Macro: <EM>AUTOLOAD_WITH mitkToFHardware</EM> . We usually add an option for the user to activate the device module, but this is not essential (refer to <EM> OPTION(MITK_USE_TOF_KINECT "Enable support for Kinect camera" OFF)</EM>).
        \n -> refer to CMakeList.text in the Kinect-Folder
 
-       \Warning The dll/so files are not automatically deleted.
+       Warning: The dll/so files are not automatically deleted.
 
     \n<li>files.cmake
         The files.cmake contains all the previously mentioned files (device, deviceFactory, controller, and ModuleActivator)
        \n -> refer to mitkKinectActivator.cpp
     </ul>
 
 
  <li> <B> Creating the Code Files in the MODULENAME-Folder </B>
    <ul>
         <li>\a MODULENAMEController
         \n -> While referring to mitkKinectcontroller.cpp and the mitkKinectcontroller.h, take a good look at the definition of the MITK_KINECTMODULE_EXPORT-class in the .h file
 
         \n<li>\a MODULENAMEDevice
         Your device must inherit from ToFCameraDevice (e.g. class MITK_KINECTMODULE_EXPORT KinectDevice : public ToFCameraDevice) and consequently implement the methods of the ToFCameraDevice MicroService-Interface. (See ToFCameraDevice.h). Make sure to give your device a specific name in the method GetDeviceName(). All instances of your device will automatically be available in the view "ToFUtil", if you generate it via the factory.
         \n -> refer to mitkKinectDevice.cpp and the mitkKinectDevice.h.
 
         \n<li>\a MODULENAMEDeviceFactory
         Like the mitkToFCameraDevice, the mitkIToFDeviceFactory is a MicroService-Interface. The factory is meant for generation of devices of the same type. This concept allows for having multiple instances of the same camera connected. (Currently our GUI does not really support an actual connection of multiple devices, but the software framework, in principle, does.) Your factory must inherit from the mitkAbstractDeviceFactory, which provides some useful methods for device generation. Your factory instance should be registered as MicroService in order to be available in the view "ToF Device Generation".
         \n -> refer to mitkKinectDeviceFactory.cpp and the mitkKinectDeviceFactory.h
 
         \n<li>\a MODULENAMEActivator
         The load() method of this class will be called when the module is activated. If you would like to have an instance of your device registered as MicroService, you should call deviceFactory->ConnectToFDevice(); here. In addition, you can generate devices anywhere in your code via this method. The factory will automatically be available in the view "ToF Device Generation" if you register it like we do with the Kinect. TODO: Code example:
         \n ->refer to mitkKinectActivator.cpp and the mitkKinectActivator.h or the mitkPMDModuleActivator.cpp and the mitkPMDModuleActivator.h.
      </ul>
 </ol>
 \n
 
 If you did everything correct, your Module should be implemented an executable MODULENAME-Project will be generated and a working device should show up in the ServiceListWidget in the Connection-Part of ToFUtil.
 <B>Warning</B>   The dll/so files are not automatically deleted. After deactivating a device, please delete the concerning files in <EM>SUPERBUILDDIR/MITK-build/bin/mitkToFHardware/BUILDTYPE</EM>
 
 
 \section GeneratingDeviceModulsPageSec2 [OPTIONAL] Adding a Testing Sub-Directory
 
 If you have any Tests you want to include, a <EM>Testing-Subdirectory</EM> in the newly created MODULENAME-Folder should be created. In this Folder we are going to put a CMakeLists.txt and a files.cmake the first one will just consist
 
     \code
     MITK_CREATE_MODULE_TESTS()
     \endcode
 
 while the later one, the files.cmake holds Information about TestFiles you created and put in the Folder.
 E.g. for the Kinect:
 
    \code
     set(MODULE_TESTS
     mitkKinectControllerTest.cpp
     mitkKinectDeviceTest.cpp
     )
    \endcode
 
 As before, feel free to take a look at one of the existing Modules and their Testing-Subfolder as the Kinect´s.
 
 If you managed to implement your Module properly, an executable MODULENAMETestDriver will be generated.
 
 
 */
diff --git a/Plugins/org.blueberry.core.expressions/plugin.xml b/Plugins/org.blueberry.core.expressions/plugin.xml
index 3509a3e70b..7e2896abbf 100644
--- a/Plugins/org.blueberry.core.expressions/plugin.xml
+++ b/Plugins/org.blueberry.core.expressions/plugin.xml
@@ -1,18 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?BlueBerry version="0.1"?>
 
 <plugin>
-  <extension-point id="org.blueberry.core.expressions.propertyTesters" name="Property Tester Extension-Point" schema="schema/propertyTesters.exsd"/>
-  <extension-point id="org.blueberry.core.expressions.definitions" name="Defintions Extension-Point" schema="schema/definitions.exsd"/>
-  <extension-point id="org.blueberry.core.expressions.commonExpression" name="Common Expressions Extension-Point" schema="schema/expressionLanguage.exsd"/>
-
   <extension point="org.blueberry.core.expressions.propertyTesters">
     <propertyTester
       id="org.blueberry.core.expressions.pluginPropertyTester"
       type="berry::ObjectTypeInfo"
       namespace="org.blueberry.core.runtime"
       properties="product,isPluginInstalled,pluginState"
       class="berry::PlatformPropertyTester">
     </propertyTester>
   </extension>
 </plugin>
diff --git a/Plugins/org.blueberry.core.expressions/schema/definitions.exsd b/Plugins/org.blueberry.core.expressions/schema/definitions.exsd
deleted file mode 100755
index ad07cdb214..0000000000
--- a/Plugins/org.blueberry.core.expressions/schema/definitions.exsd
+++ /dev/null
@@ -1,166 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.core.expressions">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.core.expressions" id="definitions" name="Expression Definitions"/>
-      </appInfo>
-      <documentation>
-         &lt;p&gt;
-This extension point allows you to create reusable extensions.  They can then be used in other core expression constructs.
-&lt;/p&gt;
-&lt;p&gt;
-The reference element in a core expression will evaluated the expression definition with the evaluation context that is active for the reference element.
-&lt;/p&gt;
-
-      </documentation>
-   </annotation>
-
-   <include schemaLocation="expressionLanguage.exsd"/>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="definition" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="definition">
-      <annotation>
-         <documentation>
-            Provides a global definition of an expression to be used with the &amp;lt;reference/&amp;gt; expression element.  This helps to reuse common expressions.
-         </documentation>
-      </annotation>
-      <complexType>
-         <choice>
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-         </choice>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  A globally unique identifier for the expression definition.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         You can define and the use core expressions:
-
-&lt;p&gt;
-&lt;pre&gt;
-&amp;lt;extension point=&quot;org.blueberry.core.expressions.definitions&quot;&amp;gt;
-   &amp;lt;definition id=&quot;com.example.parts.activeProblemsView&quot;&amp;gt;
-       &amp;lt;with variable=&quot;activePartId&quot;&amp;gt;
-          &amp;lt;equals value=&quot;org.blueberry.ui.views.ProblemsView&quot;/&amp;gt;
-       &amp;lt;/with&amp;gt;
-   &amp;lt;/definition&amp;gt;
-   &amp;lt;definition id=&quot;com.example.markers.markerSelection&quot;&amp;gt;
-       &amp;lt;iterate&amp;gt;
-          &amp;lt;instanceof value=&quot;org.blueberry.core.resources.IMarker&quot;/&amp;gt;
-       &amp;lt;/with&amp;gt;
-   &amp;lt;/definition&amp;gt;
-&amp;lt;/extension&amp;gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-&lt;p&gt;
-Then this expression definition can be used when composing other expressions.
-&lt;/p&gt;
-&lt;p&gt;
-&lt;pre&gt;
-&amp;lt;enabledWhen&amp;gt;
-   &amp;lt;reference definitionId=&quot;com.example.parts.activeProblemsView&quot;&amp;gt;
-&amp;lt;/enabledWhen&amp;gt;
-&lt;/pre&gt;
-&lt;pre&gt;
-&amp;lt;visibleWhen&amp;gt;
-   &amp;lt;and&amp;gt;
-      &amp;lt;reference definitionId=&quot;com.example.parts.activeProblemsView&quot;/&amp;gt;
-      &amp;lt;reference definitionId=&quot;com.example.markers.markerSelection&quot;/&amp;gt;
-   &amp;lt;/and&amp;gt;
-&amp;lt;/visibleWhen&amp;gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         3.3
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2007 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at &lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.core.expressions/schema/expressionLanguage.exsd b/Plugins/org.blueberry.core.expressions/schema/expressionLanguage.exsd
deleted file mode 100755
index 400743a1d2..0000000000
--- a/Plugins/org.blueberry.core.expressions/schema/expressionLanguage.exsd
+++ /dev/null
@@ -1,535 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.core.expressions">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.core.expressions" id="commonExpression" name="Common Expressions"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <element name="enablement">
-      <annotation>
-         <documentation>
-            A generic root element. The element can be used inside an extension point to define its enablement expression.
-            The children of an enablement expression are combined using the and operator.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="unbounded">
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </sequence>
-      </complexType>
-   </element>
-
-   <element name="not">
-      <annotation>
-         <documentation>
-            This element represent a NOT operation on the result of evaluating it&apos;s sub-element expression.
-         </documentation>
-      </annotation>
-      <complexType>
-         <choice>
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </choice>
-      </complexType>
-   </element>
-
-   <element name="and">
-      <annotation>
-         <documentation>
-            This element represent an AND operation on the result of evaluating all it&apos;s sub-elements expressions.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="unbounded">
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </sequence>
-      </complexType>
-   </element>
-
-   <element name="or">
-      <annotation>
-         <documentation>
-            This element represent an  OR operation on the result of evaluating all it&apos;s sub-element expressions.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="unbounded">
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </sequence>
-      </complexType>
-   </element>
-
-   <element name="instanceof">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="value"/>
-         </appInfo>
-         <documentation>
-            This element is used to perform an instanceof check of the object in focus. The expression returns
-            EvaluationResult.TRUE if the object&apos;s type is a sub type of the type specified by the attribute value.
-            Otherwise EvaluationResult.FALSE is returned.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="value" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified name of a class or interface.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="java.lang.Object"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="test">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="property"/>
-         </appInfo>
-         <documentation>
-            This element is used to evaluate the property state of the object in focus. The set of
-            testable properties can be extended using the propery tester extension point. The test
-            expression returns EvaluationResult.NOT_LOADED if the property tester doing the actual
-            testing isn&apos;t loaded yet and the attribute forcePluginActivation is set to false. 
-            If forcePluginActivation is set to true and the evaluation context used to evaluate
-            this expression support plug-in activation then evaluating the property will result in 
-            activating the plug-in defining the tester.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="property" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the name of an object&apos;s property to test.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="args" type="string">
-            <annotation>
-               <documentation>
-                  additional arguments passed to the property tester. Multiple arguments are seperated
-                  by commas. Each individual argument is converted into a Java base type using the same
-                  rules as defined for the value attribute of the test expression.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="value" type="string">
-            <annotation>
-               <documentation>
-                  the expected value of the property. Can be omitted if the property 
-                  is a boolean property. The test expression is supposed to return 
-EvaluationResult.TRUE if the property matches the value and EvaluationResult.FALSE
-otherwise. The value attribute is converted into a Java base type using the following
-rules:
-&lt;ul&gt;
- &lt;li&gt;the string &amp;quot;true&amp;quot; is converted into Boolean.TRUE&lt;/li&gt;
- &lt;li&gt;the string &amp;quot;false&amp;quot; is converted into Boolean.FALSE&lt;/li&gt;
- &lt;li&gt;if the string contains a dot then the interpreter tries to convert
- the value into a Float object. If this fails the string is treated as a
- java.lang.String&lt;/li&gt;
- &lt;li&gt;if the string only consists of numbers then the interpreter
- converts the value in an Integer object.&lt;/li&gt;
- &lt;li&gt;in all other cases the string is treated as a java.lang.String&lt;/li&gt;
- &lt;li&gt;the conversion of the string into a Boolean, Float, or Integer can
- be suppressed by surrounding the string with single quotes. For
- example, the attribute value=&amp;quot;&apos;true&apos;&amp;quot; is converted into the
- string &amp;quot;true&amp;quot;&lt;/li&gt;
-&lt;/ul&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="forcePluginActivation" type="boolean">
-            <annotation>
-               <documentation>
-                  a flag indicating whether the plug-in contributing the property tester
-                  should be loaded if necessary. As such, this flag should be used judiciously, 
-                  in order to avoid unnecessary plug-in activations. Most clients should avoid
-                  setting this flag to true. This flag is only honored if the evaluation context
-                  used to evaluate this expression allows plug-in activation. Otherwise the flag
-                  is ignored and no plug-in loading takes place.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="systemTest">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="value"/>
-         </appInfo>
-         <documentation>
-            Tests a system property by calling the System.getProperty method and compares the result
-            with the value specified through the value attribute.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="property" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the name of an system property to test.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="value" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the expected value of the property. The value is interpreted as a string value.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="equals">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="value"/>
-         </appInfo>
-         <documentation>
-            This element is used to perform an equals check of the object in focus. The expression returns
-            EvaluationResult.TRUE if the object is equal to the value provided by the attribute value. Otherwise
-            EvaluationResult.FALSE is returned.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="value" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the expected value. The value provided as a string is converted into
-                  a Java base type using the same rules as for the value attribute of the test expression.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="count">
-      <annotation>
-         <documentation>
-            This element is used to test the number of elements in a collection.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="value" type="string" use="required">
-            <annotation>
-               <documentation>
-                  an expression to specify the number of elements in a list. Following wildcard
-                  characters can be used:
-                  &lt;dl&gt;
-                    &lt;dt&gt;*&lt;/dt&gt; &lt;dd&gt;any number of elements&lt;/dd&gt;
-                    &lt;dt&gt;?&lt;/dt&gt; &lt;dd&gt;no elements or one element&lt;/dd&gt;
-                    &lt;dt&gt;+&lt;/dt&gt; &lt;dd&gt;one or more elements&lt;/dd&gt;
-                    &lt;dt&gt;!&lt;/dt&gt; &lt;dd&gt;no elements&lt;/dd&gt;
-                    &lt;dt&gt;integer value&lt;/dt&gt; &lt;dd&gt;the list must contain the exact number of elements&lt;/dd&gt;
-                  &lt;/dl&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="with">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="variable"/>
-         </appInfo>
-         <documentation>
-            This element changes the object to be inspected for all its child element to the object
-            referenced by the given variable. If the variable can not be resolved then the expression
-            will throw a ExpressionException when evaluating it. The children of a with expression 
-            are combined using the and operator.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="unbounded">
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </sequence>
-         <attribute name="variable" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the name of the variable to be used for further inspection. It is up to the evaluator
-                  of an extension point to provide the variable in the variable pool.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="resolve">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="variable"/>
-         </appInfo>
-         <documentation>
-            This element changes the object to be inspected for all its child element to the object
-            referenced by the given variable. If the variable can not be resolved then the expression
-            will throw a ExpressionException when evaluating it. The children of a with expression 
-            are combined using the and operator.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="unbounded">
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </sequence>
-         <attribute name="variable" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the name of the variable to be resolved. This variable is then used as the object in focus
-                  for child element evaluation. It is up to the evaluator of an extension point to provide a 
-                  corresponding variable resolver (see IVariableResolver) through the evaluation context passed
-                  to the root expression element when evaluating the expression.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="args" type="string">
-            <annotation>
-               <documentation>
-                  additional arguments passed to the variable resolver. Multiple arguments are seperated
-                  by commas. Each individual argument is converted into a Java base type using the same
-                  rules as defined for the value attribute of the test expression.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="adapt">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="type"/>
-         </appInfo>
-         <documentation>
-            This element is used to adapt the object in focus to the type specified by the attribute
-            type. The expression returns not loaded if either the adapter or the type referenced isn&apos;t
-            loaded yet. It throws a ExpressionException during evaluation if the type name doesn&apos;t exist 
-            at all. The children of an adapt expression are combined using the and operator.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="unbounded">
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </sequence>
-         <attribute name="type" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the type to which the object in focus is to be adapted.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="java.lang.Object"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="iterate">
-      <annotation>
-         <documentation>
-            This element is used to iterate over a variable that is of type java.util.Collection. If
-            the object in focus is not of type java.util.Collection then an ExpressionException will
-            be thrown while evaluating the expression.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="unbounded">
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </sequence>
-         <attribute name="operator">
-            <annotation>
-               <documentation>
-                  either &quot;and&quot; or &quot;or&quot;. The operator defines how the child
-                  elements will be combined. If not specified, &quot;and&quot; will be used.
-               </documentation>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="or">
-                  </enumeration>
-                  <enumeration value="and">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-         <attribute name="ifEmpty" type="boolean">
-            <annotation>
-               <documentation>
-                 the value return from the iterate expression if the collection is empty. If
-                 not specified then true is returned when the operator equals &quot;and&quot; 
-                 and false is return if the operator equals &quot;or&quot;.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="reference">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="definitionId"/>
-         </appInfo>
-         <documentation>
-            This element is used to reference an expression from the &lt;b&gt;org.blueberry.core.expressions.definitions&lt;/b&gt; extension point.  The expression definition will be evaluated within the current expression element using the current evaluation context.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="definitionId" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The unique id of an expression from &lt;b&gt;org.blueberry.core.expressions.definitions&lt;/b&gt;.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         Release 3.0
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2001, 2004 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at &lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.core.expressions/schema/propertyTesters.exsd b/Plugins/org.blueberry.core.expressions/schema/propertyTesters.exsd
deleted file mode 100755
index 30f9b60ca4..0000000000
--- a/Plugins/org.blueberry.core.expressions/schema/propertyTesters.exsd
+++ /dev/null
@@ -1,146 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.core.expressions">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.core.expressions" id="propertyTesters" name="Property Testers"/>
-      </appInfo>
-      <documentation>
-         This extension point allows to add properties to an already existing type. Those
-         properties can then be used inside the expression language&apos;s test expression
-         element.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="propertyTester" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="propertyTester">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  unique identifier for the property tester
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="type" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the type to be extended by this property tester
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="namespace" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique id determining the name space the properties are added to
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="properties" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a comma separated list of properties provided by this property tester
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the name of the class that implements the testing methods. The class must be public and extend
-&lt;samp&gt;org.blueberry.core.expressions.PropertyTester&lt;/samp&gt; with a public 0-argument constructor.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.blueberry.core.expressions.PropertyTester"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         3.0
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of a property tester contribution:
-
-&lt;p&gt;
-&lt;pre&gt;
-  &lt;extension point=&quot;org.eclipse.core.expressions.propertyTesters&quot;&gt;
-    &lt;propertyTester
-      id=&quot;org.eclipse.jdt.ui.IResourceTester&quot;
-      type=&quot;org.eclipse.core.resources.IResource&quot;
-      namespace=&quot;org.eclipse.jdt.ui&quot;
-      properties=&quot;canDelete&quot;
-      class=&quot;org.eclipse.jdt.ui.internal.ResourceTester&quot;&gt;
-    &lt;/propertyTester&gt;
-  &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         The contributed class must extend &lt;code&gt;berry::PropertyTester&lt;/code&gt;
-      </documentation>
-   </annotation>
-
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2001, 2004 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at &lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.core.runtime/plugin.xml b/Plugins/org.blueberry.core.runtime/plugin.xml
index 4516950d8c..4e81473ab7 100644
--- a/Plugins/org.blueberry.core.runtime/plugin.xml
+++ b/Plugins/org.blueberry.core.runtime/plugin.xml
@@ -1,13 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?BlueBerry version="0.1"?>
 <plugin>
-  <extension-point id="org.blueberry.osgi.applications" name="Applications" schema="schema/applications.exsd"/>
-  <extension-point id="org.blueberry.core.runtime.products" name="Products" schema="schema/products.exsd"/>
   <extension
       id="error"
       point="org.blueberry.osgi.applications">
     <application visible="false">
       <run class="berry::ErrorApplication"/>
     </application>
   </extension>
 </plugin>
diff --git a/Plugins/org.blueberry.core.runtime/schema/applications.exsd b/Plugins/org.blueberry.core.runtime/schema/applications.exsd
deleted file mode 100644
index 48350bda0e..0000000000
--- a/Plugins/org.blueberry.core.runtime/schema/applications.exsd
+++ /dev/null
@@ -1,113 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.osgi" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appinfo>
-         <meta.schema plugin="org.blueberry.osgi" id="applications" name="Applications"/>
-      </appinfo>
-      <documentation>
-         The applications extension point allows plugins to contribute applications to the BlueBerry Platform.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <appinfo>
-            <meta.element />
-         </appinfo>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="1" maxOccurs="unbounded">
-            <element ref="application"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="application">
-      <complexType>
-         <sequence>
-            <element ref="run"/>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="run">
-      <complexType>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="examples"/>
-      </appinfo>
-      <documentation>
-         Following is an example of an application declaration.
-&lt;p&gt;
-   &lt;pre&gt;
-      &lt;extension id=&quot;sampleApplication&quot; point=&quot;org.blueberry.osgi.applications&quot;&gt;
-         &lt;application id=&quot;my.domain.application&quot;&gt;
-         &lt;run class=&quot;xyz::SampleApp&quot;/&gt;
-         &lt;/application&gt;
-      &lt;/extension&gt;
-   &lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="apiInfo"/>
-      </appinfo>
-      <documentation>
-         Application classes must subclass &lt;code&gt;berry::IApplication&lt;/code&gt;.
-      </documentation>
-   </annotation>
-
-
-
-</schema>
diff --git a/Plugins/org.blueberry.core.runtime/schema/products.exsd b/Plugins/org.blueberry.core.runtime/schema/products.exsd
deleted file mode 100644
index 39956abccc..0000000000
--- a/Plugins/org.blueberry.core.runtime/schema/products.exsd
+++ /dev/null
@@ -1,213 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.core.runtime">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.core.runtime" id="products" name="Products"/>
-      </appInfo>
-      <documentation>
-         Products are the BlueBerry unit of branding.  Product extensions are supplied by plug-ins wishing to define one or more products.  There must be one product per extension as the extension id is used in processing and identifying the product.
-&lt;p&gt;
-There are two possible forms of product extension, static and dynamic.  Static product extensions directly contain all relevant information about the product.  Dynamic product extensions identify a class (an &lt;code&gt;IProductProvider&lt;/code&gt;) which is capable of defining one or more products when queried.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <choice>
-               <element ref="product"/>
-               <element ref="provider"/>
-            </choice>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="product">
-      <complexType>
-         <sequence>
-            <element ref="property" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="application" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the default application to run when running this product
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the human-readable name of this product
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="description" type="string">
-            <annotation>
-               <documentation>
-                  the human-readable description of this product
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="property">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="name"/>
-         </appInfo>
-      </annotation>
-      <complexType>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the key under which this property is stored
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="value" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the value of this property
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="provider">
-      <annotation>
-         <documentation>
-            details of a product provider
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="run"/>
-         </sequence>
-      </complexType>
-   </element>
-
-   <element name="run">
-      <complexType>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the fully-qualified name of a class which implements
-&lt;samp&gt;berry::IProductProvider&lt;/samp&gt;.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         next_release
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         Following is an example of static product declaration:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension id=&quot;coolProduct&quot; point=&quot;org.blueberry.core.runtime.products&quot;&gt;
-      &lt;product name=&quot;%coolName&quot; application=&quot;coolApplication&quot; description=&quot;%coolDescription&quot;&gt;
-          &lt;property name=&quot;windowImages&quot; value=&quot;window.gif&quot;/&gt;
-          &lt;property name=&quot;aboutImage&quot; value=&quot;image.gif&quot;/&gt;
-          &lt;property name=&quot;aboutText&quot; value=&quot;%aboutText&quot;/&gt;
-          &lt;property name=&quot;appName&quot; value=&quot;CoolApp&quot;/&gt;
-          &lt;property name=&quot;welcomePage&quot; value=&quot;$nl$/welcome.xml&quot;/&gt;
-          &lt;property name=&quot;preferenceCustomization&quot; value=&quot;plugin_customization.ini&quot;/&gt;
-      &lt;/product&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-
-The following is an example of a dynamic product (product provider) declaration:
-Following is an example of an application declaration:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension id=&quot;coolProvider&quot; point=&quot;org.blueberry.core.runtime.products&quot;&gt;
-      &lt;provider&gt;
-         &lt;run class=&quot;me::CoolProvider&quot;/&gt;
-      &lt;/provider&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         Static product extensions provided here are represented at runtime by instances of &lt;code&gt;IProduct&lt;/code&gt;.  Dynamic product extensions must identify an implementor of &lt;code&gt;IProductProvider&lt;/code&gt;.  See &lt;code&gt;IProductConstants&lt;/code&gt;
-for details of the branding related product properties defined by the Eclipse UI.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         No implementations of &lt;code&gt;IProductProvider&lt;/code&gt; are supplied.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2004, 2005 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which
-accompanies
-this distribution, and is available at
-&lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.core.runtime/src/berryObjectGeneric.h b/Plugins/org.blueberry.core.runtime/src/berryObjectGeneric.h
index 626a57bdfa..13aae27040 100755
--- a/Plugins/org.blueberry.core.runtime/src/berryObjectGeneric.h
+++ b/Plugins/org.blueberry.core.runtime/src/berryObjectGeneric.h
@@ -1,109 +1,110 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef BERRYOBJECTGENERIC_H_
 #define BERRYOBJECTGENERIC_H_
 
 #include <sstream>
 #include <org_blueberry_core_runtime_Export.h>
 #include "berryMacros.h"
 #include "berryObject.h"
 
 namespace berry {
 
 template <typename T>
 class org_blueberry_core_runtime_EXPORT ObjectGeneric : public Object
 {
   public:
 
     berryObjectMacro(ObjectGeneric);
 
     typedef T ValueType;
 
     ObjectGeneric() : m_Value(0) {}
     ObjectGeneric(T x) : m_Value(x) {}
     //ObjectGeneric(const Self& o) { m_Value = o.m_Value; }
 
     ~ObjectGeneric() override
     {
     }
 
     void SetValue(T val) {
       m_Value = val;
     }
 
     T GetValue() const {
       return m_Value;
     }
 
     bool operator==(const Object* o) const override
     {
       if(const Self* other = dynamic_cast<const Self*>(o))
         return (this->m_Value == other->m_Value);
 
       return false;
     }
 
     virtual std::string GetValueAsString() const
     {
       std::stringstream myStr;
       std::locale originalLocale = myStr.getloc();
       std::locale C("C");
       myStr.imbue(C);
       myStr << GetValue() ;
       myStr.imbue(originalLocale);
       return myStr.str();
     }
 
     virtual bool Assignable(Object::ConstPointer other) const
     {
       return other.Cast<const Self>() != 0;
     }
 
     virtual void Assign(Object::ConstPointer other)
     {
       ConstPointer specOther = other.Cast<const Self>();
 
       if (specOther && this->m_Value != specOther->m_Value)
       {
         this->m_Value = specOther->m_Value;
       }
     }
 
   protected:
 
     T m_Value;
 };
 
 
 } // namespace berry
 
 /**
  * Generates a specialized subclass of berry::ObjectGeneric.
  * This way, GetClassName() returns the value provided by ObjectName.
  * Please see berryObjects.h for examples
  * @param ObjectName the name of the instantiation of ObjectGeneric
  * @param Type the value type
+ * @param DefaultValue the default value
  */
 #define berrySpecializeGenericObject(ObjectName,Type,DefaultValue)   \
 class org_blueberry_core_runtime_EXPORT ObjectName: public ::berry::ObjectGeneric< Type > \
 {                                                                    \
 public:                                                              \
   berryObjectMacro(ObjectName);                                      \
   ObjectName() : ::berry::ObjectGeneric< Type >(DefaultValue) { }    \
   ObjectName(Type x) : ::berry::ObjectGeneric<Type>(x) {}            \
   QString ToString() const { QString txt; QTextStream ts(&txt); ts << m_Value; return txt; } \
 };
 
 
 #endif /* BERRYOBJECTGENERIC_H_ */
diff --git a/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/Logging.png b/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/Logging.png
deleted file mode 100644
index 33cd6a983c..0000000000
Binary files a/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/Logging.png and /dev/null differ
diff --git a/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/blueberrylogview.dox b/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/blueberrylogview.dox
index 4f4fa8fde2..f4a0815bae 100644
--- a/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/blueberrylogview.dox
+++ b/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/blueberrylogview.dox
@@ -1,16 +1,16 @@
 /**
 \page org_blueberry_views_logview The Logging Plugin
 
-\imageMacro{logging.svg,"Icon of the Logging Plugin",2.00}
+\imageMacro{logview-dox.svg,"Icon of the Logging Plugin",2.00}
 
 This plug-in records all logging output of events and progress as specified in the source code with time of occurrence, level of importance (Info, Warning, Error, Fatal, Debug), the message given and the origin of the message (source code section).
 
 \imageMacro{LogView.png,"Screenshot of the Logging Plugin",16.00}
 
 There are different features available in the view. The 'Filter' text field provides the possibility to search for all log events containing a certain substring. The 'Copy to clipboard' button allows you to copy the current content of the logging view to your clipboard. This enables you to insert the logging information to any text processing application.
 
 In the simple logging view, you'll see logging messages and logging levels. A brief description of the logging levels can be found in the \ref LoggingPage "logging concept documentation". With two checkboxes more information on every logging message can be activated. The checkbox 'categories' adds a column for the category. The checkbox 'advanced fields' additionally displays the time from application start to the log message entry and the function, filename and line number of the logging message origin.
 
 \imageMacro{LogViewExplain.png,"Details on the Vizualized Logging Information",16.00}
 
 */
diff --git a/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/logging.svg b/Plugins/org.blueberry.ui.qt.log/documentation/UserManual/logview-dox.svg
similarity index 100%
rename from Plugins/org.blueberry.ui.qt.log/documentation/UserManual/logging.svg
rename to Plugins/org.blueberry.ui.qt.log/documentation/UserManual/logview-dox.svg
diff --git a/Plugins/org.blueberry.ui.qt.objectinspector/documentation/UserManual/ObjectBrowser.png b/Plugins/org.blueberry.ui.qt.objectinspector/documentation/UserManual/ObjectBrowser.png
deleted file mode 100644
index b10161cf1b..0000000000
Binary files a/Plugins/org.blueberry.ui.qt.objectinspector/documentation/UserManual/ObjectBrowser.png and /dev/null differ
diff --git a/Plugins/org.blueberry.ui.qt/plugin.xml b/Plugins/org.blueberry.ui.qt/plugin.xml
index 561a9ec8a7..4da5fa1273 100644
--- a/Plugins/org.blueberry.ui.qt/plugin.xml
+++ b/Plugins/org.blueberry.ui.qt/plugin.xml
@@ -1,465 +1,451 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?BlueBerry version="0.1"?>
 <plugin>
-
-   <extension-point id="org.blueberry.ui.commands" name="Commands" schema="schema/commands.exsd"/>
-   <extension-point id="org.blueberry.ui.editors" name="Editors" schema="schema/editors.exsd"/>
-   <extension-point id="org.blueberry.ui.handlers" name="Handlers" schema="schema/handlers.exsd"/>
-   <extension-point id="org.blueberry.ui.intro" name="Introduction Extensions" schema="schema/intro.exsd"/>
-   <extension-point id="org.blueberry.ui.preferencePages" name="Preference Pages" schema="schema/preferencePages.exsd"/>
-   <extension-point id="org.blueberry.ui.views" name="Views" schema="schema/views.exsd"/>
-   <extension-point id="org.blueberry.ui.keywords" name="keywords" schema="schema/keywords.exsd"/>
-   <extension-point id="org.blueberry.ui.tweaklets" name="Tweaklets" schema="schema/tweaklets.exsd"/>
-   <extension-point id="org.blueberry.ui.perspectives" name="Perspectives" schema="schema/perspectives.exsd"/>
-   <extension-point id="org.blueberry.ui.presentationFactories" name="Presentation Factories" schema="schema/presentationFactories.exsd"/>
-   <extension-point id="org.blueberry.ui.services" name="Services" schema="schema/services.exsd"/>
-   <extension-point id="org.blueberry.ui.perspectiveExtensions" name="Perspective Extensions" schema="schema/perspectiveExtensions.exsd"/>
-
    <extension point="org.blueberry.ui.services">
 
       <serviceFactory factoryClass="berry::WorkbenchSupportFactory">
          <service serviceClass="org.blueberry.ui.IProgressService"/>
          <service serviceClass="org.blueberry.ui.IWorkbenchSiteProgressService"/>
          <service serviceClass="org.blueberry.ui.IPartService"/>
          <service serviceClass="org.blueberry.ui.IPageService"/>
          <service serviceClass="org.blueberry.ui.ISelectionService"/>
       </serviceFactory>
 
       <serviceFactory factoryClass="berry::HandlerServiceFactory">
          <service serviceClass="org.blueberry.ui.IHandlerService"/>
       </serviceFactory>
 
       <serviceFactory factoryClass="berry::EvaluationServiceFactory">
          <service serviceClass="org.blueberry.ui.IEvaluationService"/>
       </serviceFactory>
 <!--
       <serviceFactory factoryClass="berry::ContextServiceFactory">
          <service serviceClass="org.blueberry.ui.IContextService"/>
       </serviceFactory>
 -->
       <serviceFactory factoryClass="berry::CommandServiceFactory">
          <service serviceClass="org.blueberry.ui.ICommandService"/>
       </serviceFactory>
 
       <serviceFactory factoryClass="berry::MenuServiceFactory">
          <service serviceClass="org.blueberry.ui.IMenuService"/>
       </serviceFactory>
 
       <sourceProvider provider="berry::WorkbenchSourceProvider">
          <variable name="selection" priorityLevel="workbench"/>
          <variable name="activeShell" priorityLevel="workbench"/>
          <variable name="activeWorkbenchWindow" priorityLevel="workbench"/>
          <variable name="activeWorkbenchWindowShell" priorityLevel="workbench"/>
          <variable name="activeWorkbenchWindow.isToolbarVisible" priorityLevel="workbench"/>
          <variable name="activeWorkbenchWindow.isPerspectiveBarVisible" priorityLevel="workbench"/>
          <variable name="activeWorkbenchWindow.isSatusLineVisible" priorityLevel="workbench"/>
          <variable name="activeWorkbenchWindow.activePerspective" priorityLevel="workbench"/>
          <variable name="activeEditor" priorityLevel="workbench"/>
          <variable name="activeEditorId" priorityLevel="workbench"/>
          <variable name="activePart" priorityLevel="workbench"/>
          <variable name="activePartId" priorityLevel="workbench"/>
          <variable name="activeSite" priorityLevel="workbench"/>
          <variable name="activeEditorInput" priorityLevel="workbench"/>
       </sourceProvider>
 
    </extension>
 
    <extension point="org.blueberry.ui.commands">
      <category
        name="File"
        description=""
        id="org.blueberry.ui.category.file" />
      <category
        name="Edit"
        description=""
        id="org.blueberry.ui.category.edit" />
      <category
        name="Window"
        description=""
        id="org.blueberry.ui.category.window" />
      <category
        name="Help"
        description=""
        id="org.blueberry.ui.category.help" />
      <category
        name="Views"
        description="Commands for opening views"
        id="org.blueberry.ui.category.views">
      </category>
      <category
        name="Perspectives"
        description="Commands for opening perspectives"
        id="org.blueberry.ui.category.perspectives">
      </category>
 
      <command
         name="Save"
         description="Save the current contents"
         categoryId="org.blueberry.ui.category.file"
         id="org.blueberry.ui.file.save" />
      <!--
      <command
         name="Save"
         description="Save the current contents"
         categoryId="org.blueberry.ui.category.file"
         defaultHandler="berry::SaveHandler"
         id="org.blueberry.ui.file.save" />
      -->
      <command
         categoryId="org.blueberry.ui.category.file"
         defaultHandler="berry::QuitHandler"
         description="Exit the application"
         id="org.blueberry.ui.file.exit"
         name="Exit"/>
      <command
         name="Undo"
         description="Undo the last operation"
         categoryId="org.blueberry.ui.category.edit"
         id="org.blueberry.ui.edit.undo" />
      <command
         name="Redo"
         description="Redo the last operation"
         categoryId="org.blueberry.ui.category.edit"
         id="org.blueberry.ui.edit.redo" />
      <command
         name="Cut"
         description="Cut the selection to the clipboard"
         categoryId="org.blueberry.ui.category.edit"
         id="org.blueberry.ui.edit.cut" />
      <command
         name="Copy"
         description="Copy the selection to the clipboard"
         categoryId="org.blueberry.ui.category.edit"
         id="org.blueberry.ui.edit.copy" />
      <command
         name="Paste"
         description="Paste from the clipboard"
         categoryId="org.blueberry.ui.category.edit"
         id="org.blueberry.ui.edit.paste" />
      <command
         name="Delete"
         description="Delete the selection"
         categoryId="org.blueberry.ui.category.edit"
         id="org.blueberry.ui.edit.delete" />
 
      <command
        name="Help Contents"
        description="Open the help contents"
        categoryId="org.blueberry.ui.category.help"
        defaultHandler="berry::HelpContentsHandler"
        id="org.blueberry.ui.help.helpContents" />
      <!--
      <command
        name="Help Search"
        description="Open the help search"
        categoryId="org.blueberry.ui.category.help"
        defaultHandler="berry::HelpSearchHandler"
        id="org.blueberry.ui.help.helpSearch" />
      -->
      <command
        name="Dynamic Help"
        description="Open the dynamic help"
        categoryId="org.blueberry.ui.category.help"
        defaultHandler="berry::DynamicHelpHandler"
        id="org.blueberry.ui.help.dynamicHelp" />
      <command
        name="Welcome"
        description="Show help for beginning users"
        categoryId="org.blueberry.ui.category.help"
        id="org.blueberry.ui.help.intro" />
      <command
        name="About"
        description="Open the about dialog"
        categoryId="org.blueberry.ui.category.help"
        helpContextId="org.blueberry.ui.about_action_context"
        id="org.blueberry.ui.help.aboutAction" />
      <command
         name="Show View"
         description="Shows a particular view"
         id="org.blueberry.ui.views.showView"
         defaultHandler="berry::ShowViewHandler">
         <commandParameter
           id="org.blueberry.ui.views.showView.viewId"
           name="View"
           values="berry::ViewParameterValues" />
         <commandParameter
           id="org.blueberry.ui.views.showView.secondaryId"
           name="Secondary Id"
           optional="true"/>
      </command>
      <command
         name="Save Perspective As"
         description="Save the current perspective"
         categoryId="org.blueberry.ui.category.window"
         id="org.blueberry.ui.window.savePerspective" />
      <command
         name="Close All Perspectives"
         description="Close all open perspectives"
         categoryId="org.blueberry.ui.category.window"
         id="org.blueberry.ui.window.closeAllPerspectives" />
      <command
         name="Close Perspective"
         description="Close the current perspective"
         categoryId="org.blueberry.ui.category.window"
         id="org.blueberry.ui.window.closePerspective">
         <commandParameter
           id="org.blueberry.ui.window.closePerspective.perspectiveId"
           name="Perspective Id"
           optional="true"
           values="berry::PerspectiveParameterValues">
         </commandParameter>
      </command>
      <command
         name="Reset Perspective"
         description="Reset the current perspective to its default state"
         categoryId="org.blueberry.ui.category.window"
         id="org.blueberry.ui.window.resetPerspective" />
 
      <command
         categoryId="org.blueberry.ui.category.perspectives"
         defaultHandler="berry::ShowPerspectiveHandler"
         description="Show a particular perspective"
         id="org.blueberry.ui.perspectives.showPerspective"
         name="Show Perspective">
         <commandParameter
            id="org.blueberry.ui.perspectives.showPerspective.perspectiveId"
            name="Parameter"
            values="berry::PerspectiveParameterValues">
         </commandParameter>
         <commandParameter
            id="org.blueberry.ui.perspectives.showPerspective.newWindow"
            name="In New Window"
            optional="true">
         </commandParameter>
      </command>
 
      <command
         categoryId="org.blueberry.ui.category.window"
         description="Open the preferences dialog"
         id="org.blueberry.ui.window.preferences"
         name="Preferences">
         <commandParameter
            id="preferencePageId"
            name="Preference Page"
            optional="true"
            values="berry::PreferencePageParameterValues"/>
      </command>
 
      <command
         categoryId="org.blueberry.ui.category.window"
         defaultHandler="berry::OpenInNewWindowHandler"
         description="Open another window"
         id="org.blueberry.ui.window.newWindow"
         name="New Window"/>
      <command
         name="New Editor"
         description="Open another editor on the active editor's input"
         categoryId="org.blueberry.ui.category.window"
         id="org.blueberry.ui.window.newEditor"/>
 
    </extension>
 
   <extension point="org.blueberry.core.expressions.propertyTesters">
     <propertyTester
       class="berry::OpenPerspectivePropertyTester"
       id="org.blueberry.ui.openPerspectivePropertyTester"
       namespace="org.blueberry.ui.workbenchWindow"
       properties="isPerspectiveOpen"
       type="berry::IWorkbenchWindow">
     </propertyTester>
   </extension>
 
    <extension point="org.blueberry.ui.handlers">
      <handler
        class="berry::NewEditorHandler"
        commandId="org.blueberry.ui.window.newEditor">
        <enabledWhen>
          <with variable="activeEditor">
            <instanceof value="berry::IEditorPart"/>
          </with>
        </enabledWhen>
      </handler>
      <handler
        class="berry::SavePerspectiveHandler"
        commandId="org.blueberry.ui.window.savePerspective">
        <enabledWhen>
          <or>
            <with variable="activeWorkbenchWindow">
              <test property="org.blueberry.ui.workbenchWindow.isPerspectiveOpen"/>
            </with>
            <!-- this is a workaround to evaluate the expression -->
            <with variable="activePart">
              <instanceof value="berry::IWorkbenchPart"/>
            </with>
          </or>
        </enabledWhen>
      </handler>
      <handler
        class="berry::CloseAllPerspectivesHandler"
        commandId="org.blueberry.ui.window.closeAllPerspectives">
        <enabledWhen>
          <or>
            <with variable="activeWorkbenchWindow">
              <test property="org.blueberry.ui.workbenchWindow.isPerspectiveOpen"/>
            </with>
            <!-- this is a workaround to evaluate the expression -->
            <with variable="activePart">
              <instanceof value="berry::IWorkbenchPart"/>
            </with>
          </or>
        </enabledWhen>
      </handler>
      <handler
        class="berry::ClosePerspectiveHandler"
        commandId="org.blueberry.ui.window.closePerspective">
        <enabledWhen>
          <or>
            <with variable="activeWorkbenchWindow">
              <test property="org.blueberry.ui.workbenchWindow.isPerspectiveOpen"/>
            </with>
            <!-- this is a workaround to evaluate the expression -->
            <with variable="activePart">
              <instanceof value="berry::IWorkbenchPart"/>
            </with>
          </or>
        </enabledWhen>
      </handler>
      <handler
        class="berry::ResetPerspectiveHandler"
        commandId="org.blueberry.ui.window.resetPerspective">
        <enabledWhen>
          <or>
            <with variable="activeWorkbenchWindow">
              <test property="org.blueberry.ui.workbenchWindow.isPerspectiveOpen"/>
            </with>
            <!-- this is a workaround to evaluate the expression -->
            <with variable="activePart">
              <instanceof value="berry::IWorkbenchPart"/>
            </with>
          </or>
        </enabledWhen>
      </handler>
      <handler
        class="berry::IntroHandler"
        commandId="org.blueberry.ui.help.intro">
        <enabledWhen>
          <or>
            <with variable="activeWorkbenchWindow">
              <test property="org.blueberry.ui.workbenchWindow.isPerspectiveOpen"/>
            </with>
            <!-- this is a workaround to evaluate the expression -->
            <with variable="activePart">
              <instanceof value="berry::IWorkbenchPart"/>
            </with>
          </or>
        </enabledWhen>
      </handler>
      <handler
        class="berry::HelpContentsHandler"
        commandId="org.blueberry.ui.help.helpContents">
        <enabledWhen>
          <or>
            <with variable="org.blueberry.core.runtime.Platform">
              <test property="org.blueberry.core.runtime.pluginState" args="org.blueberry.ui.qt.help" value="STARTING"/>
            </with>
            <with variable="org.blueberry.core.runtime.Platform">
              <test property="org.blueberry.core.runtime.pluginState" args="org.blueberry.ui.qt.help" value="ACTIVE"/>
            </with>
          </or>
        </enabledWhen>
      </handler>
      <handler
        class="berry::DynamicHelpHandler"
        commandId="org.blueberry.ui.help.dynamicHelp">
        <enabledWhen>
          <or>
            <with variable="org.blueberry.core.runtime.Platform">
              <test property="org.blueberry.core.runtime.pluginState" args="org.blueberry.ui.qt.help" value="STARTING"/>
            </with>
            <with variable="org.blueberry.core.runtime.Platform">
              <test property="org.blueberry.core.runtime.pluginState" args="org.blueberry.ui.qt.help" value="ACTIVE"/>
            </with>
          </or>
        </enabledWhen>
      </handler>
    </extension>
 
    <extension point="org.blueberry.ui.views">
       <category
             name="General"
             id="org.blueberry.ui"/>
       <view
             class="berry::ViewIntroAdapterPart"
             category="org.blueberry.ui"
             name="Welcome"
             id="org.blueberry.ui.internal.introview"/>
       <stickyView
             location="RIGHT"
             id="org.blueberry.ui.internal.introview"/>
    </extension>
 
    <extension point="org.blueberry.ui.editors">
       <editor
             class="berry::EditorIntroAdapterPart"
             name="Welcome"
             id="org.blueberry.ui.internal.introeditor">
       </editor>
    </extension>
 
    <extension point="org.blueberry.ui.tweaklets">
       <tweaklet
          id="org.blueberry.ui.qt.tweaklets.WorkbenchTweaklet"
          name="Qt Workbench Tweaklet"
          description="Qt specific Workbench tweaks"
          definition="org.blueberry.WorkbenchTweaklet"
          implementation="berry::QtWorkbenchTweaklet" />
 
       <tweaklet
          id="org.blueberry.ui.qt.tweaklets.WorkbenchPageTweaklet"
          name="Qt WorkbenchPage Tweaklet"
          description="Qt specific WorkbenchPage tweaks"
          definition="org.blueberry.WorkbenchPageTweaklet"
          implementation="berry::QtWorkbenchPageTweaklet" />
 
       <tweaklet
          id="org.blueberry.ui.qt.tweaklets.GuiWidgetsTweaklet"
          name="Qt Widgets Tweaklet"
          description="Qt specific widget tweaks"
          definition="org.blueberry.GuiWidgetsTweaklet"
          implementation="berry::QtWidgetsTweaklet" />
 
        <tweaklet
          id="org.blueberry.ui.qt.tweaklets.DnDTweaklet"
          name="Qt DnD Tweaklet"
          description="Qt specific DnD tweaks"
          definition="org.blueberry.DnDTweaklet"
          implementation="berry::QtDnDTweaklet" />
 
        <tweaklet
          id="org.blueberry.ui.qt.tweaklets.ImageTweaklet"
          name="Qt Image Tweaklet"
          description="Qt specific image tweaks"
          definition="org.blueberry.ImageTweaklet"
          implementation="berry::QtImageTweaklet" />
 
        <tweaklet
          id="org.blueberry.ui.qt.tweaklets.MessageDialogTweaklet"
          name="Qt Message Dialog Tweaklet"
          description="Qt specific message dialogs"
          definition="org.blueberry.MessageDialogTweaklet"
          implementation="berry::QtMessageDialogTweaklet" />
    </extension>
 
    <extension point="org.blueberry.ui.presentationFactories">
       <factory
             name="Default"
             class="berry::QtWorkbenchPresentationFactory"
             id="org.blueberry.ui.presentations.default">
       </factory>
    </extension>
 
    <extension point="org.blueberry.ui.keywords">
      <keyword id="org.blueberry.ui.style" label="themes skins styles appearance icons search path "/>
      <keyword id="org.blueberry.ui.perspectives" label="open view switch perspectives same window new help research available viewer visualization"/>
    </extension>
 </plugin>
diff --git a/Plugins/org.blueberry.ui.qt/schema/commands.exsd b/Plugins/org.blueberry.ui.qt/schema/commands.exsd
deleted file mode 100755
index 84ddaf81da..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/commands.exsd
+++ /dev/null
@@ -1,466 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appinfo>
-         <meta.schema plugin="org.blueberry.ui" id="commands" name="Commands"/>
-      </appinfo>
-      <documentation>
-         &lt;p&gt;
-The &lt;code&gt;org.blueberry.ui.commands&lt;/code&gt; extension point is used to declare commands and command categories, using the &lt;code&gt;command&lt;/code&gt; and &lt;code&gt;category&lt;/code&gt; elements. A command is an abstract representation of some semantic behaviour, but not it&apos;s actual implementation.  This allows different developers to contribute specific behaviour for their individual parts.  For example, there might be a &quot;paste&quot; command with one implementation in an editor and a different implementation in an explorer widget.  These implementations are called handlers.  Commands can also be viewed as declarative function pointers, or signal handlers.
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <appinfo>
-            <meta.element />
-         </appinfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="category" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="command" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="commandParameterType" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  An optional identifier of the extension instance.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  An optional name of the extension instance.
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  A fully qualified identifier of the target extension point.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="command">
-      <annotation>
-         <documentation>
-            &lt;p&gt;
-This element is used to define commands. A command represents an request from the user that can be handled by an action, and should be semantically unique among other commands. Do not define a command if there is already one defined with the same meaning. If more than one of these elements exist with the same &lt;code&gt;id&lt;/code&gt; attribute, only the last declared element (in order of reading the plugin registry) is considered valid. See the extension points &lt;a href=&quot;org_blueberry_ui_actionSets.html&quot;&gt;org.blueberry.ui.actionSets&lt;/a&gt; and &lt;a href=&quot;org_blueberry_ui_editorActions.html&quot;&gt;org.blueberry.ui.editorActions&lt;/a&gt; to understand how actions are connected to commands.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="defaultHandler" minOccurs="0" maxOccurs="1"/>
-            <element ref="state" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="commandParameter" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="description" type="string">
-            <annotation>
-               <documentation>
-                  A translatable short description of this command for display in the UI.
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The unique identifier of this command.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The translatable name of this command for display in the UI. Commands are typically named in the form of an imperative verb.
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="categoryId" type="string">
-            <annotation>
-               <documentation>
-                  The unique id of the category for this command. If this command does not specify a category it will be placed in an global &quot;Uncategorized&quot; category.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="defaultHandler" type="string">
-            <annotation>
-               <documentation>
-                  The default handler for this command (see the &lt;a href=&quot;org_blueberry_ui_handlers.html&quot;&gt;org.blueberry.ui.handlers&lt;/a&gt; extension point).  If no other handler is active, this handler will be active.  This handler will conflict with other handler definitions that specify no &lt;code&gt;activeWhen&lt;/code&gt; conditions.  If you are creating an &lt;code&gt;IExecutableExtension&lt;/code&gt;, you can use the &lt;code&gt;defaultHandler&lt;/code&gt; element instead.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="returnTypeId" type="string">
-            <annotation>
-               <documentation>
-                  The id of a &lt;code&gt;commandParameterType&lt;/code&gt; indicating the type of value returned by this command.  Specifying a &lt;code&gt;returnTypeId&lt;/code&gt; allows clients executing the command to associate the value returned with a type and to convert the value to a QString form that may be stored and/or passed to another command that accepts parameters of the same type.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="helpContextId" type="string">
-            <annotation>
-               <documentation>
-                  The identifier of the help context that relates to this command in general.  Handlers can override this context identifier to provide help that is more specific to their particular behaviours.
-&lt;p&gt;&lt;em&gt;Not used yet&lt;/em&gt;&lt;/p&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="category">
-      <annotation>
-         <documentation>
-            &lt;p&gt;
-In the UI, commands are often organized by category to make them more manageable. This element is used to define these categories. Commands can add themselves to at most one category. If more than one of these elements exist with the same &lt;code&gt;id&lt;/code&gt; attribute, only the last declared element (in order of reading the plugin registry) is considered valid.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="description" type="string">
-            <annotation>
-               <documentation>
-                  A translatable short description of this category for display in the UI.
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The unique identifier of this category.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The translatable name of this category for display in the UI.
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="commandParameter">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="id"/>
-         </appinfo>
-         <documentation>
-            &lt;p&gt;
-Defines a parameter that a command should understand.  A parameter is a way to provide more information to a handler at execution time.  For example, a &quot;show view&quot; command might take a view as a parameter.  Handlers should be able to understand these parameters, so they should be treated like API.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="values" minOccurs="0" maxOccurs="1"/>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The unique identifier for this parameter.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The name for the parameter.  This is the name as it will be displayed to an end-user.  As such, it should be translatable.  The name should be short -- preferrably one word.
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="values" type="string">
-            <annotation>
-               <documentation>
-                  The class providing a list of parameter values for the user to select.  This class should implement &lt;code&gt;org.blueberry.core.commands.IParameterValues&lt;/code&gt;.  If this class is not specified, you must specify the more verbose &lt;code&gt;values&lt;/code&gt; element.  Please see &lt;code&gt;org.blueberry.osgi.IExecutableExtension&lt;/code&gt;.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn=":org.blueberry.core.commands.IParameterValues"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="typeId" type="string">
-            <annotation>
-               <documentation>
-                  The id of a commandParameterType for this commandParameter.  Specifying a typeId allows handlers of a command to convert string parameter values to objects in a consistent way and it allows potential callers of a command to look for commands that take objects of various types for their parameters.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="optional" type="boolean" use="default" value="true">
-            <annotation>
-               <documentation>
-                  Whether this parameter is optional.  If a parameter is optional, the handler should be able to handle the absence of the parameter.  By default, all parameters are optional.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="commandParameterType">
-      <annotation>
-         <documentation>
-            &lt;p&gt;
-Defines the object type of a commandParameter and may specify an &lt;code&gt;org.blueberry.core.commands.AbstractParameterValueConverter&lt;/code&gt; subclass to convert between string parameter values and objects.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The unique identifier for this commandParameterType.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="type" type="string">
-            <annotation>
-               <documentation>
-                  The fully qualified name of a class to use as the type of this command parameter.  This attribute is optional, however if omitted, &lt;code&gt;org.blueberry.osgi.Object&lt;/code&gt; will be used as the parameter type.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="converter" type="string">
-            <annotation>
-               <documentation>
-                  The class for converting between objects and string representations of objects for command parameter values.  This class should extend &lt;code&gt;org.blueberry.core.commands.AbstractParameterValueConverter&lt;/code&gt;. The converter should produce and consume objects of the type indicated in the &lt;code&gt;type&lt;/code&gt; attribute. If this class is not specified, this facility to convert between string and object values for this parameter type will not be available (the &lt;code&gt;GetValueConverter()&lt;/code&gt; on class &lt;code&gt;ParameterType&lt;/code&gt; will return &lt;code&gt;null&lt;/code&gt;).
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.core.commands.AbstractParameterValueConverter"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="values">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="class"/>
-         </appinfo>
-         <documentation>
-            &lt;p&gt;
-The more verbose version of the &lt;code&gt;values&lt;/code&gt; attribute on the &lt;code&gt;commandParameter&lt;/code&gt;.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <choice>
-            <element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
-         </choice>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The class providing a list of parameter values for the user to select.  This class should implement &lt;code&gt;org.blueberry.core.commands.IParameterValues&lt;/code&gt;.  If this class is not specified, you must specify the more verbose &lt;code&gt;values&lt;/code&gt; element.  Please see &lt;code&gt;org.blueberry.osgi.IExecutableExtension&lt;/code&gt;.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.core.commands.IParameterValues"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="parameter">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="name"/>
-         </appinfo>
-         <documentation>
-            &lt;p&gt;
-A possible value for a parameter.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The name of the parameter to pass to the &lt;code&gt;IExecutableExtension&lt;/code&gt;.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="value" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The value of the parameter to pass to the &lt;code&gt;IExecutableExtension&lt;/code&gt;.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="defaultHandler">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="class"/>
-         </appinfo>
-         <documentation>
-            &lt;p&gt;
-The default handler for this command.  If no other handler is active, this handler will be active.  This handler will conflict with other handler definitions that specify no &lt;code&gt;activeWhen&lt;/code&gt; conditions.  If you are not creating an &lt;code&gt;IExecutableExtension&lt;/code&gt;, you can use the &lt;code&gt;defaultHandler&lt;/code&gt; attribute instead.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="parameter"/>
-         </sequence>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The class which implements &lt;code&gt;org.blueberry.core.commands.IHandler&lt;/code&gt;.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="state">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="class"/>
-         </appinfo>
-         <documentation>
-            &lt;p&gt;
-State information shared between all handlers, and potentially persisted between sessions.The state is simply a class that is loaded to look after the state.  See the API Information for more details.  This is not used for UI attributes like a menu contribution check box state or label.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="class" minOccurs="0" maxOccurs="1"/>
-         </sequence>
-         <attribute name="class" type="string">
-            <annotation>
-               <documentation>
-                  The class that can be loaded to store the state of this command.  State is shared amongst handlers, and can be persisted between sessions.  This class must implement &lt;code&gt;org.blueberry.core.commands.State&lt;/code&gt;.  Please see API Information.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  A unique identifier for this state.  This is used for persisting the state between sessions (if the state is an instance of &lt;code&gt;org.blueberry.core.commands.PersistentState&lt;/code&gt;).  Certain common identifiers (see &lt;code&gt;org.blueberry.ui.menus.IMenuStateIds&lt;/code&gt;) are understood when the command is being rendered in the menus or tool bars.  The identifier only needs to be unique within the command defining the state.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="class">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="class"/>
-         </appinfo>
-         <documentation>
-            &lt;p&gt;
-The class that can be loaded to store the state of this command.  This element is used if you wish to pass multiple parameters to an &lt;code&gt;org.blueberry.osgi.IExecutableExtension&lt;/code&gt;.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The class that can be loaded to store the state of this command.  State is shared amongst handlers, and can be persisted between sessions.  This class must implement &lt;code&gt;org.blueberry.core.commands.State&lt;/code&gt;.  Please see API Information.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="since"/>
-      </appinfo>
-      <documentation>
-         &lt;p&gt;
-1.0
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="examples"/>
-      </appinfo>
-      <documentation>
-         &lt;p&gt;
-The &lt;code&gt;plugin.xml&lt;/code&gt; file in the &lt;code&gt;org.blueberry.ui&lt;/code&gt; plugin makes extensive use of the &lt;code&gt;org.blueberry.ui.commands&lt;/code&gt; extension point.
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="apiInfo"/>
-      </appinfo>
-      <documentation>
-         &lt;p&gt;
-Handlers can be registered with commands using the &lt;code&gt;org.blueberry.ui.handlers.IHandlerService&lt;/code&gt;. This can be retrieved from various workbench components (e.g., workbench, workbench window, part site, etc.) by calling &lt;code&gt;GetService(IHandlerService::ID)&lt;/code&gt;.
-&lt;/p&gt;
-&lt;p&gt;
-In general, it is preferrably to declare all commands statically (in &lt;code&gt;plugin.xml&lt;/code&gt;).  This is so that users can attach key bindings to the commands.  However, it is possible to declare commands at run-time.  To do this, retrieve the &lt;code&gt;org.blueberry.ui.commands.ICommandService&lt;/code&gt; from a workbench component, call &lt;code&gt;GetCommand(yourCommandID)&lt;/code&gt; and then call &lt;code&gt;Command::Define(...)&lt;/code&gt;.
-Commands defined programmatically must be cleaned up by the plugin if it is unloaded.
-&lt;/p&gt;
-&lt;p&gt;
-There are a few default implementations of handler states that may be useful to users of this extension point:
-&lt;/p&gt;
-&lt;ul&gt;
-&lt;!--
-&lt;li&gt;org.eclipse.jface.commands.TextState&lt;/li&gt;
-&lt;li&gt;org.eclipse.jface.commands.RadioState&lt;/li&gt;
-&lt;li&gt;org.eclipse.jface.commands.ToggleState&lt;/li&gt;
-&lt;li&gt;org.eclipse.ui.handlers.RegistryRadioState&lt;/li&gt;
-&lt;li&gt;org.eclipse.ui.handlers.RegistryToggleState&lt;/li&gt;
---&gt;
-&lt;/ul&gt;
-      </documentation>
-   </annotation>
-
-
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/editors.exsd b/Plugins/org.blueberry.ui.qt/schema/editors.exsd
deleted file mode 100755
index 93f1db4a0f..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/editors.exsd
+++ /dev/null
@@ -1,328 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.ui" id="editors" name="Internal and External Editors"/>
-      </appInfo>
-      <documentation>
-         This extension point is used to add new editors to the
-workbench.  A editor is a visual component within a
-workbench page. It is typically used to edit or browse
-a document or input object.  To open an editor, the user
-will typically invoke &quot;Open&quot; on an &lt;samp&gt;IFile&lt;/samp&gt;.
-When this action is performed the workbench registry
-is consulted to determine an appropriate editor for
-the file type and then a new instance of the editor
-type is created.  The actual result depends on the
-type of the editor.  The workbench provides support
-for the creation of internal editors, which are tightly
-integrated into the workbench, and external editors,
-which are launched in a separate frame window.
-There are also various level of integration between
-these extremes.
-&lt;p&gt;
-In the case of an internal editor tight integration can
-be achieved between the workbench window and the editor
-part.  The workbench menu and toolbar are pre-loaded
-with a number of common actions, such as cut, copy, and
-paste.  The active part, view or editor, is expected to
-provide the implementation for these actions. An internal
-editor may also define new actions which appear in the
-workbench window.  These actions only appear when the
-editor is active.
-&lt;p&gt;
-The integration between the workbench and external
-editors is more tenuous.  In this case the workbench
-may launch an editor but after has no way of determining
-the state of the external editor or collaborating
-with it by any means except through the file system.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="editor" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="editor">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="name" icon="icon"/>
-         </appInfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="contentTypeBinding" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique name that will be used to identify this editor
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a translatable name that will be used in the UI for this editor
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="icon" type="string">
-            <annotation>
-               <documentation>
-                  A relative name of the icon that will be used for all resources that match the specified extensions. Editors should provide an icon to make it easy for users to distinguish between different editor types. If you specify a command rather than a class, an icon is not needed. In that case, the workbench
-will use the icon provided by the operating system.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="resource"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="extensions" type="string">
-            <annotation>
-               <documentation>
-                  an optional field containing the list of file types understood by the editor.  This is a string containing comma separate file extensions.  For instance, an editor which understands hypertext documents may register for &quot;htm, html&quot;.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string">
-            <annotation>
-               <documentation>
-                  the name of a class that implements &lt;samp&gt;berry::IEditorPart&lt;/samp&gt;. The attributes &lt;samp&gt;class&lt;/samp&gt;, &lt;samp&gt;command&lt;/samp&gt;, and &lt;samp&gt;launcher&lt;/samp&gt; are mutually exclusive. If this attribute is defined then &lt;samp&gt;contributorClass&lt;/samp&gt; should also be defined.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="berry::EditorPart"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="command" type="string">
-            <annotation>
-               <documentation>
-                  a command to run in order to launch an external editor. The executable command must be located on the system path or in the plug-in&apos;s directory. The attributes &lt;samp&gt;class&lt;/samp&gt;, &lt;samp&gt;command&lt;/samp&gt;, and &lt;samp&gt;launcher&lt;/samp&gt; are mutually exclusive.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="launcher" type="string">
-            <annotation>
-               <documentation>
-                  the name of a class which that implements &lt;samp&gt;berry::IEditorLauncher&lt;/samp&gt;.
-A launcher will open an external editor. The attributes &lt;samp&gt;class&lt;/samp&gt;, &lt;samp&gt;command&lt;/samp&gt;, and &lt;samp&gt;launcher&lt;/samp&gt; are mutually exclusive.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="berry::IEditorLauncher"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="contributorClass" type="string">
-            <annotation>
-               <documentation>
-                  the name of a class that implements &lt;samp&gt;berry::IEditorActionBarContributor&lt;/samp&gt;. This attribute should only be defined if the &lt;samp&gt;class&lt;/samp&gt; attribute is defined. This class is used to add new actions to the workbench menu and tool bar which reflect the features of the editor type.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="berry::EditorActionBarContributor"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="default" type="boolean" use="default" value="false">
-            <annotation>
-               <documentation>
-                  if true, this editor will be used as the default editor for the
-type. This is only relevant in a case where more than one editor
-is registered for the same type. If an editor is not the default
-for the type, it can still be launched using &quot;Open with...&quot;
-submenu for the selected resource.
-&lt;p&gt;
-Please note that this attribute is only honored for filename and extension associations at this time.  It will not be honored for content type bindings.  Content type-based resolution will occur on a first come, first serve basis and is not explicitly specified.&lt;/p&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="filenames" type="string">
-            <annotation>
-               <documentation>
-                  an optional field containing the list of file names
-understood by the editor.  This is a string
-containing comma separate file names.  For instance,
-an editor which understands specific hypertext
-documents may register for &quot;ejb.htm, ejb.html&quot;.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="matchingStrategy" type="string">
-            <annotation>
-               <documentation>
-                  the name of a class that implements &lt;samp&gt;berry::IEditorMatchingStrategy&lt;/samp&gt;. This attribute should only be defined if the &lt;samp&gt;class&lt;/samp&gt; attribute is defined. This allows the editor extension to provide its own algorithm for matching the input of one of its editors to a given editor input.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="berry::IEditorMatchingStrategy"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="contentTypeBinding">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="contentTypeId"/>
-         </appInfo>
-         <documentation>
-            Advertises that the containing editor understands the given content type and is suitable for editing files of that type.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="contentTypeId" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The content type identifier. This is an ID defined by the &apos;org.blueberry.core.runtime.contentTypes&apos; extension point.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example
-of an internal editor extension definition:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension point=&quot;org.blueberry.ui.editors&quot;&gt;
-      &lt;editor
-         id=&quot;com.xyz.XMLEditor&quot;
-         name=&quot;Fancy XYZ XML editor&quot;
-         icon=&quot;./icons/XMLEditor.gif&quot;
-         extensions=&quot;xml&quot;
-         class=&quot;xyz::XMLEditor&quot;
-         contributorClass=&quot;xyz::XMLEditorContributor&quot;
-         default=&quot;false&quot;&gt;
-      &lt;/editor&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         If the command attribute is used, it will be treated
-as an external program command line that will be executed
- in a platform-dependent manner.
-&lt;p&gt;
-If the launcher attribute is used the editor will also
-be treated as an external program.  In this case the
-specified class must implement
-&lt;samp&gt;org.eclipse.ui.IEditorLauncher&lt;/samp&gt;.
-The launcher will be instantiated and then
-&lt;samp&gt;open(IPath path)&lt;/samp&gt; will be invoked to
-launch the editor on the provided local file system path.
-&lt;p&gt;
-If the class attribute is used, the workbench will
-assume that it is an internal editor and the specified
-class must implement &lt;samp&gt;org.eclipse.ui.IEditorPart&lt;/samp&gt;.
-It is common practice to
-&lt;samp&gt;subclass org.eclipse.ui.EditorPart&lt;/samp&gt; when
-defining a new editor type.  It is also necessary to
-define a &lt;samp&gt;contributorClass&lt;/samp&gt; attribute.
-The specified class must implement
-&lt;samp&gt;org.eclipse.ui.IEditorActionBarContributor&lt;/samp&gt;,
-and is used to add new actions to the workbench
-menu and tool bar which reflect the features of the
-editor type.
-&lt;p&gt;
-Within the workbench there may be more than one open
-editor of a particular type.  For instance, there may
-be one or more open Java Editors.  To avoid the creation
-of duplicate actions and action images the editor
-concept has been split into two.  An
-&lt;samp&gt;IEditorActionBarContributor&lt;/samp&gt; is responsible
-for the creation of actions.  The editor is responsible
-for action implementation.  Furthermore, the contributor
-is shared by each open editor.  As a result of this
-design there is only one set of actions for one or
-more open editors.
-&lt;p&gt;
-The contributor will add new actions to the workbench
-menu and toolbar which reflect the editor type.  These
-actions are shared and, when invoked, act upon the
-active editor.  The active editor is passed to the
-contributor by invoking
-&lt;samp&gt;IEditorActionBarContributor.setActiveEditor&lt;/samp&gt;.
-The identifiers for actions and major groups within
-the workbench window are defined in
-&lt;samp&gt;org.eclipse.ui.IWorkbenchActionConstants&lt;/samp&gt;.
-These should be used as a reference point for the
-addition of new actions.   Top level menus are created
-by using the following values for the path attribute:
-&lt;ul&gt;
-&lt;li&gt;
-additions - represents a group to the left of the Window menu.
-&lt;/li&gt;
-&lt;/ul&gt;
-Actions and menus added into these paths will only be
-shown while the associated editor is active. When the
-editor is closed, menus and actions will be removed.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         The workbench provides a &quot;Default Text Editor&quot;. The end user product may contain other editors as part of the shipping bundle. In that case, editors will be registered as extensions using the syntax described above.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2002, 2007 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/elementFactories.exsd b/Plugins/org.blueberry.ui.qt/schema/elementFactories.exsd
deleted file mode 100644
index ac2acf1c37..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/elementFactories.exsd
+++ /dev/null
@@ -1,167 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.ui" id="elementFactories" name="Element Factories"/>
-      </appInfo>
-      <documentation>
-         This extension point is used to add element factories
-to the workbench.  An element factory is used to
-recreate &lt;samp&gt;IAdaptable&lt;/samp&gt; objects which are
-persisted during workbench shutdown.
-&lt;p&gt;
-As an example, the element factory is used to
-persist editor input.  The input for an
-editor must implement
-&lt;samp&gt;berry::EditorInput&lt;/samp&gt;.
-The life cycle of an &lt;samp&gt;berry::IEditorInput&lt;/samp&gt; within
-an editor has a number of phases.
-&lt;ol&gt;
-&lt;li&gt;
-The initial input for an editor is passed in during
-editor creation.
-&lt;/li&gt;
-&lt;li&gt;
-On shutdown the workbench state is captured.
-In this process the workbench will create a memento
-for each open editor and its input.  The input is
-saved as a two part memento containing a factory ID
-and any primitive data required to recreate the
-element on startup.  For more information see
-the documentation on
-&lt;samp&gt;berry::IPersistableElement&lt;/samp&gt;.
-&lt;/li&gt;
-&lt;li&gt;
-On startup the workbench state is read and the
-editors from the previous session are recreated.
-In this process the workbench will recreate the input
-element for each open editor.  To do this it will
-map the original factory ID for the input element
-to a concrete factory class defined in the registry.
-If a mapping exists, and the factory class is valid,
-an instance of the factory class is created.  Then
-the workbench asks the factory to recreate the original
-element from the remaining primitive data within the
-memento.  The resulting &lt;samp&gt;berry::IAdaptable&lt;/samp&gt; is cast
-to an &lt;samp&gt;berry::IEditorInput&lt;/samp&gt; and passed to the
-new editor.
-&lt;/li&gt;
-&lt;/ol&gt;
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="factory" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="factory">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique name that will be used to identify this factory.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified name of a class that implements
-&lt;samp&gt;berry::IElementFactory&lt;/samp&gt;
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="c++" basedOn="berry::IElementFactory"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of an element factory extension:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension
-        point = &quot;org.blueberry.ui.elementFactories&quot;&gt;
-        &lt;factory
-           id =&quot;com.xyz.ElementFactory&quot;
-           class=&quot;xyz::ElementFactory&quot;&gt;
-        &lt;/factory&gt;
-    &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         The value of the &lt;samp&gt;class&lt;/samp&gt; attribute must
-be a fully qualified name of a class that implements
-&lt;samp&gt;berry::IElementFactory&lt;/samp&gt;. An instance
-of this class must create an &lt;samp&gt;berry::IAdaptable&lt;/samp&gt;
-object from a workbench memento.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         The workbench provides an &lt;samp&gt;IResource&lt;/samp&gt; factory.
-Additional factories should be added to recreate other
-&lt;samp&gt;berry::IAdaptable&lt;/samp&gt; types commonly found in other
-object models.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2002, 2005 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/handlers.exsd b/Plugins/org.blueberry.ui.qt/schema/handlers.exsd
deleted file mode 100755
index 1ce19c0c10..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/handlers.exsd
+++ /dev/null
@@ -1,309 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.ui">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.ui" id="handlers" name="Handlers"/>
-      </appInfo>
-      <documentation>
-         &lt;p&gt;
-The handlers extension point is an elaboration of the experimental &lt;code&gt;handlerSubmission&lt;/code&gt; element defined in Eclipse 3.0.  A handler is the behaviour of a command at a particular point in time.  A command can have zero or more handlers associated with it.  At any one point in time, however, a command will either have no active handler or one active handler.  The active handler is the one which is currently responsible for carrying out the behaviour of the command.  This is very similar to the concept of an action handler and a retargettable action.
-&lt;/p&gt;
-&lt;p&gt;
-The handlers extension point allows a plug-in developer to specify a handler that should become active and/or enabled under certain conditions.  If a handler is inactive, then no command will delegate its behaviour to the handler.  If a handler is disabled, then the handler will not be asked to execute; execution of the handler is blocked.  The conditions are defined using the expression language facility added during 3.0.  They are expressed using &lt;code&gt;activeWhen&lt;/code&gt; and &lt;code&gt;enabledWhen&lt;/code&gt; clauses.
-&lt;/p&gt;
-&lt;p&gt;
-The workbench provides some variables that these expressions can rely on.  Variables that are valid in activeWhen and enabledWhen expressions can be found in &lt;code&gt;org.eclipse.ui.ISources&lt;/code&gt;.  The types of the variables are determined by the &lt;code&gt;org.eclipse.ui.ISourceProvider&lt;/code&gt; that provides them.
-&lt;/p&gt;
-&lt;p&gt;
-A handler that specifies no conditions is a default handler.  A default handler is only active if no other handler has all of its conditions satisfied.  If two handlers still have conditions that are satisfied, then the conditions are compared.  The idea is to select a handler whose condition is more specific or more local.  To do this, the variables referred to by the condition are looked at.  The condition that refers to the most specific variable &quot;wins&quot;.  The order of specificity (from least specific to most specific) is suggested in &lt;code&gt;org.eclipse.ui.ISources&lt;/code&gt;.
-&lt;/p&gt;
-&lt;p&gt;
-If this still doesn&apos;t resolve the conflict, then no handler is active.  If a particular tracing option is turned on, then this leads to a message in the log.  A conflict can also occur if there are two default handlers.  It is the responsibility of the plug-in developers and integration testers to ensure that this does not happen.
-&lt;/p&gt;
-&lt;p&gt;
-These conditions are used to avoid unnecessary plug-in loading.  These handler definitions are wrapped in a proxy.  For a proxy to load its underlying handler, two things must happen: the conditions for the proxy must be met so that it becomes active, and the command must be asked to do something which it must delegate (e.g., execute(), isEnabled()).
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <include schemaLocation="schema://org.eclipse.core.expressions/schema/expressionLanguage.exsd"/>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="handler" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="handler">
-      <annotation>
-         <documentation>
-            &lt;p&gt;Associated a command with a handler implementation.&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="activeWhen" minOccurs="0" maxOccurs="1"/>
-            <element ref="class" minOccurs="0" maxOccurs="1"/>
-            <element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
-         </sequence>
-         <attribute name="commandId" type="string" use="required">
-            <annotation>
-               <documentation>
-                  &lt;p&gt;The id of the command to associate with this handler implementation.&lt;/p&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string">
-            <annotation>
-               <documentation>
-                  &lt;p&gt;The handler class that imlements &lt;code&gt;org.eclipse.core.commands.IHandler&lt;/code&gt; or extends &lt;code&gt;org.eclipse.core.commands.AbstractHandler&lt;/code&gt;.&lt;/p&gt;
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="helpContextId" type="string">
-            <annotation>
-               <documentation>
-                  &lt;p&gt;
-The identifier of the help context that relates to this specific handler.  While a command can provide a general description of a command&apos;s behaviour, it is sometimes appropriate for a handler to provide help more specific to their implementation.
-&lt;/p&gt;
-&lt;p&gt;&lt;em&gt;Since: 3.2&lt;/em&gt;&lt;/p&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="activeWhen">
-      <annotation>
-         <documentation>
-            &lt;p&gt;Contains a core expression used by the &lt;code&gt;IHandlerService&lt;/code&gt; to determine when this handler is active.&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <choice>
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </choice>
-      </complexType>
-   </element>
-
-   <element name="enabledWhen">
-      <annotation>
-         <documentation>
-            &lt;p&gt;Contains a core expression used by the workbench handler proxy to determine when this handler is enabled without loading it.&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <choice>
-            <element ref="not"/>
-            <element ref="and"/>
-            <element ref="or"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </choice>
-      </complexType>
-   </element>
-
-   <element name="class">
-      <annotation>
-         <documentation>
-            &lt;p&gt;Used when creating an &lt;code&gt;IExecutableExtension&lt;/code&gt; with a named parameter, or more than one.&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="class" type="string">
-            <annotation>
-               <documentation>
-                  &lt;p&gt;The handler class that imlements &lt;code&gt;org.eclipse.core.commands.IHandler&lt;/code&gt; or extends &lt;code&gt;org.eclipse.core.commands.AbstractHandler&lt;/code&gt;.&lt;/p&gt;
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="parameter">
-      <annotation>
-         <documentation>
-            &lt;p&gt;A parameter for an &lt;code&gt;IExecutableExtension&lt;/code&gt;.&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  &lt;p&gt;The parameter name.&lt;/p&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="value" type="string" use="required">
-            <annotation>
-               <documentation>
-                  &lt;p&gt;The parameter value.&lt;/p&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         3.1
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         &lt;p&gt;
-Variables that are valid in activeWhen and enabledWhen expressions can be found in &lt;code&gt;org.eclipse.ui.ISources&lt;/code&gt;.  The types of the variables are determined by the &lt;code&gt;org.eclipse.ui.ISourceProvider&lt;/code&gt; that provides them.
-&lt;/p&gt;
-&lt;pre&gt;
-&lt;extension
- point=&quot;org.eclipse.ui.handlers&quot;&gt;
- &lt;handler
-  commandId=&quot;commandId&quot;
-  class=&quot;org.eclipse.compare.Command&quot;&gt;
-  &lt;activeWhen&gt;
-   &lt;with variable=&quot;selection&quot;&gt;
-    &lt;count value=&quot;1&quot; /&gt;
-    &lt;iterate operator=&quot;and&quot;&gt;
-     &lt;adapt type=&quot;org.eclipse.core.resources.IResource&quot; /&gt;
-    &lt;/iterate&gt;
-   &lt;/with&gt;
-  &lt;/activeWhen&gt;
- &lt;/handler&gt;
- &lt;handler
-  commandId=&quot;other.commandId&quot;
-  class=&quot;org.eclipse.ui.TalkToMe&quot;&gt;
-  &lt;activeWhen&gt;
-   &lt;with variable=&quot;activePartId&quot;&gt;
-    &lt;equals value=&quot;org.eclipse.ui.views.SampleView&quot;/&gt;
-   &lt;/with&gt;
-  &lt;/activeWhen&gt;
- &lt;/handler&gt;
-&lt;/extension&gt;
-&lt;/pre&gt;
-&lt;p&gt;
-To further avoid plug-in loading, it is possible to specify when the handler is enabled.  If the proxy has not yet loaded the handler, then only the expressions syntax is used to decide if the handler is enabled.  If the proxy has loaded the handler, then the expressions syntax is consulted first.  If the expressions syntax evaluates to true, then the handler is asked if it is enabled.  (This is a short-circuit Boolean &quot;and&quot; operation between the expressions syntax and the handler&apos;s enabled state.)
-&lt;/p&gt;
-&lt;pre&gt;
-&lt;extension
- point=&quot;org.eclipse.ui.handlers&quot;&gt;
- &lt;handler
-  commandId=&quot;commandId&quot;
-  class=&quot;org.eclipse.Handler&quot;&gt;
-  &lt;enabledWhen&gt;
-   &lt;with variable=&quot;activeContexts&quot;&gt;
-     &lt;iterator operator=&quot;or&quot;&gt;
-       &lt;equals value=&quot;org.eclipse.ui.contexts.window&quot;/&gt;
-     &lt;/iterator&gt;
-   &lt;/with&gt;
-  &lt;/enabledWhen&gt;
- &lt;/handler&gt;
-&lt;/extension&gt;
-&lt;/pre&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         &lt;p&gt;
-All handlers implement &lt;code&gt;org.eclipse.core.commands.IHandler&lt;/code&gt;, and can use &lt;code&gt;org.eclipse.core.commands.AbstractHandler&lt;/code&gt; as a base class.  Within the workbench, it is possible to activate and deactivate handlers using the &lt;code&gt;org.eclipse.ui.handlers.IHandlerService&lt;/code&gt; interface.  This interface can be retrieved from supporting workbench objects, such as &lt;code&gt;IWorkbench&lt;/code&gt; itself, a workbench window, or a part site.  To retrieve the service, you would make a call like &lt;code&gt;IWorkbench.getService(IHandlerService.class)&lt;/code&gt;.
-&lt;/p&gt;
-&lt;p&gt;
-It is also possible to activate and deactive handlers using legacy code in the workbench.  This can be done through the legacy mechanism shown below.  This mechanism is useful to clients who are using actions to contribute to menus or toolbars.  This is deprecated and not recommended.
-&lt;/p&gt;
-&lt;pre&gt;
- IWorkbenchPartSite mySite;
- IAction myAction;
-
- myAction.setActionDefinitionId(commandId);
- IKeyBindingService service = mySite.getKeyBindingService();
- service.registerAction(myAction);
-&lt;/pre&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2005, 2007 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/intro.exsd b/Plugins/org.blueberry.ui.qt/schema/intro.exsd
deleted file mode 100755
index b1badeb3bd..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/intro.exsd
+++ /dev/null
@@ -1,208 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appinfo>
-         <meta.schema plugin="org.blueberry.ui" id="intro" name="Intro Part"/>
-      </appinfo>
-      <documentation>
-         &lt;p&gt;This extension point is used to register implementations of special workbench parts, called intro parts, that are responsible for introducing a product to new users. An intro part is typically shown the first time a product is started up. Rules for associating an intro part implementation with particular products are also contributed via this extension point.
-&lt;/p&gt;
-The life cycle is as follows:
-&lt;ul&gt;
-&lt;li&gt;The intro area is created on workbench start up. As with editor and view areas, this area is managed by an intro site (implementing &lt;code&gt;IIntroSite&lt;/code&gt;).&lt;/li&gt;
-&lt;li&gt;The id of the current product (Platform::GetProduct()) is used to choose the relevant intro part implementation.
-&lt;/li&gt;
-&lt;li&gt;The intro part class (implementing &lt;code&gt;IIntroPart&lt;/code&gt;) is created and initialized with the intro site.
-&lt;/li&gt;
-&lt;li&gt;While the intro part is showing to the user, it can transition back and forth between full and standby mode (either programmatically or explicitly by the user).
-&lt;/li&gt;
-&lt;li&gt;Eventually the intro part is closed (either programmatically or explicitly by the user). The current perspective takes over the entire workbench window area.
-&lt;/li&gt;
-&lt;/ul&gt;
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <appinfo>
-            <meta.element />
-         </appinfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="intro" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="introProductBinding" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="intro">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="id" icon="icon"/>
-         </appinfo>
-         <documentation>
-            Specifies an introduction. An introduction is a product-specific presentation shown to first-time users on product start up.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique identifier for this introduction
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="icon" type="string">
-            <annotation>
-               <documentation>
-                  a plug-in-relative file name of the icon that will be associated with this introduction
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="resource"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified name of the class implementing the &lt;code&gt;berry::IIntroPart&lt;/code&gt; interface.  A common practice
-is to subclass &lt;samp&gt;berry::IntroPart&lt;/samp&gt;
-in order to inherit the default functionality.  This class implements the introduction.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn=":berryIIntroPart"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="contentDetector" type="string">
-            <annotation>
-               <documentation>
-                  a fully qualified name of a class extending &lt;code&gt;berry::IntroContentDetector&lt;/code&gt;.  This optional class is used to detect newly added introduction content.  If new content is available, the view showing the introduction will be opened again.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn=":berryIntroContentDetector"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="label" type="string">
-            <annotation>
-               <documentation>
-                  an string label for this introduction that will be used in the construction of the open action as well as the part label.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="introProductBinding">
-      <annotation>
-         <documentation>
-            Specifies a binding between a product and an introduction. These bindings determine which introduction is appropriate for the current product (as defined by &lt;code&gt;Platform::GetProduct()&lt;/code&gt;).
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="productId" type="string" use="required">
-            <annotation>
-               <documentation>
-                  unique id of a product
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="introId" type="string" use="required">
-            <annotation>
-               <documentation>
-                  unique id of an introduction
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="since"/>
-      </appinfo>
-      <documentation>
-         3.0
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="examples"/>
-      </appinfo>
-      <documentation>
-         The following is an example of an intro part extension that contributes an particular introduction and associates it with a particular product:
-&lt;p&gt;
-&lt;pre&gt;
-  &lt;extension point=&quot;org.eclipse.ui.intro&quot;&gt;
-     &lt;intro
-        id=&quot;com.example.xyz.intro.custom&quot;
-        class=&quot;com.example.xyz.intro.IntroPart&quot;/&gt;
-     &lt;introProductBinding
-        productId=&quot;com.example.xyz.Product&quot;
-        introId=&quot;com.example.xyz.intro.custom&quot;/&gt;
-  &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="apiInfo"/>
-      </appinfo>
-      <documentation>
-         The value of the &lt;code&gt;class&lt;/code&gt; attribute must be the fully qualified name of a class that implements the&lt;code&gt;org.eclipse.ui.intro.IIntroPart&lt;/code&gt; interface by subclassing &lt;code&gt;org.eclipse.ui.part.intro.IntroPart&lt;/code&gt;.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="implementation"/>
-      </appinfo>
-      <documentation>
-         There are no default implementations of the initial user experience. Each Eclipse-based product is responsible for providing one that is closely matched to its branding and function.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="copyright"/>
-      </appinfo>
-      <documentation>
-         Copyright (c) 2004, 2007 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/keywords.exsd b/Plugins/org.blueberry.ui.qt/schema/keywords.exsd
deleted file mode 100644
index ac8a532caf..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/keywords.exsd
+++ /dev/null
@@ -1,127 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.ui" id="keywords" name="Keywords"/>
-      </appInfo>
-      <documentation>
-         The keywords extension point defines keywords and a unique id for reference by other schemas.
-
-See propertyPages and preferencePages.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <documentation>
-         </documentation>
-      </annotation>
-      <complexType>
-         <choice>
-            <element ref="keyword" minOccurs="0" maxOccurs="unbounded"/>
-         </choice>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="keyword">
-      <annotation>
-         <documentation>
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The id is the unique id used to reference the keyword.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="label" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The human readable label of the keyword
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of a keyword extension:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension
-     point=&quot;org.blueberry.ui.keywords&quot;&gt;
-    &lt;keyword
-            label=&quot;presentation tab themes&quot;
-            id=&quot;com.xyz.AppearanceKeywords&quot;/&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         There currently is no public API for retrieving or creating keywords other than this extension point.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         Keywords are used only with preference and property pages.  See the &lt;samp&gt;keywordReference&lt;/samp&gt; element of the org.blueberry.ui.propertyPages and org.blueberry.ui.preferencePages extension points.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2005,2006 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/menus.exsd b/Plugins/org.blueberry.ui.qt/schema/menus.exsd
deleted file mode 100644
index ecae8da9b0..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/menus.exsd
+++ /dev/null
@@ -1,646 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.ui" id="menus" name="Menus"/>
-      </appInfo>
-      <documentation>
-&lt;p&gt;
-This extension point allows the plug-in developer to add (contribute) a variety of custom additions to the BlueBerry framework:
-&lt;ul&gt;
-  &lt;li&gt;Main Menu&lt;/li&gt;
-  &lt;li&gt;Main Toolbars&lt;/li&gt;
-  &lt;li&gt;View Menus/Toolbars:
-  &lt;ul&gt;
-    &lt;li&gt;View Dropdown Menu&lt;/li&gt;
-    &lt;li&gt;View Toolbar&lt;/li&gt;
-    &lt;li&gt;Context Menu(s)&lt;/li&gt;
-  &lt;/ul&gt;
-  &lt;/li&gt;
-  &lt;li&gt;Trim&lt;/li&gt;
-&lt;/ul&gt;
-&lt;/p&gt;
-&lt;p&gt;
-The general strategy for this mechanism is to separate the &apos;location&apos; where the contributions should be inserted from the visibility and enablement state of the element. Each contribution first defines its insertion location through a Menu &apos;URI&apos;, a string (loosely) formatted according to the jave.net.URI format:
-&lt;/p&gt;&lt;p&gt;
-&lt;b&gt;&quot;[Scheme]:[ID]?[ArgList]&quot;&lt;/b&gt;
-&lt;ul&gt;
-&lt;li&gt;&lt;b&gt;Scheme&lt;/b&gt; - The &apos;type&apos; of the UI component into which the contributions will be added. It may be either &quot;menu&quot;, &quot;popup&quot; or &quot;toolbar&quot;. While &apos;popup&apos; is indeed a form of menu it is provided to allow a distinction between a view&apos;s &apos;chevron&apos; menu (for which we use the &quot;menu&quot; scheme) and its default context menu which, by convention, should be registered using the &quot;popup&quot; scheme.&lt;/li&gt;
-&lt;li&gt;&lt;b&gt;ID&lt;/b&gt; - This is the id of menu or toolbar into which the contributions should be added. By convention views should use their view id as the id of the root of their chevron and default popup menu. Note that there is no explicit distinction between contributions supporting editors and &apos;normal&apos; contributions into the Menu Menu or Toolbar; both global contributions and editor contributions would use the &quot;org.blueberry.ui.main.menu&quot; id or &quot;org.blueberry.ui.main.toolbar&quot;. A special id used with popup:, &quot;org.blueberry.ui.popup.any&quot;, is reserved to handle contributions which are candidates to appear on any (top level) context menu. Note that these contributions are expected to implement a &apos;visibleWhen&apos; expression sufficient to limit their visibility to appropriate menus&lt;/li&gt;
-&lt;li&gt;&lt;b&gt;Query&lt;/b&gt; - This field allows fine-grained definition of the specific location &lt;i&gt;within&lt;/i&gt; a given menu. It has the form &quot;[placement]=[id]&quot; where placement is one of &quot;before&quot;, &quot;after&quot;, or &quot;endof&quot; and the id is expected to be the id of some IContributionItem in the menu.&lt;/li&gt;
-&lt;/ul&gt;
-&lt;p&gt;
-This will define the location at which the contributions will appear in the BlueBerry UI. Once the insertion point has been defined the rest of the contributions describe the UI elements that will be added at that location. Each element supports a &apos;visibleWhen&apos; expression that determines at run time whether a particular item should appear in the menu based on the system&apos;s current state (selection, active view/editor, context...).  See &lt;code&gt;berry::ISources&lt;/code&gt; for a list of currently
-supported variables.
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <include schemaLocation="schema://org.blueberry.core.expressions/schema/expressionLanguage.exsd"/>
-
-   <element name="extension">
-      <annotation>
-         <appInfo>
-            <meta.element />
-         </appInfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="group" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="widget" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="menuContribution" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  org.blueberry.ui.menus
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  An optional identifier of the extension instance.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  An optional name of the extension instance.
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="class">
-      <annotation>
-         <documentation>
-            A class element supporting the executable extension parsing syntax for both &lt;code&gt;widget&lt;/code&gt; and &lt;code&gt;dynamic&lt;/code&gt; elements.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The class to load as an &lt;code&gt;IExecutableExtension&lt;/code&gt;.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="visibleWhen">
-      <annotation>
-         <documentation>
-            A core Expression that controls the visibility of the given element.
-         </documentation>
-      </annotation>
-      <complexType>
-         <choice minOccurs="0" maxOccurs="1">
-            <element ref="not"/>
-            <element ref="or"/>
-            <element ref="and"/>
-            <element ref="instanceof"/>
-            <element ref="test"/>
-            <element ref="systemTest"/>
-            <element ref="equals"/>
-            <element ref="count"/>
-            <element ref="with"/>
-            <element ref="resolve"/>
-            <element ref="adapt"/>
-            <element ref="iterate"/>
-            <element ref="reference"/>
-         </choice>
-         <attribute name="checkEnabled" type="boolean" use="default" value="false">
-            <annotation>
-               <documentation>
-                  If this attribute is set to &lt;code&gt;true&lt;/code&gt;, then there should be no sub-elements.  This just checks the enabled state of the command, and makes the corresponding element visible if the command is enabled.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="parameter">
-      <annotation>
-         <documentation>
-            A parameter to either an executable extension or a command -- depending on where it appears in the extension.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The name is either the name of the parameter to pass to the executable extension, or the identifier of the parameter for the command.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.commands/command/commandParameter/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="value" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The value to pass for this parameter.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="menuContribution">
-      <annotation>
-         <documentation>
-            &lt;p&gt;Defines an ordered set of additions to the command UI structure. The defined elements will be added into the command UI structure at the location specified by the &lt;code&gt;locationURI&lt;/code&gt; element.
-&lt;/p&gt;&lt;p&gt;
-This should be the starting point for &lt;i&gt;all&lt;/i&gt; contributions into menus, toolbars or trim, wherever they occur in the UI.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="menu" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="command" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="separator" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="dynamic" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="toolbar" minOccurs="0" maxOccurs="unbounded"/>
-            <element ref="control" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="locationURI" type="string" use="required">
-            <annotation>
-               <documentation>
-                  A &lt;code&gt;URI&lt;/code&gt; specification that defines the insertion point at which the contained additions will be added.
-
-The format for the URI is comprised of three basic parts:
-
-Scheme: One of &quot;menu&quot;, &quot;popup&quot; or &quot;toolbar. Indicates the type of the manager used to handle the contributions
-Id: This is either the id of an existing menu, a view id or the id of the editor &apos;type&apos;
-Query: The query format is &amp;lt;placement&amp;gt;=&amp;lt;id&amp;gt; where:
- &amp;lt;placement&amp;gt; is either &quot;before&quot;, &quot;after&quot;, or &quot;endof&quot; and
- &amp;lt;id&amp;gt; is the id of an existing menu item.  The placement modifier is executed when this contribution is processed.  Following contributions may change the final shape of the menu when they are processed.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string">
-            <annotation>
-               <documentation>
-                  If this optional attribute is specified the provided class will be instantiated and used to provide menu contributions at this location.  If provided, all child elements will be ignored.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.blueberry.ui.menus.ExtensionContributionFactory:"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="allPopups" type="boolean" use="default" value="false">
-            <annotation>
-               <documentation>
-                  By default popup contributions are not contributed to context menus that do not include an &lt;b&gt;additions&lt;/b&gt; marker.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="menu">
-      <annotation>
-         <documentation>
-            Defines a new menu contribution at the given insertion point.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="1">
-            <element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
-            <choice minOccurs="0" maxOccurs="unbounded">
-               <element ref="menu" minOccurs="0" maxOccurs="1"/>
-               <element ref="command" minOccurs="0" maxOccurs="1"/>
-               <element ref="separator" minOccurs="0" maxOccurs="1"/>
-               <element ref="dynamic" minOccurs="0" maxOccurs="1"/>
-            </choice>
-         </sequence>
-         <attribute name="label" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The label to be displayed for this element when it is placed in either a menu or a toolbar. This value should be translatable.
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  The &apos;id&apos; of this menu contribution. If defined then it can be extended through other &apos;menuAddition&apos; elements or the id can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="mnemonic" type="string">
-            <annotation>
-               <documentation>
-                  The character of the Label that should be given the mnemonic affordance. This is to allow the menu system to re-define the value during translation without having to understand the various platforms&apos; conventions for menu label definition (i.e. using the &apos;&amp;amp;&apos; character...).
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="icon" type="string">
-            <annotation>
-               <documentation>
-                  A plugin relative path to the image to be used as the icon for this menu in either a menu or a toolbar.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="resource"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="tooltip" type="string">
-            <annotation>
-               <documentation>
-                  The tooltip to be displayed for this element when it is placed in a toolbar. This value should be translatable.
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="commandId" type="string">
-            <annotation>
-               <documentation>
-                  Th commandId is used to update the submenu text with a keyboard shortcut.  The command should have a handler that can launch a quickmenu version of this menu.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.commands/command/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="command">
-      <annotation>
-         <documentation>
-            Defines a new Command Contribution at the defined insertion point.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
-            <element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="label" type="string">
-            <annotation>
-               <documentation>
-                  The label to be displayed for this element when it is placed in either a menu. This value should be translatable.
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="commandId" type="string" use="required">
-            <annotation>
-               <documentation>
-                  This is the id of the Command that is to be bound to this element. This is the hook into the Commands/Handlers/Key binding services that actually do the work should this item be selected. In many cases this command will have been defined in a previous extension declaration.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.commands/command/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  The &apos;id&apos; of this contribution. If defined then it can be  used as a reference in the Query part of the location defining whether the additions are to go before or after this element.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="mnemonic" type="string">
-            <annotation>
-               <documentation>
-                  The character of the Label that should be given the mnemonic affordance. This is to allow the menu system to re-define the value during translation without having to understand the various platforms&apos; conventions for menu label definition (i.e. using the &apos;&amp;amp;&apos; character...).
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="icon" type="string">
-            <annotation>
-               <documentation>
-                  a relative path of an icon used to visually represent the action in its context.
-If omitted and the action appears in the toolbar, the Workbench will use a placeholder icon. The path is relative to the location of the plugin.xml file of the contributing plug-in, or the &lt;code&gt;ISharedImages&lt;/code&gt; constant.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="resource"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="disabledIcon" type="string">
-            <annotation>
-               <documentation>
-                  a relative path of an icon used to visually represent the action in its context when the action is disabled. If omitted, the normal icon will simply appear greyed out. The path is relative to the location of the plugin.xml file of the contributing plug-in. The disabled icon will appear in toolbars but not in menus. Icons for disabled actions in menus will be supplied by the OS.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="resource"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="hoverIcon" type="string">
-            <annotation>
-               <documentation>
-                  a relative path of an icon used to visually represent the action in its context when the mouse pointer is over the action. If omitted, the normal icon will be used. The path is relative to the location of the plugin.xml file of the contributing plug-in.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="resource"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="tooltip" type="string">
-            <annotation>
-               <documentation>
-                  The tooltip to be displayed for this element when it is placed in a toolbar. This value should be translatable.
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="helpContextId" type="string">
-            <annotation>
-               <documentation>
-                  a unique identifier indicating the help context for this action. If the action appears as a menu item, then pressing F1 while the menu item is highlighted will display help.  This overrides the help context id provided by the active handler or command.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="style" use="default" value="push">
-            <annotation>
-               <documentation>
-                  an attribute to define the user interface style type for the action. If omitted, then it is &lt;samp&gt;push&lt;/samp&gt; by default. The attribute value will be one of the following:
-    &lt;table border=&quot;0&quot; width=&quot;80%&quot;&gt;
-      &lt;tr&gt;
- &lt;td valign=&quot;top&quot; width=&quot;25&quot;&gt;&lt;/td&gt;
-        &lt;td valign=&quot;top&quot; nowrap&gt;&lt;b&gt;push&lt;/b&gt;&lt;/td&gt;
-        &lt;td valign=&quot;top&quot;&gt;- as a regular menu item or tool item.&lt;/td&gt;
-      &lt;/tr&gt;
-      &lt;tr&gt;
- &lt;td valign=&quot;top&quot; width=&quot;25&quot;&gt;&lt;/td&gt;
-        &lt;td valign=&quot;top&quot; nowrap&gt;&lt;b&gt;radio&lt;/b&gt;&lt;/td&gt;
-        &lt;td valign=&quot;top&quot;&gt;- as a radio style menu item or tool item. Actions with the radio style within the same menu or toolbar group behave as a radio set. The initial value is specified by the &lt;samp&gt;state&lt;/samp&gt; attribute.&lt;/td&gt;
-      &lt;/tr&gt;
-      &lt;tr&gt;
- &lt;td valign=&quot;top&quot; width=&quot;25&quot;&gt;&lt;/td&gt;
-        &lt;td valign=&quot;top&quot; nowrap&gt;&lt;b&gt;toggle&lt;/b&gt;&lt;/td&gt;
-        &lt;td valign=&quot;top&quot;&gt;- as a checked style menu item or as a toggle tool item. The initial value is specified by the &lt;samp&gt;state&lt;/samp&gt; attribute.&lt;/td&gt;
-      &lt;/tr&gt;
-      &lt;tr&gt;
- &lt;td valign=&quot;top&quot; width=&quot;25&quot;&gt;&lt;/td&gt;
-        &lt;td valign=&quot;top&quot; nowrap&gt;&lt;b&gt;pulldown&lt;/b&gt;&lt;/td&gt;
-        &lt;td valign=&quot;top&quot;&gt;- (ToolBar only) Creates a ToolItem with the &lt;code&gt;SWT.DROP_DOWN&lt;/code&gt; affordance. The URI of the menu is &quot;menu:&quot; + this item&apos;s ID.&lt;/td&gt;
-      &lt;/tr&gt;
-    &lt;/table&gt;
-               </documentation>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="push">
-                  </enumeration>
-                  <enumeration value="radio">
-                  </enumeration>
-                  <enumeration value="toggle">
-                  </enumeration>
-                  <enumeration value="pulldown">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-         <attribute name="mode">
-            <annotation>
-               <documentation>
-                  For commands appearing in a toolbar, &lt;code&gt;FORCE_TEXT&lt;/code&gt; will show text even if there is an icon.  See CommandContributionItem.
-               </documentation>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="FORCE_TEXT">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="separator">
-      <annotation>
-         <documentation>
-            Inserts a separator at the current insertion point.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The &apos;id&apos; of this contribution. If defined then it can be  used as a reference in the Query part of the location defining whether the additions are to go before or after this element (or at the end of the logical group containing this element using the &apos;endof&apos; value).
-&lt;p&gt;
-Separator contributions that have an id define the start of a logical group so the result of using the &apos;endof&apos; value for placement is to search forward in the current menu to locate the next separator and to place the inserted elements before that element. If no trailing separator is found then the items are placed at the end of the menu.
-&lt;/p&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="visible" type="boolean">
-            <annotation>
-               <documentation>
-                  Indicates whether or not the separator should be visible in the UI. &lt;code&gt;false&lt;/code&gt; by default.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="toolbar">
-      <annotation>
-         <documentation>
-            Contributes a new ToolBar at the current insertion point.  This element is only currently valid for CoolBarManagers, which can contain toolbars.  For example, the trim location URIs specified in &lt;code&gt;org.blueberry.ui.menus.MenuUtil&lt;/code&gt;.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="0" maxOccurs="1">
-            <element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
-            <choice minOccurs="0" maxOccurs="unbounded">
-               <element ref="command" minOccurs="0" maxOccurs="1"/>
-               <element ref="separator" minOccurs="0" maxOccurs="1"/>
-               <element ref="dynamic" minOccurs="0" maxOccurs="1"/>
-               <element ref="control" minOccurs="0" maxOccurs="1"/>
-            </choice>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The &apos;id&apos; of this toolbar contribution. If defined then it can be extended through other &apos;menuAddition&apos; elements or the id can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="label" type="string">
-            <annotation>
-               <documentation>
-                  The label to be displayed for this element when it is displayed in the customize perspective dialog. This value should be translatable.
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="control">
-      <annotation>
-         <documentation>
-            Used to contribute controls to ToolBars in the workbench. The &apos;class&apos; attribute must be a derivative of the
-WorkbenchWindowControlContribution base class.
-&lt;p&gt;
-&lt;b&gt;NOTE:&lt;/b&gt; Due to platform restrictions control contributions are only supported for toolbars; Attempts to contribute controls into a menu or popup will be treated as a NO-OP.
-&lt;/p&gt;
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
-         </sequence>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  The &apos;id&apos; of this menu contribution. If defined then it can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The class which will be used to create the control that is to be hosted in a ToolBar. This must be a subclass of
-WorkbenchWindowControlContribution which provides information as to the control&apos;s location (i.e. which workbench window it&apos;s being hosted in and the side of the window that it is currently being displayed on.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.blueberry.ui.menus.WorkbenchWindowControlContribution"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="dynamic">
-      <annotation>
-         <documentation>
-            The element provides a mechanism that will call back into the defined class to provide an IContributionItem to be shown when the menu or toolbar is built. The defined class must be a derivative of the org.blueberry.jface.action.ContributionItem base class.  It can also use org.blueberry.ui.action.CompoundContributionItem and provide an implementation for the abstract &lt;code&gt;getContributionItems&lt;/code&gt; method to provide a dynamic menu item.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="class" minOccurs="0" maxOccurs="1"/>
-            <element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  A unique identifier for this contribution.  It is recommended that the identifier be prefixed by the plug-in name, to guarantee uniqueness.  For example, a widget contributed by &lt;code&gt;org.blueberry.ui&lt;/code&gt; might be called &lt;code&gt;org.blueberry.ui.widget1&lt;/code&gt;.
-&lt;p&gt;
-If defined then it can be  used as a reference in the Query part of the location defining whether the additions are to go before or after this element (or at the end of the logical group containing this element using the &apos;endof&apos; value).
-&lt;/p&gt;
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  This class is expected to be a subclass of ContributionItem. The item may implement IWorkbenchContribution to be provided an IServiceLocator.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.blueberry.jface.action.ContributionItem"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         &lt;p&gt;
-It is preferred that menu contributions be added in the &lt;code&gt;plugin.xml&lt;/code&gt;.  Plugins can
-programmatically add their own menu contributions using &lt;code&gt;org.blueberry.ui.menus.IMenuService&lt;/code&gt; and &lt;code&gt;org.blueberry.ui.menus.AbstractContributionFactory&lt;/code&gt;, but should be sure to remove them if the plugin is unloaded.  The &lt;code&gt;IMenuService&lt;/code&gt; can be retrieved through any of the &lt;code&gt;IServiceLocators&lt;/code&gt;, the workbench, the workbench window, or the part site.
-&lt;/p&gt;
-&lt;p&gt;
-See &lt;a href=&quot;org_blueberry_ui_commands.html&quot;&gt;org.blueberry.ui.commands&lt;/a&gt; to define a command and &lt;a href=&quot;org_blueberry_ui_handlers.html&quot;&gt;org.blueberry.ui.handlers&lt;/a&gt; to define an implementation for the command.
-&lt;/p&gt;
-&lt;p&gt;To register a context menu, use the &lt;code&gt;IWorkbenchPartSite.registerContextMenu&lt;/code&gt; methods.&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         3.3
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         &lt;p&gt;
-A basic extension looks like this.
-&lt;/p&gt;
-&lt;pre&gt;
-   &lt;extension
-         id=&quot;add.item&quot;
-         point=&quot;org.blueberry.ui.menus&quot;&gt;
-      &lt;menuContribution
-         locationURI=&quot;menu:someorg.somemenu.id?after=additions&quot;&gt;
-         &lt;command
-               commandId=&quot;someorg.someid.someCommand&quot;
-               icon=&quot;icons/anything.gif&quot;
-               id=&quot;someorg.someid.BasicCmdItem&quot;
-               label=&quot;Simple Item&quot;
-               mnemonic=&quot;S&quot;&gt;
-         &lt;/command&gt;
-      &lt;/menuContribution&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;p&gt;
-This is the simplest example; adding a command contribution after an existing menu&apos;s additions group.
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2005,2007 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/perspectiveExtensions.exsd b/Plugins/org.blueberry.ui.qt/schema/perspectiveExtensions.exsd
deleted file mode 100644
index d908729c13..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/perspectiveExtensions.exsd
+++ /dev/null
@@ -1,373 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.ui" id="perspectiveExtensions" name="Perspective Extensions"/>
-      </appInfo>
-      <documentation>
-         This extension point is used to extend perspectives
-registered by other plug-ins. A perspective defines
-the initial contents of the window action bars
-(menu and toolbar) and the initial set of views
-and their layout within a workbench page.
-Other plug-ins may contribute actions or views to
-the perspective which appear when the perspective
-is selected.  Optional additions by other plug-ins
-are appended to the initial definition.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <appInfo>
-            <meta.element />
-         </appInfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="perspectiveExtension" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="perspectiveExtension">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="targetID"/>
-         </appInfo>
-      </annotation>
-      <complexType>
-         <choice minOccurs="0" maxOccurs="unbounded">
-            <element ref="actionSet"/>
-            <element ref="viewShortcut"/>
-            <element ref="perspectiveShortcut"/>
-            <element ref="newWizardShortcut"/>
-            <element ref="view"/>
-            <element ref="showInPart"/>
-            <element ref="hiddenMenuItem"/>
-            <element ref="hiddenToolBarItem"/>
-         </choice>
-         <attribute name="targetID" use="required">
-            <annotation>
-               <documentation>
-                  the unique identifier of the perspective (as specified in the registry) into which the contribution is made. If the value is set to &quot;*&quot; the extension is applied to all perspectives.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.perspectives/perspective/@id"/>
-               </appInfo>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="*">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="actionSet">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the unique identifier of the action set which will be added to the perspective.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.actionSets/actionSet/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="viewShortcut">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the unique identifier of the view which will be added to the perspective&apos;s &quot;Show View&quot; submenu of the &quot;Window&quot; menu.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="perspectiveShortcut">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the unique identifier of the perspective which will be added to the perspective&apos;s &quot;Open Perspective&quot; submenu of the &quot;Window&quot; menu.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.perspectives/perspective/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="newWizardShortcut">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the unique identifier of the new wizard which will be added to the perspective&apos;s &quot;New&quot; submenu of the &quot;File&quot; menu.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.newWizards/wizard/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="showInPart">
-      <complexType>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  the unique identifier of the view which will be added to the perspective&apos;s &quot;Show In...&quot; prompter in the Navigate menu.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="view">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the unique identifier of the view which will be added to the perspective layout.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="relative">
-            <annotation>
-               <documentation>
-                  the unique identifier of a view which already exists in the perspective.  This will be used as a reference point for placement of the view.  The relationship between these two views is defined by &lt;samp&gt;relationship&lt;/samp&gt;.  Ignored if relationship is &quot;fast&quot;.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
-               </appInfo>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="org.blueberry.ui.editorss">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-         <attribute name="relationship" use="required">
-            <annotation>
-               <documentation>
-                  specifies the relationship between &lt;samp&gt;id&lt;/samp&gt; and
-&lt;samp&gt;relative&lt;/samp&gt;.
-The following values are supported:
-&lt;ul&gt;
-&lt;b&gt;fast&lt;/b&gt; - the view extension will be created as a fast view.
-&lt;br&gt;&lt;b&gt;stack&lt;/b&gt; - the view extension will be stacked with the relative
-view in a folder.
-&lt;br&gt;&lt;b&gt;left, right, top, bottom&lt;/b&gt; - the view extension will be placed
-beside the relative view. In this case a &lt;samp&gt;ratio&lt;/samp&gt; must also
-be defined.&lt;/ul&gt;
-               </documentation>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="stack">
-                  </enumeration>
-                  <enumeration value="left">
-                  </enumeration>
-                  <enumeration value="right">
-                  </enumeration>
-                  <enumeration value="top">
-                  </enumeration>
-                  <enumeration value="bottom">
-                  </enumeration>
-                  <enumeration value="fast">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-         <attribute name="ratio" type="string">
-            <annotation>
-               <documentation>
-                  the percentage of area within the relative view which will be donated to the view extension. If the view extension is a fast view, the ratio is the percentage of the workbench the fast view will cover when active. This must be defined as a floating point value and lie between 0.05 and 0.95.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="visible" type="boolean">
-            <annotation>
-               <documentation>
-                  whether the view is initially visible when the perspective is opened.  This attribute should have a value of &quot;true&quot; or &quot;false&quot; if used.
-If this attribute is not used, the view will be initially visible by default.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="closeable" type="boolean">
-            <annotation>
-               <documentation>
-                  whether the view is closeable in the target perspective. This attribute should have a value of &quot;true&quot; or &quot;false&quot; if used.  If this attribute is not used, the view will be closeable, unless the perspective itself is marked as fixed.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="moveable" type="boolean">
-            <annotation>
-               <documentation>
-                  whether the view is moveable.  A non-moveable view cannot be moved either within the same folder, or moved between folders in the perspective.  This attribute should have a value of &quot;true&quot; or &quot;false&quot; if used.
-If this attribute is not used, the view will be moveable, unless the perspective itself is marked as fixed.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="standalone" type="boolean">
-            <annotation>
-               <documentation>
-                  whether the view is a standalone view.  A standalone view cannot be docked together with others in the same folder.  This attribute should have a value of &quot;true&quot; or &quot;false&quot; if used.  This attribute is ignored if the relationship attribute is &quot;fast&quot; or &quot;stacked&quot;.  If this attribute is not used, the view will be a regular view, not a standalone view (default is &quot;false&quot;).
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="showTitle" type="boolean">
-            <annotation>
-               <documentation>
-                  whether the view&apos;s title is shown.  This attribute should have a value of &quot;true&quot; or &quot;false&quot; if used.  This attribute only applies to standalone views.  If this attribute is not used, the view&apos;s title will be shown (default is &quot;true&quot;).
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="minimized" type="boolean" use="default" value="false">
-            <annotation>
-               <documentation>
-                  If the perspective extension will result in a new view stack being created (i.e. the &apos;relationship&apos; attribute is one of left, right, top or bottom) this field determines the new stack&apos;s initial display state.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="hiddenMenuItem">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The unique identifier of the Command which is to be removed from the menu.
-
-&lt;strong&gt;WARNING:&lt;/strong&gt; This is considered to be a &apos;Product level&apos; extension and should not be used in consumable plugins without great care.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="hiddenToolBarItem">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The unique identifier of the Command which is to be removed from thetoolbar.
-
-&lt;strong&gt;WARNING:&lt;/strong&gt; This is considered to be a &apos;Product level&apos; extension and should not be used in consumable plugins without great care.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of a perspective extension (note the subelements and the way attributes are used):
-&lt;p&gt;
-&lt;pre&gt;
-    &lt;extension point=&quot;org.blueberry.ui.perspectiveExtensions&quot;&gt;
-        &lt;perspectiveExtension
-            targetID=&quot;org.blueberry.ui.resourcePerspective&quot;&gt;
-            &lt;actionSet id=&quot;org.xyz.MyActionSet&quot;/&gt;
-            &lt;viewShortcut id=&quot;org.xyz.views.PackageExplorer&quot;/&gt;
-            &lt;newWizardShortcut id=&quot;org.xyz.wizards.NewProjectCreationWizard&quot;/&gt;
-            &lt;perspectiveShortcut id=&quot;org.xyz.MyPerspective&quot;/&gt;
-            &lt;view id=&quot;org.xyz.views.PackageExplorer&quot;
-                relative=&quot;org.blueberry.ui.views.ResourceNavigator&quot;
-                relationship=&quot;stack&quot;/&gt;
-            &lt;view id=&quot;org.xyz.views.TypeHierarchy&quot;
-                relative=&quot;org.blueberry.ui.views.ResourceNavigator&quot;
-                relationship=&quot;left&quot;
-                ratio=&quot;0.50&quot;/&gt;
-        &lt;/perspectiveExtension&gt;
-    &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-&lt;p&gt;
-In the example above, an action set, view shortcut,
-new wizard shortcut, and perspective shortcut are
-contributed to the initial contents of the
-Resource Perspective.  In addition, the
-Package Explorer view is stacked on the
-Resource Navigator and the Type Hierarchy View is
-added beside the Resource Navigator.
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         The items defined within the perspective extension are contributed to the initial contents of the target perspective.  Following this, the user may remove any contribution or add others to a perspective from within the workbench user interface.
-      </documentation>
-   </annotation>
-
-
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2002, 2007 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/perspectives.exsd b/Plugins/org.blueberry.ui.qt/schema/perspectives.exsd
deleted file mode 100755
index 8e355d8ed3..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/perspectives.exsd
+++ /dev/null
@@ -1,181 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.ui" id="perspective" name="Perspectives"/>
-      </appInfo>
-      <documentation>
-         This extension point is used to add perspective factories to the workbench.  A perspective factory is used to define the initial layout and visible action sets for a perspective.  The user can select a perspective by invoking the &quot;Open Perspective&quot; submenu of the &quot;Window&quot; menu.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="perspective" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="perspective">
-      <annotation>
-         <appInfo>
-            <meta.element labelAttribute="name" icon="icon"/>
-         </appInfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="description" minOccurs="0" maxOccurs="1"/>
-            <element ref="keywordReference" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique name that will be used to identify this perspective.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a translatable name that will be used in the workbench window menu bar to represent this perspective.
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified name of the class that implements
-&lt;samp&gt;berry::IPerspectiveFactory&lt;/samp&gt; interface.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="berry::IPerspectiveFactory"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="icon" type="string">
-            <annotation>
-               <documentation>
-                  a relative name of the icon that will be associated
-with this perspective.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="resource"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="fixed" type="boolean">
-            <annotation>
-               <documentation>
-                  indicates whether the layout of the perspective is fixed.  If true, then views created by the perspective factory are not closeable, and cannot be moved.  The default is false.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="description" type="string">
-      <annotation>
-         <appInfo>
-            <meta.element translatable="true"/>
-         </appInfo>
-         <documentation>
-            an optional subelement whose body should contain text providing a short description of the perspective.
-         </documentation>
-      </annotation>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of a perspective extension:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension
-        point=&quot;org.blueberry.ui.perspectives&quot;&gt;
-        &lt;perspective
-            id=&quot;org.blueberry.ui.resourcePerspective&quot;
-            name=&quot;Resource&quot;
-            class=&quot;berry::ResourcePerspective&quot;
-            icon=&quot;resources/MyIcon.gif&quot;&gt;
-        &lt;/perspective&gt;
-    &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         The value of the &lt;samp&gt;class&lt;/samp&gt; attribute must be the
-fully qualified name of a class that implements
-&lt;samp&gt;berry::IPerspectiveFactory&lt;/samp&gt;.
-The class must supply the initial layout for a
-perspective when asked by the workbench.
-&lt;p&gt;
-The &lt;samp&gt;plugin_customization.ini&lt;/samp&gt; file is used to define the default perspective.  The &lt;i&gt;default perspective&lt;/i&gt; is the first perspective which appears when the product is launched after install.  It is also used when the user opens a page or window with no specified perspective.  The default perspective is defined as a property within the plugin_customization.ini, as shown below.  The user may also override this perspective from the workbench perspectives preference page.
-&lt;pre&gt;
-    defaultPerspectiveId = org.blueberry.ui.resourcePerspective
-&lt;/pre&gt;
-The perspectives which appear in the &quot;Open Perspective&quot; menu are shortcuts for perspective selection.  This set is defined by the active perspective itself, and extensions made through the perspectiveExtensions extension point.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         The workbench provides a &quot;Resource Perspective&quot;.
-Additional perspectives may be added by plug-ins.
-They are selected using the &quot;Open Perspective&quot; submenu of the &quot;Window&quot; menu.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2002, 2005 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/preferencePages.exsd b/Plugins/org.blueberry.ui.qt/schema/preferencePages.exsd
deleted file mode 100644
index 0869da9db8..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/preferencePages.exsd
+++ /dev/null
@@ -1,195 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appinfo>
-         <meta.schema plugin="org.blueberry.ui" id="preferencePages" name="Preference Pages"/>
-      </appinfo>
-      <documentation>
-         The workbench provides one common dialog box for preferences.
-The purpose of this extension point is to allow plug-ins to add
-pages to the preference dialog box. When preference dialog box
-is opened (initiated from the menu bar), pages contributed in
-this way will be added to the dialog box.
-
-&lt;p&gt;
-The preference dialog
-box provides for hierarchical grouping of the pages. For this
-reason, a page can optionally specify a &lt;samp&gt;category&lt;/samp&gt; attribute.
-This
-attribute represents a path composed of parent page IDs separated
-by &apos;/&apos;. If this attribute is omitted or if any of the parent
-nodes in the path cannot be found, the page will be added at
-the root level.
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="page" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="page">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="name"/>
-         </appinfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="keywordReference" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique name that will be used to identify this page.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a translatable name that will be used in the UI for this page.
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a name of the fully qualified class that implements
-&lt;samp&gt;berry::IWorkbenchPreferencePage&lt;/samp&gt;.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.jface.preference.PreferencePage:org.eclipse.ui.IWorkbenchPreferencePage"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="category" type="string">
-            <annotation>
-               <documentation>
-                  a path indicating the location of the page in the preference tree. The path may either be a parent node ID or a sequence
-     of IDs separated by &apos;/&apos;, representing the full path from the root node.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="identifier" basedOn="org.eclipse.ui.preferencePages/page/@id"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="keywordReference">
-      <annotation>
-         <documentation>
-            A reference by a preference page to a keyword. See the keywords extension point.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The id of the keyword being referred to.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="identifier" basedOn="org.eclipse.ui.keywords/keyword/@id"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="examples"/>
-      </appinfo>
-      <documentation>
-         The following is an example for the preference extension point:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension
-       point=&quot;org.blueberry.ui.preferencePages&quot;&gt;
-      &lt;page
-         id=&quot;com.xyz.prefpage1&quot;
-         name=&quot;XYZ&quot;
-         class=&quot;xyz::PrefPage1&quot;&gt;
-         &lt;keywordReference id=&quot;xyz.Keyword&quot;/&gt;
-      &lt;/page&gt;
-      &lt;page
-         id=&quot;com.xyz.prefpage2&quot;
-         name=&quot;Keyboard Settings&quot;
-         class=&quot;xyz::PrefPage2&quot;
-         category=&quot;com.xyz.prefpage1&quot;&gt;
-      &lt;/page&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="apiInfo"/>
-      </appinfo>
-      <documentation>
-         The value of the attribute class must represent a fully qualified name of the class that implements
-&lt;samp&gt;berry::IWorkbenchPreferencePage&lt;/samp&gt;.
-      </documentation>
-   </annotation>
-
-
-
-   <annotation>
-      <appinfo>
-         <meta.section type="implementation"/>
-      </appinfo>
-      <documentation>
-         The workbench adds several pages for setting the preferences of the platform. Pages registered
-through this extension will be added after them according to their category information.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="copyright"/>
-      </appinfo>
-      <documentation>
-         Copyright (c) 2002, 2005 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/presentationFactories.exsd b/Plugins/org.blueberry.ui.qt/schema/presentationFactories.exsd
deleted file mode 100755
index e7dcb6d72f..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/presentationFactories.exsd
+++ /dev/null
@@ -1,125 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.blueberry.ui" id="presentationFactories" name="Presentation Factories"/>
-      </appInfo>
-      <documentation>
-         This extension point is used to add presentation factories to the workbench.
-         A presentation factory defines the overall look and feel of the workbench,
-         including how views and editors are presented.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="factory" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="factory">
-      <complexType>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  Specify the fully qualified class to be used for the presentation factory.  The specified value must implement the interface &lt;code&gt;berry::IPresentationFactory&lt;/code&gt;.
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.ui.presentations.AbstractPresentationFactory"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique name that will be used to identify this presentation factory
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a translatable name that can be used to show this presentation factory in the UI
-               </documentation>
-               <appInfo>
-                  <meta.attribute translatable="true"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         The following is an example of a presentationFactory extension:
-&lt;pre&gt;
-  &lt;extension point=&quot;org.blueberry.ui.presentationFactories&quot;&gt;
-     &lt;factory
-        class=&quot;berry::ExampleWorkbenchPresentationFactory&quot;/&gt;
-  &lt;/extension&gt;
-  &lt;/pre&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         The class specified in the factory element must be a concrete subclass of &lt;code&gt;org.eclipse.ui.presentations.AbstractPresentationFactory&lt;/code&gt;.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         If a presentation factory is not specified or is missing then the implementation in &lt;code&gt;berry::QtWorkbenchPresentationFactory&lt;/code&gt; will be used.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2004, 2005 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/services.exsd b/Plugins/org.blueberry.ui.qt/schema/services.exsd
deleted file mode 100755
index b07d5c4c07..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/services.exsd
+++ /dev/null
@@ -1,226 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appinfo>
-         <meta.schema plugin="org.blueberry.ui" id="services" name="Services"/>
-      </appinfo>
-      <documentation>
-         Define service factories so that services can be contributed declaratively and will be available through &lt;code&gt;berry::IServiceLocator::GetService(Class)&lt;/code&gt;.  The implementation of &lt;code&gt;AbstractServiceFactory&lt;/code&gt; must be able to return a global service and multiple child services (if applicable).
-&lt;p&gt;
-Services must follow a general contract:
-&lt;ul&gt;
-&lt;li&gt;The top level service has no parent.&lt;/li&gt;
-&lt;li&gt;The child service may use the supplied parent, which can be cast to the service interface.&lt;/li&gt;
-&lt;li&gt;Any other services needed for initialization should be retrieved from the &lt;code&gt;berry::IServiceLocator&lt;/code&gt;.&lt;/li&gt;
-&lt;li&gt;If the service needs to clean up any state (like listeners) it should implement &lt;code&gt;berry::IDisposable&lt;/code&gt;.&lt;/li&gt;
-&lt;li&gt;Services should clearly specify when they perform cleanup for clients, such as removing listeners automatically on disposal.&lt;/li&gt;
-&lt;/ul&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <documentation>
-            Contribute services to the workbench.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence minOccurs="1" maxOccurs="unbounded">
-            <element ref="serviceFactory" minOccurs="0" maxOccurs="1"/>
-            <element ref="sourceProvider" minOccurs="0" maxOccurs="1"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="serviceFactory">
-      <annotation>
-         <documentation>
-            Match a service interface to a factory that can supply a hierachical implementation of that service.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="service" minOccurs="1" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="factoryClass" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The factory that extends &lt;code&gt;AbstractServiceFactory&lt;/code&gt; and can create the implementation for the serviceClass.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.ui.services.AbstractServiceFactory:"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="service">
-      <annotation>
-         <documentation>
-            A service this factory can provide.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="serviceClass" type="string">
-            <annotation>
-               <documentation>
-                  The interface that represents a service contract.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="sourceProvider">
-      <annotation>
-         <documentation>
-            A Source Provider supplies source variables to the IEvaluationService.  It can also notify the IEvaluationService when one or more of the variables change.
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="variable" minOccurs="1" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="provider" type="string" use="required">
-            <annotation>
-               <documentation>
-                  This class must provide variables and call the appropriate fireSourceChanged(*) method when any of the variables change.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="org.eclipse.ui.AbstractSourceProvider:"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="variable">
-      <annotation>
-         <documentation>
-            A source variable from this provider.  A source provider must declare all variables that it provides.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The name of a contributed source variable.  It is a good practice to prepend the plugin id to the variable name to avoid collisions with other source providers.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="priorityLevel" use="required">
-            <annotation>
-               <documentation>
-                  For conflict resolution used by services like the IHandlerService, contributed source variables must assign a priority.  &lt;b&gt;workbench&lt;/b&gt; is the global default priority.  See &lt;code&gt;ISources&lt;/code&gt; for relative priority information.
-               </documentation>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="workbench">
-                  </enumeration>
-                  <enumeration value="activeContexts">
-                  </enumeration>
-                  <enumeration value="activeShell">
-                  </enumeration>
-                  <enumeration value="activeWorkbenchWindow">
-                  </enumeration>
-                  <enumeration value="activeEditorId">
-                  </enumeration>
-                  <enumeration value="activePartId">
-                  </enumeration>
-                  <enumeration value="activeSite">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="examples"/>
-      </appinfo>
-      <documentation>
-         &lt;p&gt;
-Here is a basic definition:
-&lt;pre&gt;
-   &lt;extension
-         point=&quot;org.blueberry.ui.services&quot;&gt;
-      &lt;serviceFactory
-            factoryClass=&quot;my::LevelServiceFactory&quot;&gt;
-         &lt;service
-               serviceClass=&quot;my::ILevelService&quot;&gt;
-         &lt;/service&gt;
-      &lt;/serviceFactory&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;&lt;/p&gt;
-&lt;p&gt;
-The &lt;code&gt;LevelServiceFactory&lt;/code&gt; can return an &lt;code&gt;ILevelService&lt;/code&gt; when it is requested from the &lt;code&gt;IServiceLocator&lt;/code&gt;:
-&lt;pre&gt;
-   berry::ILevelService::Pointer s = GetSite()-&gt;GetService(my::ILevelService::GetStaticClassName());
-   std::cout &lt;&lt; s-&gt;GetLevel();
-&lt;/pre&gt;
-&lt;/p&gt;
-&lt;p&gt;
-In this test example, the factory would instantiate three &lt;code&gt;ILevelService&lt;/code&gt; implementations during the first call to &lt;code&gt;GetSite()-&gt;GetService(*)&lt;/code&gt;.  The global one in the workbench, one for the workbench window, and one for the site.
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="apiInfo"/>
-      </appinfo>
-      <documentation>
-         &lt;p&gt;
-Please see &lt;code&gt;org.eclipse.ui.services.AbstractServiceFactory&lt;/code&gt;, &lt;code&gt;org.eclipse.ui.services.IDisposable&lt;/code&gt;, and &lt;code&gt;org.eclipse.ui.services.IServiceWithSources&lt;/code&gt; for more information.
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-
-
-   <annotation>
-      <appinfo>
-         <meta.section type="copyright"/>
-      </appinfo>
-      <documentation>
-         Copyright (c) 2007 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/tweaklets.exsd b/Plugins/org.blueberry.ui.qt/schema/tweaklets.exsd
deleted file mode 100755
index 6d4f0a67d4..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/tweaklets.exsd
+++ /dev/null
@@ -1,145 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appinfo>
-         <meta.schema plugin="org.blueberry.ui" id="tweaklets" name="Tweaklets"/>
-      </appinfo>
-      <documentation>
-         This extension point is used to define tweaklets.  A tweaklet is anything that can be used to tweak the look and feel of the Workbench.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <appinfo>
-            <meta.element />
-         </appinfo>
-      </annotation>
-      <complexType>
-         <choice minOccurs="0" maxOccurs="unbounded">
-            <element ref="tweaklet"/>
-         </choice>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="tweaklet">
-      <annotation>
-         <appinfo>
-            <meta.element labelAttribute="name" icon="icon"/>
-         </appinfo>
-      </annotation>
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique name that will be used to identify this tweaklet
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a translatable name that will be used in the UI for this tweaklet
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="description" type="string">
-            <annotation>
-               <documentation>
-                  a translatable short description of this tweaklet, to be used in the UI
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="definition" type="string">
-            <annotation>
-               <documentation>
-                  an identifier of the tweaklet definition in the workbench, typically a fully qualified type name without colons
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="implementation" type="string">
-            <annotation>
-               <documentation>
-                  an identifier of the tweaklet implementation provided by the extender, typically a fully qualified class name
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-
-   <annotation>
-      <appinfo>
-         <meta.section type="apiInfo"/>
-      </appinfo>
-      <documentation>
-         The following is an example tweaklet:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension point=&quot;org.blueberry.ui.tweaklets&quot;&gt;
-      &lt;tweaklet
-         id=&quot;org.blueberry.ui.tweaklets.ConcreteXYZTweaklet&quot;
-         name=&quot;XYZ Tweaklet&quot;
-         description=&quot;Short description of the tweak&quot;
-         definition=&quot;berryAbstractXYZTweaklet&quot;
-         implementation=&quot;berry::ConcreteXYZTweaklet&quot;/&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="since"/>
-      </appinfo>
-      <documentation>
-         Typically, although not required, the value of the &lt;samp&gt;definition&lt;/samp&gt; attribute is the
-fully qualified name without colons of an abstract class defined by the
-workbench, and the value of the &lt;samp&gt;implementation&lt;/samp&gt; attribute is the
-fully qualified name of a non-abstract class provided by the extending plug-in.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="implementation"/>
-      </appinfo>
-      <documentation>
-         Tweaklets are usually used to specialize the workbench for a specific GUI toolkit.
-      </documentation>
-   </annotation>
-
-
-</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/views.exsd b/Plugins/org.blueberry.ui.qt/schema/views.exsd
deleted file mode 100755
index 3ebdced734..0000000000
--- a/Plugins/org.blueberry.ui.qt/schema/views.exsd
+++ /dev/null
@@ -1,311 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appinfo>
-         <meta.schema plugin="org.blueberry.ui" id="views" name="Views"/>
-      </appinfo>
-      <documentation>
-         This extension point is used to define additional views
-for the workbench.  A view is a visual component
-within a workbench page.  It is typically used to
-navigate a hierarchy of information (like the workspace),
-open an editor,  or display properties for
-the active editor.  The user can make a view
-visible from the Window &gt; Show View menu or close it from the
-view local title bar.
-&lt;p&gt;
-In order to reduce the visual clutter in the Show View Dialog, views should be grouped using categories.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <appinfo>
-            <meta.element />
-         </appinfo>
-      </annotation>
-      <complexType>
-         <choice minOccurs="0" maxOccurs="unbounded">
-            <element ref="category"/>
-            <element ref="view"/>
-            <element ref="stickyView"/>
-         </choice>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="category">
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique name that will be used to identify this category
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a translatable name that will be used in the UI for this category
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="parentCategory" type="string">
-            <annotation>
-               <documentation>
-                  an optional path composed of category IDs separated by &apos;/&apos;. This
-allows the creation of a hierarchy of categories.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/category/@id"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="view">
-      <complexType>
-         <sequence>
-            <element ref="description" minOccurs="0" maxOccurs="1"/>
-            <element ref="keywordReference" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a unique name that will be used to identify this view
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a translatable name that will be used in the UI for this view
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="category" type="string">
-            <annotation>
-               <documentation>
-                  an optional attribute that is composed of the category IDs separated
-by &apos;/&apos;. Each referenced category must be declared in a corresponding category element.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/category/@id"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified name of the class that implements
-&lt;samp&gt;berry::IViewPart&lt;/samp&gt;. A common practice
-is to subclass &lt;samp&gt;berry::ViewPart&lt;/samp&gt; or &lt;samp&gt;berry::QtViewPart&lt;/samp&gt;
-in order to inherit the default functionality.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="berryViewPart:"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="icon" type="string">
-            <annotation>
-               <documentation>
-                  a relative name of the icon that will
-be associated with the view.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="resource"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="fastViewWidthRatio" type="string">
-            <annotation>
-               <documentation>
-                  the percentage of the width of the workbench that the view will take up as an active fast view.
-This must be defined as a floating point value and lie between 0.05 and 0.95.
-If no value is supplied, a default ratio will be used.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="allowMultiple" type="boolean">
-            <annotation>
-               <documentation>
-                  flag indicating whether this view allows multiple instances to be created using IWorkbenchPage::ShowView(QString id, QString secondaryId).  The default is false.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="restorable" type="boolean" use="default" value="true">
-            <annotation>
-               <documentation>
-                  flag indicating whether this view allows to be restored upon workbench restart. If set to false, the view will not be open after a workbench restart. The default is true.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="description" type="string">
-      <annotation>
-         <appinfo>
-            <meta.element translatable="true"/>
-         </appinfo>
-         <documentation>
-            an optional subelement whose body should contain text providing a short description of the view.
-         </documentation>
-      </annotation>
-   </element>
-
-   <element name="stickyView">
-      <annotation>
-         <documentation>
-            A sticky view is a view that will appear by default across all perspectives in a window once it is opened.  Its initial placement is governemed by the location attribute, but nothing prevents it from being moved or closed by the user.  Use of this element will only cause a placeholder for the view to be created, it will not show the view.  Please note that usage of this element should be done with great care and should only be applied to views that truely have a need to live across perspectives.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the id of the view to be made sticky.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="location">
-            <annotation>
-               <documentation>
-                  optional attribute that specifies the location of the sticky view relative to the editor area.  If absent, the view will be docked to the right of the editor area.
-               </documentation>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="RIGHT">
-                  </enumeration>
-                  <enumeration value="LEFT">
-                  </enumeration>
-                  <enumeration value="TOP">
-                  </enumeration>
-                  <enumeration value="BOTTOM">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-         <attribute name="closeable" type="boolean">
-            <annotation>
-               <documentation>
-                  optional attribute that specifies wether the view should be closeable.  If absent it will be closeable.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="moveable" type="boolean">
-            <annotation>
-               <documentation>
-                  optional attribute that specifies wether the view should be moveable.  If absent it will be moveable.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="examples"/>
-      </appinfo>
-      <documentation>
-         The following is an example of the extension point:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension point=&quot;org.blueberry.ui.views&quot;&gt;
-      &lt;category
-         id=&quot;com.xyz.views.XYZviews&quot;
-         name=&quot;XYZ&quot;/&gt;
-      &lt;view
-         id=&quot;com.xyz.views.XYZView&quot;
-         name=&quot;XYZ View&quot;
-         category=&quot;com.xyz.views.XYZviews&quot;
-         class=&quot;ns::XYZView&quot;
-         icon=&quot;icons/XYZ.gif&quot;/&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-The following is an example of a sticky view declaration:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension point=&quot;org.blueberry.ui.views&quot;&gt;
-      &lt;stickyView
-         id=&quot;com.xyz.views.XYZView&quot; /&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="apiInfo"/>
-      </appinfo>
-      <documentation>
-         The value of the &lt;samp&gt;class&lt;/samp&gt; attribute must be a
-fully qualified name of the class that implements
-&lt;samp&gt;berry::IViewPart&lt;/samp&gt;.  It is common
-practice to subclass &lt;samp&gt;berry::ViewPart&lt;/samp&gt;
-or &lt;samp&gt;berry::QtViewPart&lt;samp&gt; when developing a new view.
-      </documentation>
-   </annotation>
-
-
-   <annotation>
-      <appinfo>
-         <meta.section type="implementation"/>
-      </appinfo>
-      <documentation>
-         The BlueBerry Platform provides a number of standard views. From the user point of view, these views are no different from any other view provided by the plug-ins. All the views can be shown from the &quot;Show View&quot; submenu of the &quot;Window&quot; menu. The position of a view is persistent: it is saved when the view is closed and restored when the view is reopened in a single session.  The position is also persisted between workbench sessions.
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="copyright"/>
-      </appinfo>
-      <documentation>
-         Copyright (c) 2002, 2005 IBM Corporation and others.&lt;br&gt;
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at &lt;a
-href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.mitk.core.ext/plugin.xml b/Plugins/org.mitk.core.ext/plugin.xml
index 6b6ceeb06f..8e95e4d3c5 100644
--- a/Plugins/org.mitk.core.ext/plugin.xml
+++ b/Plugins/org.mitk.core.ext/plugin.xml
@@ -1,4 +1,3 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <plugin>
-  <extension-point id="org.mitk.core.ext.inputdevices" name="Input Devices" schema="schema/inputdevice.exsd"/>
 </plugin>
diff --git a/Plugins/org.mitk.core.ext/schema/inputdevice.exsd b/Plugins/org.mitk.core.ext/schema/inputdevice.exsd
deleted file mode 100644
index 6fc8bb6533..0000000000
--- a/Plugins/org.mitk.core.ext/schema/inputdevice.exsd
+++ /dev/null
@@ -1,153 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<schema targetNamespace="org.mitk.core.ext" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
-      <appinfo>
-         <meta.schema plugin="org.mitk.core.ext" id="inputdevices" name="Input Devices"/>
-      </appinfo>
-      <documentation>
-         This extension point is used to define additional input devices.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <annotation>
-         <appinfo>
-            <meta.element />
-         </appinfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="inputdevice" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  an optional identifier of the extension instance
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="inputdevice">
-      <annotation>
-         <appinfo>
-            <meta.element />
-         </appinfo>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="description" minOccurs="0" maxOccurs="1"/>
-         </sequence>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  the identifier of the input device
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the input device
-               </documentation>
-               <appinfo>
-                  <meta.attribute translatable="true"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-         <attribute name="class" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified name of the class that implements
-&lt;samp&gt;mitk::IInputDevice&lt;/samp&gt;.
-               </documentation>
-               <appinfo>
-                  <meta.attribute kind="java" basedOn="mitk::IInputDevice"/>
-               </appinfo>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="description" type="string">
-      <annotation>
-         <appinfo>
-            <meta.element translatable="true"/>
-         </appinfo>
-         <documentation>
-            an optional subelement whose body should contain text providing a short description of the input device.
-         </documentation>
-      </annotation>
-   </element>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="examples"/>
-      </appinfo>
-      <documentation>
-         The following is an example of the extension point:
-&lt;p&gt;
-&lt;pre&gt;
-   &lt;extension point=&quot;org.mitk.core.ext.inputdevices&quot;&gt;
-      &lt;inputdevice
-         id=&quot;com.xyz.inputdevice.XYZDevice&quot;
-         name=&quot;XYZ Device&quot;
-         class=&quot;ns::XYZDevice&quot; &gt;
-         &lt;description&gt;My new 20-dimensional input device&lt;/description&gt;
-      &lt;/inputdevice&gt;
-   &lt;/extension&gt;
-&lt;/pre&gt;
-&lt;/p&gt;
-     </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="apiInfo"/>
-      </appinfo>
-      <documentation>
-         The value of the &lt;samp&gt;class&lt;/samp&gt; attribute must be a
-fully qualified name of the class that implements
-&lt;samp&gt;mitk::IInputDevice&lt;/samp&gt;.
-      </documentation>
-   </annotation>
-
-
-   <annotation>
-      <appinfo>
-         <meta.section type="implementation"/>
-      </appinfo>
-      <documentation>
-         The MITK Platform can handle multiple distinct input devices by...
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appinfo>
-         <meta.section type="copyright"/>
-      </appinfo>
-      <documentation>
-         Copyright (c) German Cancer Research Center (DKFZ)&lt;br&gt;
-All rights reserved.
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/Plugins/org.mitk.gui.common/src/mitkWorkbenchUtil.cpp b/Plugins/org.mitk.gui.common/src/mitkWorkbenchUtil.cpp
index 15e460609a..cd308e32cf 100644
--- a/Plugins/org.mitk.gui.common/src/mitkWorkbenchUtil.cpp
+++ b/Plugins/org.mitk.gui.common/src/mitkWorkbenchUtil.cpp
@@ -1,471 +1,473 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkWorkbenchUtil.h"
 
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIEditorRegistry.h>
 #include <berryCoreException.h>
 #include <berryIPreferencesService.h>
 #include <berryIPreferences.h>
 
 #include "mitkIDataStorageService.h"
 #include "mitkDataStorageEditorInput.h"
 #include "mitkRenderingManager.h"
 #include "mitkIRenderingManager.h"
 
 #include "mitkProperties.h"
 #include "mitkNodePredicateData.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkCoreObjectFactory.h"
 
 #include "QmitkIOUtil.h"
 
 #include <QMessageBox>
 #include <QApplication>
 #include <QDateTime>
 
 #include "internal/org_mitk_gui_common_Activator.h"
 
 namespace mitk {
 
   struct WorkbenchUtilPrivate {
 
     /**
      * Get the editor descriptor for a given name using the editorDescriptor
      * passed in as a default as a starting point.
      *
      * @param name
      *            The name of the element to open.
      * @param editorReg
      *            The editor registry to do the lookups from.
      * @param defaultDescriptor
      *            IEditorDescriptor or <code>null</code>
      * @return IEditorDescriptor
      * @throws PartInitException
      *             if no valid editor can be found
      */
     static berry::IEditorDescriptor::Pointer GetEditorDescriptor(const QString& name, berry::IEditorRegistry* editorReg, berry::IEditorDescriptor::Pointer defaultDescriptor)
     {
       if (defaultDescriptor.IsNotNull())
       {
         return defaultDescriptor;
       }
 
       berry::IEditorDescriptor::Pointer editorDesc = defaultDescriptor;
 
       // next check the OS for in-place editor (OLE on Win32)
       if (editorReg->IsSystemInPlaceEditorAvailable(name))
       {
         editorDesc = editorReg->FindEditor(berry::IEditorRegistry::SYSTEM_INPLACE_EDITOR_ID);
       }
 
       // next check with the OS for an external editor
       if (editorDesc.IsNull() && editorReg->IsSystemExternalEditorAvailable(name))
       {
         editorDesc = editorReg->FindEditor(berry::IEditorRegistry::SYSTEM_EXTERNAL_EDITOR_ID);
       }
 
       // if no valid editor found, bail out
       if (editorDesc.IsNull())
       {
         throw berry::PartInitException("No editor found");
       }
 
       return editorDesc;
     }
 
     static mitk::IDataStorageReference::Pointer GetDataStorageReference()
     {
       ctkPluginContext* context = mitk::PluginActivator::GetContext();
       mitk::IDataStorageService* dss = nullptr;
       ctkServiceReference dsRef = context->getServiceReference<mitk::IDataStorageService>();
       if (dsRef)
       {
         dss = context->getService<mitk::IDataStorageService>(dsRef);
       }
 
       if (nullptr == dss)
       {
         QString msg = "IDataStorageService service not available. Unable to open files.";
         MITK_WARN << msg.toStdString();
         QMessageBox::warning(QApplication::activeWindow(), "Unable to open files", msg);
         return mitk::IDataStorageReference::Pointer(nullptr);
       }
 
       // Get the active data storage (or the default one, if none is active)
       mitk::IDataStorageReference::Pointer dataStorageRef = dss->GetDataStorage();
       context->ungetService(dsRef);
 
       return dataStorageRef;
     }
 
   }; // end struct WorkbenchUtilPrivate
 
+  //! [UtilLoadFiles]
   void WorkbenchUtil::LoadFiles(const QStringList &fileNames, berry::IWorkbenchWindow::Pointer window, bool openEditor)
+  //! [UtilLoadFiles]
   {
     if (fileNames.empty())
     {
       return;
     }
 
     mitk::IDataStorageReference::Pointer dataStorageReference = WorkbenchUtilPrivate::GetDataStorageReference();
     if (nullptr == dataStorageReference)
     {
       return;
     }
     mitk::DataStorage::Pointer dataStorage = dataStorageReference->GetDataStorage();
 
     // Turn off ASSERT
 #if defined(_MSC_VER) && !defined(NDEBUG) && defined(_DEBUG) && defined(_CRT_ERROR)
     int lastCrtReportType = _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
 #endif
 
     // Do the actual work of loading the data into the data storage
     DataStorage::SetOfObjects::Pointer data;
     try
     {
       data = QmitkIOUtil::Load(fileNames, *dataStorage);
     }
     catch (const mitk::Exception& e)
     {
       MITK_INFO << e;
       return;
     }
     const bool dsmodified = !data->empty();
 
     // Set ASSERT status back to previous status.
 #if defined(_MSC_VER) && !defined(NDEBUG) && defined(_DEBUG) && defined(_CRT_ERROR)
     if (lastCrtReportType)
       _CrtSetReportMode(_CRT_ASSERT, lastCrtReportType);
 #endif
 
     // Check if there is an open perspective. If not, open the default perspective.
     if (window->GetActivePage().IsNull())
     {
       QString defaultPerspId = window->GetWorkbench()->GetPerspectiveRegistry()->GetDefaultPerspective();
       window->GetWorkbench()->ShowPerspective(defaultPerspId, window);
     }
 
     bool globalReinitOnNodeAdded = true;
     berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
     if (prefService != nullptr)
     {
       berry::IPreferences::Pointer prefs
         = prefService->GetSystemPreferences()->Node("org.mitk.views.datamanager");
       if (prefs.IsNotNull())
       {
         globalReinitOnNodeAdded = prefs->GetBool("Call global reinit if node is added", true);
       }
     }
 
     if (openEditor && globalReinitOnNodeAdded)
     {
       try
       {
         // Activate the editor using the same data storage or open the default editor
         mitk::DataStorageEditorInput::Pointer input(new mitk::DataStorageEditorInput(dataStorageReference));
         berry::IEditorPart::Pointer editor = mitk::WorkbenchUtil::OpenEditor(window->GetActivePage(), input, true);
         mitk::IRenderWindowPart* renderEditor = dynamic_cast<mitk::IRenderWindowPart*>(editor.GetPointer());
         mitk::IRenderingManager* renderingManager = renderEditor == nullptr ? nullptr : renderEditor->GetRenderingManager();
 
         if (dsmodified && renderingManager)
         {
           mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
         }
       }
       catch (const berry::PartInitException& e)
       {
         QString msg = "An error occurred when displaying the file(s): %1";
         QMessageBox::warning(QApplication::activeWindow(), "Error displaying file",
           msg.arg(e.message()));
       }
     }
   }
 
   berry::IEditorPart::Pointer WorkbenchUtil::OpenEditor(berry::IWorkbenchPage::Pointer page, berry::IEditorInput::Pointer input, const QString &editorId, bool activate)
   {
     // sanity checks
     if (page.IsNull())
     {
       throw std::invalid_argument("page argument must not be nullptr");
     }
 
     // open the editor on the input
     return page->OpenEditor(input, editorId, activate);
   }
 
   berry::IEditorPart::Pointer WorkbenchUtil::OpenEditor(berry::IWorkbenchPage::Pointer page, mitk::DataStorageEditorInput::Pointer input, bool activate, bool determineContentType)
   {
     // sanity checks
     if (page.IsNull())
     {
       throw std::invalid_argument("page argument must not be nullptr");
     }
 
     // open the editor on the data storage
     QString name = input->GetName() + ".mitk";
     berry::IEditorDescriptor::Pointer editorDesc = WorkbenchUtilPrivate::GetEditorDescriptor(name,
         berry::PlatformUI::GetWorkbench()->GetEditorRegistry(),
         GetDefaultEditor(name, determineContentType));
 
     return page->OpenEditor(input, editorDesc->GetId(), activate);
   }
 
   berry::IEditorDescriptor::Pointer WorkbenchUtil::GetEditorDescriptor(const QString& name, bool /*inferContentType*/)
   {
     if (name.isEmpty())
     {
       throw std::invalid_argument("name argument must not be empty");
     }
 
     // no used for now
     //IContentType contentType = inferContentType ? Platform
     //                                              .getContentTypeManager().findContentTypeFor(name) : null;
 
     berry::IEditorRegistry* editorReg = berry::PlatformUI::GetWorkbench()->GetEditorRegistry();
 
     return WorkbenchUtilPrivate::GetEditorDescriptor(name, editorReg, editorReg->GetDefaultEditor(name /*, contentType*/));
   }
 
   berry::IEditorDescriptor::Pointer WorkbenchUtil::GetDefaultEditor(const QString& name, bool /*determineContentType*/)
   {
     // Try file specific editor.
     berry::IEditorRegistry* editorReg = berry::PlatformUI::GetWorkbench()->GetEditorRegistry();
     try
     {
       QString editorID; // = file.getPersistentProperty(EDITOR_KEY);
       if (!editorID.isEmpty())
       {
         berry::IEditorDescriptor::Pointer desc = editorReg->FindEditor(editorID);
         if (desc.IsNotNull())
         {
           return desc;
         }
       }
     }
     catch (const berry::CoreException&)
     {
       // do nothing
     }
 
     //  IContentType contentType = null;
     //  if (determineContentType)
     //  {
     //    contentType = getContentType(file);
     //  }
 
       // Try lookup with filename
     return editorReg->GetDefaultEditor(name); //, contentType);
   }
 
   mitk::IRenderWindowPart* WorkbenchUtil::GetRenderWindowPart(berry::IWorkbenchPage::Pointer page, IRenderWindowPartStrategies strategies)
   {
     // Return the active editor if it implements mitk::IRenderWindowPart
     mitk::IRenderWindowPart* renderWindowPart = dynamic_cast<mitk::IRenderWindowPart*>(page->GetActiveEditor().GetPointer());
     if (renderWindowPart)
     {
       return renderWindowPart;
     }
 
     // No suitable active editor found, check visible editors
     QList<berry::IEditorReference::Pointer> editors = page->GetEditorReferences();
     for (QList<berry::IEditorReference::Pointer>::iterator i = editors.begin(); i != editors.end(); ++i)
     {
       berry::IWorkbenchPart::Pointer part = (*i)->GetPart(false);
       if (page->IsPartVisible(part))
       {
         renderWindowPart = dynamic_cast<mitk::IRenderWindowPart*>(part.GetPointer());
         if (renderWindowPart)
         {
           return renderWindowPart;
         }
       }
     }
 
     // No suitable visible editor found, check visible views
     QList<berry::IViewReference::Pointer> views = page->GetViewReferences();
     for (QList<berry::IViewReference::Pointer>::iterator i = views.begin(); i != views.end(); ++i)
     {
       berry::IWorkbenchPart::Pointer part = (*i)->GetPart(false);
       if (page->IsPartVisible(part))
       {
         renderWindowPart = dynamic_cast<mitk::IRenderWindowPart*>(part.GetPointer());
         if (renderWindowPart)
         {
           return renderWindowPart;
         }
       }
     }
 
     // No strategies given
     if (strategies == NONE)
     {
       return nullptr;
     }
 
     mitk::IDataStorageReference::Pointer dataStorageReference = WorkbenchUtilPrivate::GetDataStorageReference();
     if (nullptr == dataStorageReference)
     {
       return nullptr;
     }
 
     mitk::DataStorageEditorInput::Pointer input(new mitk::DataStorageEditorInput(dataStorageReference));
 
     bool activate = false;
     if (strategies & ACTIVATE)
     {
       activate = true;
     }
 
     berry::IEditorPart::Pointer editorPart;
     if (strategies & OPEN)
     {
       // This will create a default editor for the given input. If an editor
       // with that input is already open, the editor is brought to the front.
       try
       {
         editorPart = mitk::WorkbenchUtil::OpenEditor(page, input, activate);
       }
       catch (const berry::PartInitException&)
       {
         // There is no editor registered which can handle the given input.
       }
     }
     else if (activate || (strategies & BRING_TO_FRONT))
     {
       // check if a suitable editor is already opened
       editorPart = page->FindEditor(input);
       if (editorPart)
       {
         if (activate)
         {
           page->Activate(editorPart);
         }
         else
         {
           page->BringToTop(editorPart);
         }
       }
     }
 
     return dynamic_cast<mitk::IRenderWindowPart*>(editorPart.GetPointer());
   }
 
   mitk::IRenderWindowPart* WorkbenchUtil::OpenRenderWindowPart(berry::IWorkbenchPage::Pointer page, bool activatedEditor/* = true*/)
   {
     if (activatedEditor)
     {
       return GetRenderWindowPart(page, ACTIVATE | OPEN);
     }
     else
     {
       return GetRenderWindowPart(page, BRING_TO_FRONT | OPEN);
     }
   }
 
   bool WorkbenchUtil::SetDepartmentLogoPreference(const QString &logoResource, ctkPluginContext *context)
   {
     if (context == nullptr)
     {
       BERRY_WARN << "Plugin context invalid, unable to set custom logo.";
       return false;
     }
 
     // The logo must be available in the local filesystem. We check if we have not already extracted the
     // logo from the plug-in or if this plug-ins timestamp is newer then the already extracted logo timestamp.
     // If one of the conditions is true, extract it and write it to the plug-in specific storage location.
     const QString logoFileName = logoResource.mid(logoResource.lastIndexOf('/') + 1);
 
     if (logoFileName.isEmpty())
     {
       BERRY_WARN << "Logo file name empty, unable to set custom logo.";
       return false;
     }
 
     const QString logoPath = context->getDataFile("").absoluteFilePath();
 
     bool extractLogo = true;
     QFileInfo logoFileInfo(logoPath + "/" + logoFileName);
 
     if (logoFileInfo.exists())
     {
       // The logo has been extracted previously. Check if the plugin timestamp is newer, which
       // means it might contain an updated logo.
       QString pluginLocation = QUrl(context->getPlugin()->getLocation()).toLocalFile();
       if (!pluginLocation.isEmpty())
       {
         QFileInfo pluginFileInfo(pluginLocation);
         if (logoFileInfo.lastModified() > pluginFileInfo.lastModified())
         {
           extractLogo = false;
         }
       }
     }
 
     if (extractLogo)
     {
       // Extract the logo from the shared library and write it to disk.
       QFile logo(logoResource);
 
       if (!logo.exists())
       {
         BERRY_WARN << "Custom logo '" << logoResource << "' does not exist.";
         return false;
       }
 
       if (logo.open(QIODevice::ReadOnly))
       {
         QFile localLogo(logoPath + "/" + logoFileName);
 
         if (localLogo.open(QIODevice::WriteOnly))
         {
           localLogo.write(logo.readAll());
           localLogo.flush();
         }
       }
     }
 
     logoFileInfo.refresh();
 
     if (logoFileInfo.exists())
     {
       // Get the preferences service
       ctkServiceReference prefServiceRef = context->getServiceReference<berry::IPreferencesService>();
       berry::IPreferencesService* prefService = nullptr;
       if (prefServiceRef)
       {
         prefService = context->getService<berry::IPreferencesService>(prefServiceRef);
       }
 
       if (prefService)
       {
         prefService->GetSystemPreferences()->Put("DepartmentLogo", qPrintable(logoFileInfo.absoluteFilePath()));
       }
       else
       {
         BERRY_WARN << "Preferences service not available, unable to set custom logo.";
         return false;
       }
     }
     else
     {
       BERRY_WARN << "Custom logo at '" << logoFileInfo.absoluteFilePath().toStdString() << "' does not exist.";
       return false;
     }
 
     return true;
   }
 
 } // namespace mitk
diff --git a/Plugins/org.mitk.gui.qt.aicpregistration/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.aicpregistration/documentation/UserManual/Manual.dox
index 4da7b4f2b5..cba634a06f 100644
--- a/Plugins/org.mitk.gui.qt.aicpregistration/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.aicpregistration/documentation/UserManual/Manual.dox
@@ -1,80 +1,80 @@
 /**
 \page org_mitk_gui_qt_aicpregistration The Anisotropic Iterative Closest Point Registration Plugin
 
-\imageMacro{"QmitkAICPRegistration_Icon.xpm","Icon of the A-ICP Registration Plugin",2}
+\imageMacro{"QmitkAICPRegistration_Icon-dox.xpm","Icon of the A-ICP Registration Plugin",2}
 
 \tableofcontents
 
 \section org_mitk_gui_qt_aicpregistrationOverview Overview
 
 The Surfaceregistration plugin allows the user to compute a transformation
 between two surfaces and align them in 3D space. It performs the
 registration with the anisotropic iterative closest point algorithm (A-ICP)
 presented in L. Maier-Hein et al. "Convergent Iterative Closest-Point Algorithm to Accomodate
 Anisotropic and Inhomogenous Localization Error.", IEEE T Pattern Anal 34 (8),
 1520-1532, 2012. With the plugin it's also possible to compute
 the target registration error (TRE) between the two aligned surfaces with a given
 set of target points. In order to register the surfaces they need to be initially
 aligned to be able to run the fine registration with the A-ICP algorithm.
 
 \imageMacro{"QmitkAICPRegistration_Plugin.png","Overview of the A-ICP Registration Plugin.",28}
 
 \section org_mitk_gui_qt_aicpregistrationUsage Usage
 
 In order to run a registration at least two surfaces need to be loaded into
 the data manager. Once the surfaces are loaded, a moving and a
 fixed surface can be selected in the associated combo boxes of the plugin.
 When the <b>Register Surfaces</b> button is pressed the registration is started
 and the moving surface is transformed onto the fixed surface.
 
 \imageMacro{"QmitkAICPRegistration_Input.png","Select the surfaces to register.",28}
 
 \section org_mitk_gui_qt_aicpregistrationTargetRegistrationErrorCalculation Target Registration Error Calculation
 
 To compute the target registration error, enable the calculation via the checkbox
 in the target registration view. Once the TRE computation is enabled the
 combo boxes are activated to select the according target point sets.
 
 \imageMacro{"QmitkAICPRegistration_TRECalculation.png","Usage of the TRE calculation view.",28}
 
 \section org_mitk_gui_qt_aicpregistrationRegistrationSettings Registration Settings
 
 The following additional settings are available in the plugin to configure the algorithm:
 <ul>
   <li>A trimmed version of the algorithm.
   <li>Set the threshold for the algorithm to converge.
   <li>Limit the iterations.
   <li>Set the search radius.
 </ul>
 
 \imageMacro{"QmitkAICPRegistration_Settings.png","Additional registration settings.",28}
 
 \subsection org_mitk_gui_qt_aicpregistrationTrimmedRegistration Trimmed Registration
 
 This option enables a trimmed version of the algorithm to register partial overlapping
 surfaces. Once the option is enabled the user can specify the overlapping part of the surface.
 Valid values for the overlapping part lie between 0 an 1.
 The trimmed version of the algorithm uses only a fixed percentage of all correspondences found
 during one iteration. Only the best correspondences will be used during the registration process.
 
 \subsection org_mitk_gui_qt_aicpregistrationThreshold Threshold
 
 The user can specify the threshold which is used as a termination constraint for the algorithm.
 When the the change of the fiducial registration error (FRE)
 between to registrations falls under the specified threshold the algorithm terminates.
 Larger values can speedup the registration process at the cost of a more accurate result.
 
 \subsection org_mitk_gui_qt_aicpregistrationMaximumIterations Maximum Iterations
 
 The maximum amount of iterations used by the algorithm can be specified by the user.
 Once the algorithm reaches the maximum amount of iterations it will stop the registration process.
 
 \subsection org_mitk_gui_qt_aicpregistrationSearchRadius Search Radius
 
 The user can specify the search radius in mm used during the correspondence search
 in a kd tree. The default value is 30 mm. A small radius can speedup the
 algorithm but can in addition also lead in bad correspondences and therefore in an incorrect
 alignment of the surfaces.
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.aicpregistration/documentation/UserManual/QmitkAICPRegistration_Icon.xpm b/Plugins/org.mitk.gui.qt.aicpregistration/documentation/UserManual/QmitkAICPRegistration_Icon-dox.xpm
similarity index 100%
rename from Plugins/org.mitk.gui.qt.aicpregistration/documentation/UserManual/QmitkAICPRegistration_Icon.xpm
rename to Plugins/org.mitk.gui.qt.aicpregistration/documentation/UserManual/QmitkAICPRegistration_Icon-dox.xpm
diff --git a/Plugins/org.mitk.gui.qt.cest/documentation/UserManual/icon.svg b/Plugins/org.mitk.gui.qt.cest/documentation/UserManual/cest-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.cest/documentation/UserManual/icon.svg
rename to Plugins/org.mitk.gui.qt.cest/documentation/UserManual/cest-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.cest/documentation/UserManual/org_mitk_gui_qt_cest.dox b/Plugins/org.mitk.gui.qt.cest/documentation/UserManual/org_mitk_gui_qt_cest.dox
index b559b0388e..58b4cccb49 100644
--- a/Plugins/org.mitk.gui.qt.cest/documentation/UserManual/org_mitk_gui_qt_cest.dox
+++ b/Plugins/org.mitk.gui.qt.cest/documentation/UserManual/org_mitk_gui_qt_cest.dox
@@ -1,66 +1,66 @@
 /**
 \page org_mitk_gui_qt_cest The CEST View
 
-\imageMacro{icon.svg,"Icon of the cest view",2.00}
+\imageMacro{cest-dox.svg,"Icon of the cest view",2.00}
 
 \tableofcontents
 
 \section org_mitk_gui_qt_cestOverview Overview
 
 This view gives the option to explore and analyze CEST data. You can select a CEST data set together with either a segmentation or a point set in the datamanager. If a segmentation was selected (make sure the segmentation is the same in each time step, you can use the button at the top of the view to copy the first time step to all subsequent ones) a statistic for the selected region is shown. If a point set was selected each points grey value is plotted.
 
 \section org_mitk_gui_qt_cestDataLoading Data Loading
 
 CEST dicom data can be loaded either via file open or drag and drop. When a dicom file is loaded via MITK and it contains CEST meta information
  the CEST Dicom Reader is offered as an option. Selecting it will parse the CEST data as follows:
 
   An initial parsing determines whether the provided string belongs to CEST data at all.
   If the "tSequenceFileName" is of the format "{WHATEVER}CEST_Rev####" it is assumed that the
   data is indeed CEST data and was taken with revision #### (not limited to four digits).
 
   Which custom parameters to save and to which property name can be controlled by a json file.
   This file can be either provided as a resource for the MitkCEST module during compilation or
   placed next to the MitkCEST library in your binary folder.
 
   The expected format for the file "REVISIONNUMBER.json": <br>
   { <br>
   "REVISIONNUMBER" : "revision_json", <br>
   "sWiPMemBlock.alFree[1]" : "AdvancedMode", <br>
   "sWiPMemBlock.alFree[2]" : "RetreatMode" <br>
   } <br>
 
   where :
   <ul>
     <li> REVISIONNUMBER is the revision number of this json parameter mapping (files with non digit characters in their
   name will be ignored)
     <li> sWiPMemBlock.alFree[1] is the name of one parameter in the private dicom tag
     <li> AdvancedMode is the name of the property the content of sWiPMemBlock.alFree[1] should be saved to
   </ul>
 
   If the sampling type is list it will try to access LIST.txt at the same location as the dicom files
   read the offsets.
 
 \section org_mitk_gui_qt_cestCreatingSegmentation Creating a segmentation
 
 You can use the segmentation view to create a segmentation for the CEST data. Drawing a segmentation will by default only add it to
 the first timestep. For more information check the help of the segmentation view.
 
 You can copy the segmentation on the first timestep to all following ones by using the copy timestep button in this view.
 
 \section org_mitk_gui_qt_cestCreatingPointSet Creating a point set
 
 You can use the point set interaction view to create a point set for the CEST data.
 For more information check the help of the point set interaction view.
 
 \section org_mitk_gui_qt_cestNormalizing Normalizing the CEST data
 
 Select the CEST image in the datamanager and hit the normalize button to create a new, normalized image.
 
 \section org_mitk_gui_qt_cestInspectProperties Investigate CEST meta data
 
 You can inspect the CEST meta data with the properties view. You need to enable the developer mode in the "Window->Preferences" Properties menu.
 When selecting a data node in the data manager with the properties view active you can change the Property List from "Data node: common" to "Base data".
 
 The cest meta data is grouped under CEST.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/QmitkDatamanager.dox b/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/QmitkDatamanager.dox
index 78387972f7..505f2ac4bb 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/QmitkDatamanager.dox
+++ b/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/QmitkDatamanager.dox
@@ -1,194 +1,194 @@
 /**
 
-\page org_mitk_views_datamanager The Datamanager
+\page org_mitk_views_datamanager The Data Manager View
 
-\imageMacro{data-manager.svg,"Icon of the Data Manager", 2.00}
+\imageMacro{data-manager-dox.svg,"Icon of the Data Manager", 2.00}
 
 \tableofcontents
 
 \section DataManagerIntroduction Introduction
 
 The Datamanager is the central component to manage medical data like images, segmentation masks, registrations, surfaces, point sets, annotations, measurements, etc..<br>
 After loading data into the Datamanager the data is shown in the four-view window, the so-called <em>Standard Display</em>.
 The user can now start working on the data by interacting with the data inside the <em>Standard Display</em>,
 by using the MITK-plugins such as <em>Segmentation</em> or <em>Basic Image Processing</em> or by using the context menu inside the data manager.
 
 \section DataManagerLoadingData Loading Data
 
 There are several ways of loading data into the Datamanager as so-called <em>data nodes</em>:
 
 <ul>
   <li> drag and drop data (e.g. from a file explorer or desktop) into the Datamanager
   <li> drag and drop data (e.g. from a file explorer or desktop) into one of the four windows of the <em>Standard Display</em>
   <li> use the keyboard shortcut <em>Ctrl + o</em>
   <li> use the <em>Open File</em> Button in the left upper corner and use the <em>Open</em> Dialog
   <li> use <em>File -> Open File...</em> from the top menu
 </ul>
 
 A lot of file-formats can be loaded into MITK, for example:
 
 <ul>
   <li> 2D-images / 3D-volumes with or without several time steps (*.dcm, *.ima, *.pic, *.nrrd, ...)
   <li> Surfaces (*.stl, *.vtk, ...)
   <li> Point sets (*.mps)
   <li> and many more
 </ul>
 
-The user can also load a series of 2D images (e.g. image001.png, image002.png ...) to a MITK 3D volume. 
+The user can also load a series of 2D images (e.g. image001.png, image002.png ...) to a MITK 3D volume.
 To do this, just drag and drop one of those 2D data files into the Datamanager by holding the ALT key.
 <em>Note: What really happens is that the data nodes are stored inside a "Data storage" and the Datamanager is just a visual representation of the data inside the "Data storage".
 That's why the documentation sometimes uses the term "Data storage" instead of "Datamanager".</em>
 
 \section DataManagerSavingData Saving Data
 
 There are several ways of saving data from the Datamanager:
 
 <ul>
   <li> use the keyboard shortcut <em>Ctrl + s</em> on a single data node
   <li> use the keyboard shortcut <em>Ctrl + s</em> on multiple data nodes
   <li> use the context menu <em>right-click -> Save</em> on a single data node
   <li> use the context menu <em>right-click -> Save</em> on multiple data nodes
   <li> use <em>File -> Save...</em> from the top menu on a single data node
   <li> use <em>File -> Save...</em> from the top menu on multiple data nodes
 </ul>
 
 \section DataManagerWorking Working with the Datamanager
 
 After loading data into the Datamanager the data appears as data nodes in a sorted list inside the Datamanager.
 The user can change the order of the data nodes manually by dragging one or multiple data nodes and dropping them at any position inside the Datamanager.
 Data nodes can also be sorted hierarchically as a parent-child-relation.
 For example after using the <em>Segmentation-Plugin</em> to create a segmentation on <em>DataNode</em>, the result is created as <em>ChildNode</em>,
 which is a child of <em>DataNode</em> (see \ref ParentChild "Parent-Child-Relation" screenshot).<br>
 A parent-child-relation can be changed by dragging a child of a data node and dropping it onto another data node.
 For this the Property <em>Allow changing of parent nodes</em> needs to be enabled (see \ref DataManagerPreferences "Preferences").
 
 \anchor ParentChild
 \imageMacro{QmitkDatamanager_ParentChild.png, "Parent-Child-Relation", 16.00}
 
 \subsection DataManagerNodeVisibility Visibility of data nodes
 
 By default all loaded data nodes are visible in the <em>Standard Display</em>. The visibility is indicated by the checkbox in front of the data node name in the Datamanager.
 If a data node is visible, the checkbox is filled - an empty checkbox indicates a hidden data node (see \ref ParentChild "Parent-Child-Relation" screenshot).
 <em>Hint: The data nodes are rendered on top of each other, such that the topmost visible data node is always displayed on top of other data nodes. By hiding
 the topmost visible data node the next data node becomes the topmost visible data node and the hidden data node is not rendered anymore.</em>
 <em>Note: "Visible" does not mean that the node is correctly displayed inside the render windows. The user might have to re-initialize a data node to have it correctly displayed.</em>
 
 \subsection DataManagerNodeSelection Selection of data nodes
 
 Some MITK-plugins contain widgets to control the data nodes that are used for plugin-specific data processing. These widgets can be configured such that they listen to
 the current selection of the Datamanager. Having such a plugin active each selection change of data nodes inside the data manager will change the respective selection of
 the plugin. The data node selection widgets can have specific node predicates, which means that only specific data nodes can be controlled by the widgets. It might happen
 that a selected data node will not be represented in such a selection widget or that the selection widget will be emptied.
 
 \subsection DataManagerNodeRenaming Renaming data nodes
 
 There are two ways of changing the name of a data node inside the Datamanager:
 
 <ul>
   <li> use the <em>F2</em> key on a single data node
   <li> double-click on a single data node
 </ul>
 
 In both cases the new name can be accepted by hitting <em>Enter</em> or by clicking somewhere else.
 
 \section DataManagerContextMenu Context Menu
 
 The Datamanager provides a context menu for each data node that can be opened by right-clicking on a data node.
 An example of the context-menu can be seen in the \ref ContextMenu "Context menu" screenshot.
 The context menu allows to quickly perform common actions on data nodes. These actions differ according to the data type. Some of these actions are described here.
 For more actions see the respective modules and plugins (e.g. <tt>QmitkCreatePolygonModelAction</tt> inside the <tt>org_mitk_gui_qt_segmentation</tt>-plugin.
 
 <ul>
   <li> <em>Global Reinit</em>: Re-initializes the render windows to the common bounding box of all data nodes of the data storage that
     <ul>
       <li> have not set <tt>"includeInBoundingBox"</tt> to false
       <li> are <tt>"visible"</tt>.
     </ul>
     In this case it does not matter on which node this action is performed.
 	<li> <em>Reinit</em>: Re-initializes the render windows to the common bounding box of all selected data nodes of the data storage that
     <ul>
       <li> have not set <tt>"includeInBoundingBox"</tt> to false
       <li> are <tt>"visible"</tt>.
     </ul>
   <li> <em>Save</em>: see \ref DataManagerSavingData "Saving Data" section
   <li> <em>Remove</em>: Removes all selected data nodes from the data storage.
   <li> <em>Show only selected nodes</em>: Enables the visibility of all selected data nodes and hides all other data nodes.
   <li> <em>Toggle visibility</em>: Shows / hides each selected data node according to each node's current visibility state.
   <li> <em>Show details</em>: Opens a pop-up window with detailed information about each node, like data type, geometry, DICOM information, file path etc.
   <li> <em>Opacity</em>: Sets the opacity via a slider for the rendering of the selected data node.
   <li> <em>Color</em>: Opens a pop-up window that allows to pick an arbitrary color for the rendering of all selected data nodes.
   <li> <em>Colormap</em>: Opens another submenu with a list of different colormaps that can be chosen for the rendering of all selected data nodes.
   <li> <em>Component</em>: Sets the currently visible data component for the rendering of this particular component of the selected data node.
   <li> <em>Texture Interpolation</em>: Smooths the data visualization for rendering of a selected data node.
   <li> <em>Surface Representation</em>: Opens another submenu with the following entries:
     <ul>
       <li> <em>Points</em>: Visually represents a surface (a data type) as a set of points.
       <li> <em>Wireframe</em>: Visually represents a surface (a data type) as a wireframe model.
       <li> <em>Surface</em>: Visually represents a surface (a data type) as a solid surface.
     </ul>
 </ul>
 
 As the description of the actions showed, it is possible to open / use the context menu with a single data node or with a set of selected data nodes.
 If the data types of multiple selected data nodes differ, the actions might not appear / work as expected. Also some actions are not available for a set of selected data nodes.
 
 \anchor ContextMenu
 \imageMacro{QmitkDatamanager_ContextMenu.png, "Context menu", 16.00}
 
 \section DataManagerPreferences Preferences
 
 The MITK Workbench provides a <em>preference page</em> for specific plugins. The preference page provided for the Datamanager can be seen in the \ref PreferencePage "Preference page" screenshot.
 The user can open the preference page by
 <ul>
   <li> using the keyboard shortcut <em>Ctrl + p</em>
   <li> using <em>Window -> Preferences...</em> from the top menu.
 </ul>
 
 It allows to set the following preferences for the Datamanager, which define the behavior of the Datamanager:
 <ul>
   <li> <em>Place new nodes on top</em>: If enabled, newly added data nodes will be inserted at the top of the list of data nodes inside the Datamanager.
   If disabled, newly added nodes will be inserted at the bottom of the list.
   <li> <em>Show helper objects</em>: If enabled, data nodes that have set <tt>"helper object"</tt> to true will be displayed in the Datamanager.
   If disabled, data nodes that have set <tt>"helper object"</tt> to true will not be visible in the Datamanager.
   <li> <em>Show nodes containing no data</em>: If enabled, data nodes that have no underlying base data defined will be displayed in the Datamanager.
   If disabled, data nodes that have no underlying base data defined will not be visible in the Datamanager.
   <li> <em>Use surface decimation</em>: If enabled, a newly created surface will be decimated to reduce the number of triangles in the triangle mesh.
   Such a surface can be created as a polygon model from a segmentation (see \ref DataManagerContextMenu "Context Menu").
   If disabled, the surface will have its original number of triangles in the triangle mesh.
   <li> <em>Allow changing of parent node</em>: If enabled, the user can change the hierarchy of the data nodes manually by dragging one or multiple data nodes and
   dropping them at any position inside the Datamanager (see \ref DataManagerWorking "Working with the Datamanager") for changing the order of the data nodes manually).
 </ul>
 
 \anchor PreferencePage
 \imageMacro{QmitkDatamanager_PreferencePage.png, "Preference page", 16.00}
 
 \section DataManagerHotkeys Hotkeys
 
 The MITK Workbench provides hotkeys for specific plugins. The hotkeys provided for the Datamanager can be seen in the \ref Hotkeys "Hotkeys" screenshot.
 They allow to expedite common operations in relation to data nodes or the Datamanager.
 The user can customize the hotkeys by accessing the <em>preference page</em>:
 <ul>
   <li> using the keyboard shortcut <em>Ctrl + p</em>
   <li> useing <em>Window -> Preferences...</em> from the top menu
 </ul>
 
 <ul>
   <li> <em>Delete selected nodes</em> Removes all selected data nodes from the data storage.
   <li> <em>Global reinit</em> Re-initializes the render windows to the common bounding box of all data nodes of the data storage that
     <ul>
       <li> have not set <tt>"includeInBoundingBox"</tt> to false
       <li> are <tt>"visible"</tt>
     </ul>
     In this case it does not matter on which node this action is performed.
   <li> <em>Make all nodes invisible</em> Hides all data nodes of the data storage.
   <li> <em>Reinit selected nodes</em> Re-initializes the render windows to the common bounding box of all selected data nodes of the data storage that
     <ul>
       <li> have not set <tt>"includeInBoundingBox"</tt> to false
       <li> are <tt>"visible"</tt>
     </ul>
   <li> <em>Show node information</em> Opens a pop-up window with detailed information about each node, like data type, geometry, DICOM information, file path etc.
   <li> <em>Toggle visibility of selected nodes</em>: Shows / hides each selected data node according to each node's current visibility state.
 </ul>
 
 \anchor Hotkeys
 \imageMacro{QmitkDatamanager_Hotkeys.png, "Hotkeys", 16.00}
 */
diff --git a/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/data-manager.svg b/Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/data-manager-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/data-manager.svg
rename to Plugins/org.mitk.gui.qt.datamanager/documentation/UserManual/data-manager-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.datamanager/plugin.xml b/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
index 43c6e710de..703cfb91f8 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
+++ b/Plugins/org.mitk.gui.qt.datamanager/plugin.xml
@@ -1,29 +1,26 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <plugin>
   <extension point="org.blueberry.ui.views">
     <view
       id="org.mitk.views.datamanager"
       name="Data Manager"
       category="Data"
       icon="resources/data-manager.svg"
       class="QmitkDataManagerView" />
   </extension>
 
   <extension point="org.blueberry.ui.preferencePages">
     <page id="org.mitk.gui.qt.application.DataManagerPreferencePage" name="Data Manager" class="QmitkDataManagerPreferencePage">
       <keywordreference id="org.mitk.gui.qt.application.DataManagerPreferencePageKeywords"></keywordreference>
     </page>
 	<page id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPage" name="Hotkeys" class="QmitkDataManagerHotkeysPrefPage" category="org.mitk.gui.qt.application.DataManagerPreferencePage">
       <keywordreference id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPageKeywords"></keywordreference>
     </page>
   </extension>
 
   <extension point="org.blueberry.ui.keywords">
     <keyword id="org.mitk.gui.qt.application.DataManagerPreferencePageKeywords" label="data manager global reinit surface decimation parent helper objects single click property editing nodes top show containing data deleted added call"></keyword>
     <keyword id="org.mitk.gui.qt.application.DataManagerHotkeysPrefPageKeywords" label="data manager hotkeys delete selected nodes global reinit invisible show information toggle visibility selected"></keyword>
   </extension>
-
-  <extension-point id="contextMenuActions" name="Context menu actions"/>
-
 </plugin>
diff --git a/Plugins/org.mitk.gui.qt.deformableclippingplane/documentation/UserManual/QmitkClippingPlane.dox b/Plugins/org.mitk.gui.qt.deformableclippingplane/documentation/UserManual/QmitkClippingPlane.dox
index 01adc438d8..feb3c7e1f5 100644
--- a/Plugins/org.mitk.gui.qt.deformableclippingplane/documentation/UserManual/QmitkClippingPlane.dox
+++ b/Plugins/org.mitk.gui.qt.deformableclippingplane/documentation/UserManual/QmitkClippingPlane.dox
@@ -1,73 +1,73 @@
 /**
-\page org_mitk_views_deformableclippingplane The Clipping Plane
+\page org_mitk_views_deformableclippingplane The Clipping Plane View
 
 \imageMacro{QmitkClippingPlane_Icon.png,"Icon of the Clipping Plane Plugin",5.00}
 
 
 \imageMacro{QmitkClippingPlane_Overview2.png,"Clipping Plane view",16.00}
 
 \tableofcontents
 
 \section org_mitk_views_clippingPlaneManualOverview Overview
 
 The <b>Clipping Plane view</b> allows you to create clipping planes and calculate the volumina of the devided parts.
 
 
 \section org_mitk_views_clippingPlaneTechnicalIssue Technical Issue
 
 To use the Update Volumina function your image should be binary.
 
 \section org_mitk_views_clippingPlaneManualImageSelection Image Selection
 
 The Clipping Plane view makes use of the Data Manager view to give you an overview of all images, segmentations and clipping planes.
 
 \imageMacro{QmitkClippingPlane_DataManager.png,"Data Manager is used for selecting the current clipping plane. The reference plane is selected in the drop down box of the control area.",8.00}
 
 To select the reference plane use the drop down box in the control area of the Clipping Plane view or the Data Manager. The clipping plane selected in the Data Manager is displayed below the drop down box. If no clipping plane exists or none is selected create a new clipping plane by using the "Create new clipping plane" button.
 Some items of the graphical user interface might be disabled when no plane is selected.
 In any case, the application will give you hints if a selection is needed.
 
 \section org_mitk_views_clippingPlaneCreating Creating New Clipping Plane
 
 If you want to create a new clipping plane select an image from the Data Manager and press the button "Create new clipping plane". Optionally you can enable the "...with surface model" option.
 
 \section org_mitk_views_clippingPlaneInteraction Interaction with the planes
 \imageMacro{QmitkClippingPlane_Interaction.png,"The interaction buttons",5.00}
 
 You have different options to interact with the clipping planes:
 
 \subsection org_mitk_views_clippingPlaneTranslation Translation
 
 In Translation mode you can change the position of the clipping plane.
  - Click the Translation Button
  - Move mouse over the selected clipping plane (the plane changes its color from blue to green)
  - Hold mouse-left button and move the mouse orthogonally to the plane
 
 \subsection org_mitk_views_clippingPlaneRotation Rotation
 
 In Rotation mode you can change the angle of the clipping plane.
  - Click the Rotation Button
  - Move mouse over the selected clipping plane (the plane changes its color from blue to green)
  - Hold mouse-left button and move the mouse in the direction it should be rotated
 
 \subsection org_mitk_views_clippingPlaneDeformation Deformation
 
 In Deformation mode you can change the surface of the clipping plane.
  - Click the Deformation Button
  - Move mouse over the selected clipping plane (the plane changes its color from blue to green). The deformation area is highlighted in red and yellow.
  - On mouse-scrolling you can change the size of the deformation area (Scroll-Down = smaller / Scroll-Up = bigger).
  - Hold mouse-left button and move the mouse orthogonally to the plane to deformate the plane
 
 \section org_mitk_views_clippingPlaneUpdateVolumina Update Volumina
 
 \imageMacro{QmitkClippingPlane_UpdateVolumina.png,"The 'Update Volumina' button",5.00}
 
 Calculating the volumina of the segmentation parts, which are devided by the clipping plane(s).
  - Create a segmentation (see Segmentation-Manual)
  - Create one or more clipping plane(s)
  - Use the interaction buttons (Translation, Rotation, Deformation) to adjust the clipping plane for intersecting the segmentation
  - (You can decide which planes shouldnt be included for the calculation by changing their visibility to invisible)
  - Click button "Update Volumina" button
  - The intersected parts are displayed in different colors and their volumina are shown beneath the "Update Volumina" button
 
 **/
diff --git a/Plugins/org.mitk.gui.qt.dicombrowser/documentation/UserManual/QmitkDicom.dox b/Plugins/org.mitk.gui.qt.dicombrowser/documentation/UserManual/QmitkDicom.dox
index 233ac4a5fb..e90b0a2e04 100644
--- a/Plugins/org.mitk.gui.qt.dicombrowser/documentation/UserManual/QmitkDicom.dox
+++ b/Plugins/org.mitk.gui.qt.dicombrowser/documentation/UserManual/QmitkDicom.dox
@@ -1,118 +1,118 @@
 /**
 \page org_mitk_editors_dicombrowser The Dicom Browser Plugin
 
-\imageMacro{dicom.svg,"Icon of the DICOM Plugin",2.00}
+\imageMacro{dicombrowser-dox.svg,"Icon of the DICOM Plugin",2.00}
 
 \note This article requires a basic knowledge of the DICOM Standard.
 
 \tableofcontents
 
 \section org_mitk_gui_qt_dicomOverview Overview
 
 The DICOM editor is an experimental editor which allows for loading of DICOM images as well as server communication.
 It features a highly experimental query/retrieve (you need to configure your PACS correspondingly) as well as a DICOM browser.
 The DICOM browser allows you to navigate the DICOM folder/cd depending on its metadata (patient/study/series)
 and import selected series for viewing in your MITK based application.
 It also allows you to store your dicom data in an internal database so you can easily access often used dicom images.
 
 It is based on the <a href="http://www.commontk.org/index.php/Documentation/Dicom_Overview">commonTK (CTK) DICOM funcionality</a>.
 
 \section org_mitk_gui_qt_dicomDataHandling Data handling
 \imageMacro{QmitkDicom_PluginControls.png,"The dicom Plugin controls",7.37}
 In the image above you see the start page of the dicom plugin. On top of the start page you see four buttons. The Local Storage,
  the Import CD, the Import Folder and the Query Retrieve button. If you press one of these buttons, the dicom plugin will switch to your local dicom image storage or will start importing dicom images
 from CD or a folder on your hard drive or it will open the query retrieve screen.
 <ul>
 <li> Click the 'Local Storage' button to open the local storage screen.
 <li> Click the 'Import CD' button to import DICOM data from a CD.
 <li> Click the 'Import Folder' button to import DICOM date from a directory.
 <li> Click the 'Query Retrieve' button to open the query retrieve screen.
 </ul>
 
 \subsection org_mitk_gui_qt_dicomStorage Data storage
 \imageMacro{QmitkDicom_PluginExtended.png,"The DICOM data storage",16.00}
 If you open the dicom plugin the dicom data storage will be displayed. You are able to see all your stored dicom image data.
 You can browse your data by clicking on the left arrow beside the name of your data. There are three levels available.
 The first level is the patient level where you can see the patient data. On the second level you can see the dicom studies for the patient.
 on the third level you can see all available series refering to it's study.
 You can delete the data by selecting it and pressing the delete button.
 Be careful if you have selected a patient or a study all refering data be deleted.
 So if you delete a patient the patient and all studies and series refered to the patient will be deleted.
 If you delete a study all series of the study will be deleted.
 If you want to view the dicom data you have to select a series and click on the View button.
 The data will appear in the DataManager and will be dispayed.
 \imageMacro{QmitkDicom_DisplayDataManager.png,"Viewed image",16.00}
 <ul>
 <li> Click on the arrow on the left of your data to expand or hide dicom data levels.
 <li> Click the 'Delete' button to delete selected DICOM data.
 <li> Click the 'View' button to view DICOM data.
 </ul>
 
 \subsection org_mitk_gui_qt_dicomImport Data import
 \imageMacro{QmitkDicom_ImportDialog.png,"The import dialog checked",9.53}
 There are two diffrent ways to import DICOM data.
 The First one is to directly imort it into your DICOM data storage. To achieve this you should toggle the checkbox 'Copy on import'.
 The second approach is, to have a look at the data first before importing it.
 To do that you simply don't check 'Copy on import'.
 This will leed you to the leed you to the 'External Dicom Data' screen which provides you a preview of the data containing in youre choosen folder.
 You can import the data here by selecting it and pressing the 'Download' button.
 It is also possible to view DICOM series directly in Mitk by selecting it here and pressing the 'View' button.
 <ul>
 <li> Click 'Import Folder' or 'Import CD' button to open the import dialog.</li>
   <ul>
   <li> Enable the 'Copy on import' checkbox and choose a folder to import into data storage directly.</li>
   <li> Disable the 'Copy on import' checkbox to get to the 'External Dicom Data' screen.</li>
       <ul>
       <li> Click on the arrow on the left of your data to expand or hide dicom data levels.
       <li> Click the 'Download' button to download selected DICOM data to your DICOM data storage.
       <li> Click the 'View' button to view DICOM data.
       </ul>
   </ul>
 </ul>
 
 \section org_mitk_gui_qt_dicomQueryRetrieve Query/Retrieve
 \warning This plugin is experimental and not all of the described features behave as expected.
 
 \note The query retrieve plugin only works if the PACS you are calling knows your machine settings.
 There are also issues when you are running a firewall.
 
 The query retrieve workflow allows you to get DICOM data from a server.
 \imageMacro{QmitkDicom_QueryRetrieve.png,"The query retrieve screen",16.00}
 
 \subsection org_mitk_gui_qt_dicomQuery Query
 \imageMacro{QmitkDicom_Nodes.png,"The DICOM network configuration",11.26}
 By performing a DICOM query you will ask a server for it's DICOM data.
 This requires to setup the DICOM network configuration of your system and the server.
 By clicking on 'Add Server' a new plain server field will appear. Now you can give it a name of your choice.
 Fill the servers "DICOM name" the AETitle. Type in it's url, it's port and the specific DICOM protocoll you want to use for image transfer.
 \note I recommend not to use CGET because most of the PACS systems (Image Servers) don't support that protocoll.
 
 You can configure the DICOM network configuration of your machine by editing the 'Calling AETiltle', the 'Storage AETitle' and The 'Storage Port' text fields.
 But normaly you don't have to change your configuration.
 \imageMacro{QmitkDicom_FilterWidget.png,"The DICOM search options",3.66}
 After you have finished your network configuration and before you start the query you should use the 'Search Options' to specify your query.
 Otherwise all data on the server will be queried and you will have to wait for a long time.
 You can specify your query by searching for a specific patient name or a study or a serie or a specific DICOM object by it's id.
 You are allowed to include or exclude DICOM modalities from your query and you can specify a specific time in which the DICOM images you are searching fo might been captured.
 When you finished that you can click the query button and the queried DICOM data will appear.
 <ul>
 <li> Click on the 'Add Server' button.
     <ul>
     <li> Edit 'Name' field.
 	<li> Edit 'AETitle' field.
 	<li> Edit 'Adress' field.
     <li> Edit 'Port' field.
     </ul>
 <li> Set search options.
 <li> Click on 'Query' button.
 </ul>
 \subsection org_mitk_gui_qt_dicomRetrieve Retrieve
 \imageMacro{QmitkDicom_Retrieve.png,"The queried DICOM data.",15.22}
 After the query you are able to select the queried data and click the 'Retrieve' button.
 This will store the queried DICOM data into your DICOM storage.
 Click on the 'Local Storage' button and work with your new data.
 <ul>
 <li> Click on the 'Retrieve' button to retrieve the data to your DICOM storage.
 <li> Click on the 'Local Storage' button.
 </ul>
 */
diff --git a/Plugins/org.mitk.gui.qt.dicombrowser/documentation/UserManual/dicom.svg b/Plugins/org.mitk.gui.qt.dicombrowser/documentation/UserManual/dicombrowser-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.dicombrowser/documentation/UserManual/dicom.svg
rename to Plugins/org.mitk.gui.qt.dicombrowser/documentation/UserManual/dicombrowser-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.dicominspector/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.dicominspector/documentation/UserManual/Manual.dox
index e1305a43b8..9ead1145cb 100644
--- a/Plugins/org.mitk.gui.qt.dicominspector/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.dicominspector/documentation/UserManual/Manual.dox
@@ -1,12 +1,12 @@
 /**
 \page org_mitk_views_dicominspector The DICOM Inspector
 
-\imageMacro{ "inspector.png", "Icon of DICOM Inspector", 2}
+\imageMacro{ "inspector-dox.png", "Icon of DICOM Inspector", 2}
 
 This is a simple view that displays all DICOM properties of the data of the currently selected node.
 DICOM properties are all properties that have a property name starting with "DICOM".
 The plugin will show the dicom values corresponding to the currently selected time point and z slice.
 E.G. the value of "acquesition time" will change with changing the time step of 3d+t image or the value
 of "slice position" will change with changing the current z slice of the image.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.dicominspector/documentation/UserManual/inspector.png b/Plugins/org.mitk.gui.qt.dicominspector/documentation/UserManual/inspector-dox.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.dicominspector/documentation/UserManual/inspector.png
rename to Plugins/org.mitk.gui.qt.dicominspector/documentation/UserManual/inspector-dox.png
diff --git a/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/Manual.dox
deleted file mode 100644
index 1ac1f69e7e..0000000000
--- a/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_mitk_gui_qt_eventrecorder The Event Recorder Plugin
-
-\imageMacro{icon.png,"Icon of Eventrecorder",2.00}
-
-\tableofcontents
-
-\section org_mitk_gui_qt_eventrecorderOverview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/icon.png b/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/icon.png
deleted file mode 100644
index 0747c53912..0000000000
Binary files a/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/icon.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Plugins/org.mitk.gui.qt.eventrecorder/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Plugins/org.mitk.gui.qt.eventrecorder/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.eventrecorder/documentation/doxygen/modules.dox
deleted file mode 100644
index 3e7e44cb3b..0000000000
--- a/Plugins/org.mitk.gui.qt.eventrecorder/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mitk_gui_qt_eventrecorder org.mitk.gui.qt.eventrecorder
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mitk_gui_qt_eventrecorder_internal Internal
-  \ingroup org_mitk_gui_qt_eventrecorder
-
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.eventrecorder plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.ext/documentation/UserManual/MITKUserManual.dox b/Plugins/org.mitk.gui.qt.ext/documentation/UserManual/MITKUserManual.dox
index 4c320da6eb..9918cc73ad 100644
--- a/Plugins/org.mitk.gui.qt.ext/documentation/UserManual/MITKUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.ext/documentation/UserManual/MITKUserManual.dox
@@ -1,111 +1,98 @@
 /**
 \page MITKWorkbenchManualPage The MITK Workbench
 
-Welcome to the basic MITK user manual. This document tries to give a concise overview of the basic functions of MITK and be an comprehensible guide on using them.
+\tableofcontents
 
+Welcome to the basic MITK user manual. This document tries to give a concise overview of the basic functions of MITK and be an comprehensible guide on using them.
 
-<div align="center"><h1>The User Interface </h1></div>
+\section MITKWorkbenchManualPage_UserInterface The User Interface
 
 The layout of the MITK applications is designed to give a clear distinction between the different work areas. The following figure gives an overview of the main sections of the user interface.
 
 \imageMacro{MITKUserManual_GUICommented.png,"The Common MITK Application Graphical User Interface",16.00}
 
-The datamanager and the \ref MITKUserManualPagePerspectives have their own help sections. This document explains the use of:
-  - The \ref Four Window View
-  - The \ref Menu
-  - The \ref MITKUserManualPageLevelWindow
-  - The \ref MITKUserManualPageMemoryUsage
-  - The \ref MITKUserManualPageViews
-
-<div align="center"><h1>Four Window View   </h1></div>
-
-<h2>Overview </h2>
+\section MITKWorkbenchManualPage_FourWindowView Four Window View
 
+\subsection MITKWorkbenchManualPage_FourWindowView_Overview Overview
 
 The four window view is the heart of the MITK image viewing. The standard layout is three 2D windows and one 3D window, with the axial window in the top left quarter, the sagittal window in the top right quarter, the coronal window in the lower left quarter and the 3D window in the lower right quarter. The different planes form a crosshair that can be seen in the 3D window.
 
 Once you select a point within the picture, informations about it are displayed at the bottom of the screen.
 
-<h2>Navigation </h2>
-
+\subsection MITKWorkbenchManualPage_FourWindowView_Navigation Navigation
 
 Left click in any of the 2D windows centers the crosshair on that point. Pressing the right mouse button and moving the mouse <B>zooms</B> in and out. By scrolling with the mouse wheel you can <B>navigate through</B> the slices of the active window and pressing the mouse wheel while moving the mouse <B>pans</B> the image section.
 
 In the 3D window you can <B>rotate</B> the object by pressing the left mouse button and moving the mouse, <B>zoom</B> either with the right mouse button as in 2D or with the mouse wheel, and <B>pan</B> the object by moving the mouse while the mouse wheel is pressed. Placing the cursor within the 3D window and holding the "F" key allows <B>free flight</B> into the 3D view.
 
-<h2>Customizing</h2>
-
+\subsection MITKWorkbenchManualPage_FourWindowView_Customizing Customizing
 
 By moving the cursor to the upper right corner of any window you can activate the window menu. It consists of three buttons.
 
 \imageMacro{MITKUserManual_CrosshairModes.png,"Crosshair",8.72}
 
 The crosshair button allows you toggle the crosshair, reset the view and change the behaviour of the planes.
 
 Activating either of the rotation modes allows you to rotate the planes visible in a 2D window by moving the mouse cursor close to them and click and dragging once it changes to indicate that rotation can be done.
 
 The swivel mode is recommended only for advanced users as the planes can be moved freely by clicking and dragging anywhere within a 2D window.
 
-
 The middle button expands the corresponding window to fullscreen within the four window view.
 
 \imageMacro{MITKUserManual_ViewsChoices.png,"Layout Choices",5.19}
 
 The right button allows you to choose between many different layouts of the four window view to use the one most suited to your task.
 
-<div align="center"><h1>Menu</h1></div>
-
+\section MITKWorkbenchManualPage_Menu Menu
 
-<h2>File</h2>
+\subsection MITKWorkbenchManualPage_Menu_File File
 
 This dialog allows you to save, load and clear entire projects, this includes any nodes in the data manager.
 
-<h2>Edit</h2>
+\subsection MITKWorkbenchManualPage_Menu_Edit Edit
+
 This dialog supports undo and redo operations as well as the image navigator, which gives you sliders to navigate through the data quickly.
 
-<h2>Window</h2>
+\subsection MITKWorkbenchManualPage_Menu_Window Window
 
 This dialog allows you to open a new window, change between perspectives and reset your current one to default settings.
 
-
 If you want to use an operation of a certain perspective within another perspective the "Show View" menu allows to select a specific function that is opened and can be moved within the working areas according to your wishes. Be aware that not every function works with every perspective in a meaningful way.
 
 The Preferences dialog allows you to adjust and save your custom settings.
 
 \imageMacro{MITKUserManual_WindowDropdown.png,"Preferences",4.89}
 
-<h2>Help </h2>
+\subsection MITKWorkbenchManualPage_Menu_Help Help
 
 This dialog contains this help, the welcome screen and information about MITK.
 
-<div align="center"><h1>Levelwindow</h1></div>
+\section MITKWorkbenchManualPage_Levelwindow Levelwindow
 
 Once an image is loaded the levelwindow appears to the right hand side of the four window view. With this tool you can adjust the range of grey values displayed and the gradient between them. Moving the lower boundary up results in any pixels having a value lower than that boundary to be displayed as black. Lowering the upper boundary causes all pixels having a value higher than it to be displayed as white.
 
 The pixels with a value between the lower and upper boundary are displayed in different shades of grey. This way a smaller levelwindow results in higher contrasts while cutting of the information outside its range whereas a larger levelwindow displays more information at the cost of contrast and detail.
 
 You can pick the levelwindow with the mouse to move it up and down, while moving the mouse cursor to the left or right to change its size. Picking one of the boundaries with a left click allows you to change the size symmetrically. Holding CTRL and clicking a boundary adjusts only that value.
 
 With line edit fields below you can directly adjust the levelwindow. The upper field describes the center of the levelwindow, the bottom the span of the window around the center. By selecting one of fields and typing any number you can set these two parameters.
 
-<div align="center"><h1>System Load Indicator</h1></div>
-
+\section MITKWorkbenchManualPage_SystemLoadIndicator System Load Indicator
 
 The System Load Indicator in the lower right hand corner of the screen gives information about the memory currently required by the MITK application. Keep in mind that image processing is a highly memory intensive task and monitor the indicator to avoid your system freezing while constantly swapping to the hard drive.
 
-<div align="center"><h1>Views</h1></div>
+\section MITKWorkbenchManualPage_Views Views
 
 Each solution for a specific problem that is self contained is realized as a single view. Thus you can create a workflow for your problem by combining the capabilities of different views to suit your needs.
 One elegant way to do this is by combining views in perspectives.
 
 By pressing and holding the left mouse button on a views tab you can move it around to suit your needs, even out of the application window.
 
-<div align="center"><h1>Perspectives </h1></div>
+\section MITKWorkbenchManualPage_Perspectives Perspectives
 
 The different tasks that arise in medical imaging need very different approaches. To acknowledge this circumstance MITK supplies a framework that can be build uppon by very different solutions to those tasks. These solutions are called perspectives, each of them works independently of others although they might be used in sequence to achieve the solution of more difficult problems.
 
 It is possible to switch between the perspectives using the "Window"->"Open Perspective" dialog.
 
-
 See menu for more information about switching perspectives.
 */
diff --git a/Plugins/org.mitk.gui.qt.geometrytools/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.geometrytools/documentation/UserManual/Manual.dox
index 66bc02d803..3baf2840a5 100644
--- a/Plugins/org.mitk.gui.qt.geometrytools/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.geometrytools/documentation/UserManual/Manual.dox
@@ -1,18 +1,18 @@
 /**
 \page org_mitk_gui_qt_geometrytools The Geometry Tools
 
-\imageMacro{icon.png,"Icon of Geometry Tools",2.00}
+\imageMacro{geometrytools-dox.xpm,"Icon of Geometry Tools",2.00}
 
 \tableofcontents
 
 \section org_mitk_gui_qt_geometrytoolsOverview Overview
 
 A plugin to modify geometry of mitkBaseData via interaction. Currently, the following
 operations can be performed:
 
 <ul>
 <li>Translation
 <li>Rotation
 <li>Scaling (not supported for images, yet, and will not happen in coordinate origin)
 </ul>
 */
diff --git a/Plugins/org.mitk.gui.qt.geometrytools/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.geometrytools/documentation/UserManual/geometrytools-dox.xpm
similarity index 100%
rename from Plugins/org.mitk.gui.qt.geometrytools/documentation/UserManual/icon.xpm
rename to Plugins/org.mitk.gui.qt.geometrytools/documentation/UserManual/geometrytools-dox.xpm
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/documentation/UserManual/Manual.dox
index 426c619338..f76698f792 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/documentation/UserManual/Manual.dox
@@ -1,18 +1,18 @@
 /**
 \page org_mitk_views_igttrackingsemiautomaticmeasurement The IGT Tracking Semi Automatic Measurement
 
-\imageMacro{icon.png,"Icon of IGT Tracking Semi Automatic Measurement",2.00}
+\imageMacro{hummelprotocolmeasurements-dox.png,"Icon of IGT Tracking Semi Automatic Measurement",2.00}
 
 \tableofcontents
 
 \section Overview
 Dieses PlugIn dient zur semiautomatischen Aufzeichnung von Messreihen mit Trackingsystemen. Entsprechend konfiguriert ist es auch für das Hummel-Protokoll einsetzbar. Zentrale Komponente des PlugIns ist eine IGT Pipeline zur Messdatenaufzeichnung, wie in Abbildung 1 dargestellt.
 
 \imageMacro{pipeline.png,"Icon of IGT Tracking Semi Automatic Measurement",10.00}
 
 Ein Screenshot der Benutzeroberfläche des PlugIns ist in Abbildung 2 zu sehen. Das Initialisieren und Starten des Trackingsystems erfolgt dabei im nicht dargestellten Tab "Tracking Initialization", der im Wesentlichen aus dem TrackingDeviceConfigurationWidget besteht. Zur Durchführung der Messungen unterstützt das PlugIn das Laden einer Liste mit Dateinamen für die Messungen, wie im oberen Teil des Screenshots zu sehen. Diese Liste wird abgearbeitet, wobei mit dem Button "Start Next Measurement" jeweils die nächste Messung gestartet wird. Die während der Messung aufgezeichneten Daten werden in eine Datei das Ausgabeverzeichnis geschrieben. Dabei entspricht der Dateiname dem aktuellen Namen aus der Liste. Die Anzahl der aufzuzeichnenden Messwerte pro Messung kann in den Einstellungen angegeben werden. Gab es bei einer Messung einen Fehler kann die Messung durch Auswahl des entsprechenden Buttons auch wiederholt werden.
 
 \imageMacro{screenshot.png,"Icon of IGT Tracking Semi Automatic Measurement",10.00}
 
 Das PlugIn unterstützt außerdem die Ansteuerung eines zweiten Trackingsystems. Dieses System soll einen am Phantom angebrachtes Tool (Reference Sensor) tracken und so sicherstellen, dass sich das Phantom während der Messung nicht bewegt. Wurde eine Bewegung des Phantoms festgestellt wird im unteren Teil des PlugIns "NOT OK" angezeigt und die Messung muss ggf. wiederholt werden.
 */
diff --git a/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/documentation/UserManual/icon.png b/Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/documentation/UserManual/hummelprotocolmeasurements-dox.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/documentation/UserManual/icon.png
rename to Plugins/org.mitk.gui.qt.igt.app.hummelprotocolmeasurements/documentation/UserManual/hummelprotocolmeasurements-dox.png
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/UserManual/Manual.dox
deleted file mode 100644
index 4e25a77184..0000000000
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-\page org_mitk_gui_qt_igt_app_echotrack The Ultrasound Navigation Plugin
-
-Available sections:
-  - \ref org_mitk_gui_qt_igt_app_echotrackOverview
-
-\section org_mitk_gui_qt_igt_app_echotrackOverview Overview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/UserManual/icon.xpm
deleted file mode 100644
index 83e48be4d8..0000000000
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/doxygen/modules.dox
deleted file mode 100644
index 4dee87289d..0000000000
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mbi_gui_qt_usnavigation org.mbi.gui.qt.usnavigation
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mbi_gui_qt_usnavigation_internal Internal
-  \ingroup org_mbi_gui_qt_usnavigation
-
-  \brief This subcategory includes the internal classes of the org.mbi.gui.qt.usnavigation plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/QmitkIGTTrackingLab.dox b/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/QmitkIGTTrackingLab.dox
index 2c2a1dc362..7f8cfa4031 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/QmitkIGTTrackingLab.dox
+++ b/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/QmitkIGTTrackingLab.dox
@@ -1,68 +1,68 @@
 /**
 \page org_igttrackinglab IGT Tutorial Step 5: The IGT-TrackingLab
 
 Available sections:
   - \ref QmitkIGTTrackingLabUsersManualOverview
   - \ref QmitkIGTTrackingLabUsersManualPrel
   - \ref QmitkIGTTrackingLabUsersManualConf
   - \ref QmitkIGTTrackingLabUsersManualIntialReg
   - \ref QmitkIGTTrackingLabUsersManualPermReg
   - \ref QmitkIGTTrackingLabUsersManualPtSetRec
   - \ref QmitkIGTTrackingLabUsersManualCamView
 
 
 \section QmitkIGTTrackingLabUsersManualOverview Introduction
 
 The IGT-TrackingLab is the last step of the IGT tutorial. In the following you can learn how to use the plugin by reading this manual. IGT-TrackingLab shows example usage for many IGT classes and is also an example navigation implemented with IGT.
 
 The symbol of the Tracking Lab View is the following:
 
-\imageMacro{../../resources/icon_igt_tracking_lab.png,"",2}
+\imageMacro{icon_igt_tracking_lab.png,"",2}
 
 The view looks like this:
 \imageMacro{IGT_TrackingLab_PluginView.png,"",15.90}
 
 With this tutorial you will register a book using a tracking device of your choice and the MITK's book surface file. The registration will enable you to move the book in the real world and observe its movement in the MITK display. It also allows you to record PointSets or use the CameraView which simulates a Camera at the tip of your pointer.
 
 \section QmitkIGTTrackingLabUsersManualPrel Preliminaries
 First connect your tracking device to your PC. Then start the MITK Workbench and configure your tracking device using the \ref org_mitk_views_igttrackingtoolbox "Tracking Toolbox View".
 
 
 \section QmitkIGTTrackingLabUsersManualConf Configuration
 Select the desired <i>Navigation Data Source</i>. Now it's time to define which tool shall be used as object marker and which tool shall be used as pointer. Next load the Book surface
 provided with the example data (e.g. book.stl from the MITK-Data repository which comes with every superbuild or may also be checked out separately) into MITK. Fixate the object marker on a real book of your choice. Now we need to tell MITK that the object marker has been fixated on a physical object. To do this, select the <i>Book</i> as surface in the <i>Object Selection</i> submenu as you can see in the screenshot above.
 
 \section QmitkIGTTrackingLabUsersManualIntialReg Initial Registration
 Now we need to register the object marker to the surface it's fixed upon, in our case the book. To do this, first press the initial registration button. For MITK to be able to do this registration, we need to
 1. Select landmarks on the virtual object (e.g. the corners of the book)
 Press the <i>plus</i> button in the <i>Image fiducials</i> column. Shift + click on the corners on the book in the <i>MITK Display</i>.
 2. Point to the corresponding landmarks in the real world using the pointer.
 Now press the <i>plus</i> button in the <i>Real world fiducials</i> column and point to the corners on the real book. Press <i>Add current instrument position</i> whenever you targeted a corner to tell MITK this is the desired landmark. Make sure you select the "real" edges in the same order as the edges in the image.
-\imageMacro{IGT_TrackingLab_InitialRegistration.png,"Here the landmarks of the virtual object are already set",15.90}
+\imageMacro{IGT_TrackingLab_InitialRegistration.PNG,"Here the landmarks of the virtual object are already set",15.90}
 
 Press <i>Register</i> to finalize the initial registration.
 Now the object marker is registered onto the book. You can see this in the MITK image. If needed the FRE is shown in the widget.
 
 \section QmitkIGTTrackingLabUsersManualPermReg Permanent Registration
 Now everything is set up and registered. We can thus activate permanent registration to continuously track the object, the object marker and the pointer.
 
 For this, simply press the <i>Permanent Registration</i> button and select <i>Activate permanent registration</i>. You can now move the book in the real world and see the same movement in the <i>MITK Display</i>. A nice test to see if everything was correctly registered is to target the corners of the book with the pointer and check if the correct corners are pointed to in the <i>MITK Display</i>.
 
 \section QmitkIGTTrackingLabUsersManualPtSetRec PointSet Recording
 A user might now want to track a tool's trajectory. For this, the <i>PointSet Recording</i> was created.
 
 First click on <i>PointSet Recording</i>. Now select your tracking source and the tool whose trajectory shall be recorded. Activate the <i>Point Set Recording</i> checkbox. In the <i>MITK Display</i> little green points will now be drawn for every measured position. Deactivate the checkbox to stop recording. The trajectory is saved in the PointSet <i>Recorded Points</i> visible in the Data Manager.
 
 \section QmitkIGTTrackingLabUsersManualCamView Camera View
 Another possible tracking application is the Camera View. Here, a virtual camera is placed at the pointers tip and its images are shown in the MITK Display.
 
 Select Camera View and as usual the Tracking Source and the tool you want to place the virtual camera on. Activate the "Activate Needle View" checkbox and move the pointer around the book. You can now see the book from the pointers perspective.
 
 You may need to adjust the Needle View Direction and the View Up Vector. This is always relative to your tools coordinate center origin. An example of the NDI pointer tool coordinate system is shown below:
 
 \imageMacro{QmitkIGTExamples_Tool.png,"The coordinate system of the NDI pointing tool",16.00}
 
 In the above case, the camera should look in inverse z-direction, and the view up vector should probably be set to positive x. Note this is just an example and may be different depending on your pointer.
 
-\ref Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
+Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/QmitkIGTTutorial.dox b/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/QmitkIGTTutorial.dox
index d6f0f59d15..a4e65c05b9 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/QmitkIGTTutorial.dox
+++ b/Plugins/org.mitk.gui.qt.igtexamples/documentation/UserManual/QmitkIGTTutorial.dox
@@ -1,94 +1,94 @@
 /**
 \page org_imageguidedtherapytutorial The MITK-IGT Tutorial View
 
 This view is not meant as an end-user module. It contains tutorial program code that explains how to use the MITK-IGT component.
 
 It contains only two buttons. The "Start image guided therapy" button will create a virtual tracking device and a virtual tool.
 It will move the tool around on random paths in a tracking volume of 200x200x200 mm. The tool is visualized with a cone.
 If you do not see a cone moving around, you will need to initialize the rendering views correctly. Use the DataManager view to perform
 a global reinit.
 
 The symbol of this view is the following:
 
-\imageMacro{../../resources/icon_igt_simple_example.png,"",2}
+\imageMacro{icon_igt_simple_example.png,"",2}
 
 and the whole view looks like this:
 
 \imageMacro{IGTExampleIGT_QT_Tutorial_PluginView.png,"",2}
 
 In this tutorial we connect to the NDI Polaris tracking system (or alternatively use a virtual tracking device) and we will show the movement of a tool as cone in the StdMultiWidget editor.
 
 First of all, you will have to add an IGT dependency to your cmake list. For this example, MitkIGTUI would be sufficient, but as the plugin contains several views, we have additional OpenIGTLink and US dependencies:
 
 \code{.cpp}
 
     project(org_mitk_gui_qt_igtexamples)
 
     mitk_create_plugin(
         EXPORT_DIRECTIVE IGTEXAMPLES_EXPORT
         EXPORTED_INCLUDE_SUFFIXES src
         MODULE_DEPENDS MitkQtWidgetsExt MitkIGT MitkIGTUI MitkOpenIGTLink MitkOpenIGTLinkUI MitkUS
     )
 \endcode
 
 More information on how to create your own plugin can be found here: \ref NewPluginPage
 
 When clicking the start button, a cone should move in the 3D view and stop after clicking the stop button.
 
 The view has several fuctions. Most of them deal with the basic functionality with the plugin (e.g. CreateQTPartControl or CreateConnections). For a deeper understanding, you might have a look at the files QmitkIGTTutorialView.cpp and QmitkIGTTutorialView.h
 For our IGT functionality, the following functions are important:
 \li OnStartIGT: Starts the navigation pipeline
 \li OnStopIGT: Disconnect the pipeline
 \li OnTimer: Updates the view
 
 Let's now have a deeper look at these functions.
 
 \section OnStartIGT OnStartIGT
 
-\snippet ../../src/internal/QmitkIGTTutorialView.cpp OnStart 1
+\snippet QmitkIGTTutorialView.cpp OnStart 1
 
 We first check in a try environment, if we should use an NDI tracking device or a virtual device. Let's start with NDI, we hardcode the parameters here and give out a warning. In your propper application, the parameters should be set via the gui aswell (see \ref org_mitk_views_igttrackingtoolbox ), but for simplicity, we just set hardcoded parameters here. If you want to try it with your own NDI device, you need to adapt these parameters here in the code:
 
-\snippet ../../src/internal/QmitkIGTTutorialView.cpp OnStart 2
+\snippet QmitkIGTTutorialView.cpp OnStart 2
 
 The tracking device has to be set to a source. For more information on the tracking pipeline, please have a look at the \ref IGTTutorialStepFilterPipeline.
 
 \snippet QmitkIGTTutorialView.cpp OnStart 3
 
 Alternatively, we can setup a virtual tracking device. We create this device, set the bounds, add a tool and connect it to the source:
 
 \snippet QmitkIGTTutorialView.cpp OnStart 4
 
 Now we need to connect the tracking system
 
 \snippet QmitkIGTTutorialView.cpp OnStart 5
 
 For the visualisation, we need an object. Here, we create a red cone
 
 \snippet QmitkIGTTutorialView.cpp OnStart 6
 
 The visualization filter will actually render the cone
 \snippet QmitkIGTTutorialView.cpp OnStart 7
 
 For a continuous display, we need to call update, here we decide to do it every 100 ms using a timer.
 \snippet QmitkIGTTutorialView.cpp OnStart 8
 
 Disable the selection of tracking devices during tracking:
 \snippet QmitkIGTTutorialView.cpp OnStart 8a
 
 For propper coding, you should always catch the exceptions:
 \snippet QmitkIGTTutorialView.cpp OnStart 9
 
 \section OnTimer OnTimer
 
 Each time, the timer is updated, the following code is executed:
 \snippet QmitkIGTTutorialView.cpp OnTimer
 
 \section OnStopIGT OnStopIGT
 This function will stop the pipeline and clean up everything:
 \snippet QmitkIGTTutorialView.cpp OnStop
 
-You now have a very simple plugin, which creates an own tracking device and starts or stops tracking. Of course, for your more advanced project, you could implement a new tracking device to be available in every plugin (see \ref IGTHowToImplementATrackingDevice) or use already implemented tracking devices via the tracking toolbox and/or microservices. This small example should just show you the most simple way to start tracking.
+You now have a very simple plugin, which creates an own tracking device and starts or stops tracking. Of course, for your more advanced project, you could implement a new tracking device to be available in every plugin (see \ref IGTHowToImplementATrackingDevice ) or use already implemented tracking devices via the tracking toolbox and/or microservices. This small example should just show you the most simple way to start tracking.
 
-\ref Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
+Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkIGTTracking.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkIGTTracking.dox
index e94957da24..c31bc51829 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkIGTTracking.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkIGTTracking.dox
@@ -1,20 +1,20 @@
 /**
 \page org_mitk_gui_qt_igttracking The IGT Tracking Plugin
 
 This plugin offers basic tracking functionalities. This includes connecting to a tracking system, logging and recording of tracking data, managing tracking tools and playing recorded tracking data.
 
 The plugin includes different views, which are described on different pages in detail.
 
 As part of the tutorial, it is recommended to get familiar with each of the following views as they lead you through the main functionality of the IGT plugin. Please read the following pages to get familiar with them:
 
 <ul>
 <li> \subpage org_mitk_views_igttrackingtoolbox : Allows for connecting a tracking system and logging/recording the tracked data.
 <li> \subpage org_mitk_views_igtnavigationtoolmanager : This view offers functionality to manage tool storages. Each tool storage holds a preconfigured tool collection. Once saved you can load a tool storage in the Tracking Toolbox and don't need to add every tool seperately.
 <li> \subpage org_mitk_views_navigationdataplayer : Plays navigation data which was recorded with the Tracking Toolbox for example.
 <li> \subpage org_mitk_views_calibrationtoolmanager Calibration Tool Manager. This view offers functionality to calibrate navigation tools.
 <li> \subpage org_mitk_views_igtregistrationview : The IGTFiducialRegistration view allows the recording of real world landmarks and corresponding landmarks on a virtual object.
 </ul>
 
-\ref Return to the \ref TrackingPlugins "[IGT Tutorial Overview]"
+Return to the \ref TrackingPlugins "[IGT Tutorial Overview]"
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolCalibration.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolCalibration.dox
index cce10b3e82..079e6d0673 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolCalibration.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolCalibration.dox
@@ -1,85 +1,85 @@
 /**
 
 \page org_mitk_views_calibrationtoolmanager The MITK-IGT Navigation Tool Calibration
 
-\imageMacro{../resources/iconTrackingToolCalibration.png,"Icon of the MITK-IGT Tracking Toolbox",2.00}
+\imageMacro{iconTrackingToolCalibration.png,"Icon of the MITK-IGT Tracking Toolbox",2.00}
 
 \tableofcontents
 
 \section QmitkMITKIGTNavigationToolCalibrationIntroduction Introduction
 This view allows the calibration of navigation tools. The calibrated tools can be saved permanently and later be used for any other IGT application. The following coordinate transforms are associated with tracking of a tool:
  <ul>
  <li> The sensor transformation from the global tracking coordinate system to the local coordinate system of the tracked sensor (m_Position, m_Orientation).
  <li> The tool tip transformation from the local sensor coordinate system to a tool tip coordinate system defined by a tool tip position and a main tool axis (m_ToolTipPosition, m_ToolAxisOrientation). The tool axis is defined as the negative z-axis of the tool tip coordinate system.
  <li> The main axis of the representation object of the tool (e.g. a surface) has to be defined along the negative z-axis.
  </ul>
 \imageMacro{TrackingTool.png,"Coordinate transforms associated to the tracking tool.",5.00}
 
 
 \section QmitkMITKIGTNavigationToolCalibrationPrerequisities Prerequisites
 
 In the IGT Tracking Toolbox configure your tracking device with at least two tools. The tool you wish to calibrate and one tool used as a pointer during the calibration process. For details on how to configure your tracking device and your tools have a look at \ref org_mitk_views_igttrackingtoolbox .
 After you configured your device and your tools connect your device and start tracking. Now switch to the IGT Navigation Tool Calibration for the calibration process.
 
 
 \section QmitkMITKIGTNavigationToolCalibrationInitialization Initialization
 
 On the tab Initialization choose the tracking device you configured in the prevois step by clicking on it in the box "Available Navigation Data Sources". Then in the box "Tools" the tools you configured for this device should appear. Click on the tool that needs to be calibrated and then on the button "Use as Tool to Calibrate". On top of the view under the headline "Tool To calibrate" you now see the tool information for the chosen tool.
 For the tool used as a pointer do the same. Click on it, then click on the button "Use as Calibration Pointer" and on top of the view under the headline "Calibration pointer you should see the tool information for the pointer tool.
 
 \imageMacro{QmitkIGTTracking_ToolCalibration_Initialization.png,"MITK Screenshot with the initialized tools for calibration",5.00}
 
 
 \section QmitkMITKIGTNavigationToolCalibrationToolTipCalibration Tool Tip Calibration
 
 After you finished the initialization of your tracking device you can proceed on to the tab Tool Tip Calibration to calibrate your tool.
 For the Tool Tip Calibration you have four different options:
 
 <ul>
 <li> Manual: Enter the known Translation and Rotation for the Tool Tip manually
 <li> Single Reference Tool: Use a calibrated tool as a reference to calibrate the non-calibrated tool
 <li> Multiple Tools Reference: Not implemented yet
 <li> Pivoting: Calibrate the tool by pivoting it around its tip. (Not fully implemented yet)
 </ul>
 
 \subsection QmitkMITKIGTNavigationToolCalibrationManual Manual Tool Tip Calibration
 
 Use this method to calibrate a navigation tool, of which you already know the translation and rotation that determine the tool tip calibration.
 Click on Start Edit Tooltip and in the new window you can enter the values for the translation and the rotation. Either by using the sliders or by entering the values into the boxes.
 \imageMacro{QmitkIGTTracking_ToolCalibration_Manual_EditingWindow.png,"MITK Screenshot of the window for manual tool calibration",5.00}
 After you entered the values you can click "Use Manipulated ToolTip" to perform the Calibration on the Tool to calibrate. The box "Current Tool Tip Orientation" will show you the results. It will list the resulting values of the Quaternion, the Euler Angles and the Matrix.
 \imageMacro{QmitkIGTTracking_ToolCalibration_Manual_After.png,"MITK Screenshot of the Current Tool Tip Orientation Box after the tool was manually calibrated",5.00}
 To save the result permanently just click "Save Calibrated Navigation Tool" and you can save the calibrated tool as an IGTTool for later use with your tracking device in a navigation application.
 If you are not satisfied with the results you can click "Start Edit Tooltip" again and either change the values for the rotation and translation again or just reset everything by clicking on "Reset to Identity". To write the new values or reseted values into the tool just click "Use Manipulated Tool Tip" again. Now you can save your relust just as described above.
 
 \subsection QmitkMITKIGTNavigationToolCalibrationReference Tool Tip Calibration with a single Reference Tool
 
 Use this method to calibrate a navigation tool using a tool as pointer that is already calibrated.
 First choose the number of tracking data you wish to collect. It is 100 by default but you may choose as many as you wish. Now place your tool to calibrate in a fixed position where it is tracked. Next place your pointing tool in a manner that its tip touches the tip and is tracked too. Fix it in this position. For a good calibration it is important that the tools move the least possible.
 After you placed the tools click on the "Collect Navigation Data" Button and wait until all the data is gathered. Now you have several options to adjust the calibration to your needs. You can calibrate the position and/or the orientation or even invert the calibration transform. Calibrating the position will translate the position of the tool to calibrate to the position of the calibration pointer. The orientation calibration will copy the mean orientation of the calibration pointer to the tool the calibrate. Choose the options needed for your tool and tracker and then click on "Run Calibration".
 The new Tool Tip Position and Orientation will be displayed und you can now apply them onto your tool by clicking on "Set New Tool Tip Position and/or Tool Orientation". To finally save the calibrated tool for later use just click on "Save Calibrated Navigation Tool".
 If you are not satisfied with the result of the calibration just repeat the steps described above.
 
 \imageMacro{QmitkIGTTracking_ToolCalibration_Reference.png,"MITK Screenshot of the Tool Tip Calibration Widget after a fully performed Tool Calibration using a single reference tool ",5.00}
 
 \subsection QmitkMITKIGTNavigationToolCalibrationPivot Tool Tip Calibration via Pivoting
 
 To calibrate your tool via pivoting place it on its tip an pivot it around its tip. Be careful not to move the tip otherwise the calibration result will be inaccurate. You can define the number of poses that should be collected. After starting the collecting process pivote the tool to different poses until the collection ends. Then click on "Comute Pivot Point" to compute the pivot point. Finally you can use the pivot result as tooltip transformation and save the calibrated tool to the hard disc for later use.
 
 \subsection QmitkMITKIGTNavigationToolCalibration Tool Landmark Calibration
 
 Two types of landmarks can be defined for each tool:
 <ul>
 <li> Control points for a later point-based registration
 <li> Tool landmarks that represents features on the tool which are e.g. visible in a CT image
 </ul>
 
 Both sets of landmarks are defined in the tool coordinate space.
 
 Control points are virtual and can only defined manually. These landmarks clearly define the tools pose only by using landmarks in the tool coordinate system. E.g., two landmarks for a 5DoF tool and three landmarks for a 6DoF tool. They may be used, e.g., for a point based registration of a tool from image space to tracking space. A typical set of three control points for a 6 DoF tool might be [1;0;0], [0;1;0], [0;0;1].
 
 Tool landmarks are designed for representing defined landmarks on a tool. The number of these landmarks might exeed the number of control points for reasons of redundancy and averaging. They are used for, e.g., manually registering the pose of a tool by visual markers in a CT scan. If you would use these landmarks to do a point based registration from image space to tracking space later, you might overweight the tool because of two many landmarks compared to other markers. The tool landmarks can be calibrated manually or by using a second tracked pointer, move it to each landmark and press "Add Pointer Position".
 
 Return to the overview of the IGT Tracking Plugin views: \ref org_mitk_gui_qt_igttracking
 
 */
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
index 2f3d166f44..dfff505877 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTNavigationToolManager.dox
@@ -1,53 +1,53 @@
 /**
 
 \page org_mitk_views_igtnavigationtoolmanager The MITK-IGT Navigation Tool Manager
 
-\imageMacro{../resources/iconTrackingToolManager.png,"Icon of the Navigation Tool Manager",2.00}
+\imageMacro{iconTrackingToolManager.png,"Icon of the Navigation Tool Manager",2.00}
 
 \section QmitkMITKIGTNavigationToolManager Introduction
 
 This view allows for creating and editing NavigationToolStorages. These storages contains naviagtion tools of a tracking device, can be saved permanently and used later for any other IGT application.
 
 \tableofcontents
 
 \section QmitkMITKIGTNavigationToolManagerToolOverview Navigation Tools Overview
 
 A navigation tool of MITK-IGT represents a tracking tool (e.g. an emt sensor or an optically tracked tool) and it's corresponding data, like it's name and it's surface. A navigation tool is a generalized container for any trackable object in combination with it's additional information. Every navigation tool has different properties which are:
 
 <ul>
 <li> Name
 <li> Unique identifier
 <li> Tool definition file
 <li> Serial number
 <li> Surface for visualization
 <li> Type of tracking device
 <li> Type of the tool
 <li> Tool landmarks
 </ul>
 
 Note that not all properties are needed for all types of tools. A tool definition file, for example, is only needed by optical tracking tools (e.g. a .rom file for Polaris or a toolfile for the MicronTracker). A tool associated with the aurora system is alwalys identified by it's serial number. You can also detect Aurora tools automatically with the TrackingToolbox view and edit the automatically detected tool storage later with this view.
 
 \section QmitkMITKIGTNavigationToolManagerManagingNavigationToolStorage Managing Navigation Tool Storage
 
 In order to create edit a tool storage container, you can select one of the available tool storages listed in the upper part of the UI. The list shows all tool storages which are available throug the micro services concept of MITK. The list also shows the current tool storage of the IGT tracking toolbox view if it is active. In addition to the listed tool storages, you can load new storages from the hard disc which will then appear in the list and might be edited as all other storage by simply selecting it in the list. You may also save a selected tool storage to the hard disc or create a new one.
 
 In the lower part of the UI you always see the list of tools of the tool storage which is currently selected in the upper part. Use the buttons "add", "edit" and "delete" to manage the contained navigation tools. If you click "edit" or "delete" the operation is applied on the currently selected tool, as shown in the screenshot below.
 
 \imageMacro{QmitkIGTTracking_NavigationToolManagemantStartScreen.png,"Screenshot of the main view of NavigationToolManagent",10.90}
 
 \section QmitkMITKIGTNavigationToolManagerAddingEditingNavigationTools Adding / Editing Navigation Tools
 
 If you add or edit a navigation tool, an input mask, as shown in the screenshot below, appears. The tool identifier is filled automatically, if you change it, remember that it is unique in the current storage. Also, choose a valid surface for every tool, this is nessesary for correct tool visualization. By default, a cone is displayed. The other information depends on the tracking system type, e.g. choose a tool file for the Polaris or the MicronTracker system and type in a serial number for the Aurora system. Two identical tools with the same serial number are also possible, they are assigned by the order in which they are attached to the device. As long as they also have the same surface as representation, this should not be a problem for most of the use cases.
 
 The tool type is additional information which is not needed by the tracking device but might be needed by further IGT applications. The same applies to the tool landmarks which might be defined for a tool. There are two different types of landmarks which are designed as described here:
 
 <ul>
 <li> Tool Calibration Landmarks: These landmarks may be used clearly define the tools pose only by  using landmarks in the tool coordinate system. E.g., two landmarks for a 5DoF tool and three landmarks for a 6DoF tool. These landmarks may be used, e.g., for a point based registration of a tool from image space to tracking space.
 <li> Tool Registration Landmarks: These landmarks are designed for representing defined landmarks on a tools surface. The number of these landmarks might exeed the number of tool calibration landmarks for reasons of redundancy and averaging. They are used for, e.g., manually registering the pose of a tool by visual markers in a CT scan. If you would use these landmarks to do a point based registration from image space to tracking space later, you might overweight the tool because of two many landmarks compared to other markers.
 </ul>
 
 \imageMacro{QmitkIGTTracking_NavigationToolManagementAddTool.png,"Screenshot of add/edit navigation tool screen",9.19}
 
 Return to the overview of the IGT Tracking Plugin views: \ref org_mitk_gui_qt_igttracking
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
index 45b0d224b2..af0a780b45 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkMITKIGTTrackingToolbox.dox
@@ -1,93 +1,93 @@
 /**
 
 \page org_mitk_views_igttrackingtoolbox The MITK-IGT Tracking Toolbox
 
-\imageMacro{../resources/iconTrackingToolbox.png,"Icon of the MITK-IGT Tracking Toolbox",2.00}
+\imageMacro{iconTrackingToolbox.png,"Icon of the MITK-IGT Tracking Toolbox",2.00}
 
 \tableofcontents
 
 \section QmitkMITKIGTTrackingToolboxIntroduction Introduction
 
 The MITK-IGT Tracking Toolbox is a view which allows you to connect to a tracking device, track and visualize navigation tools and write the tracked data into a log file.
 This page gives an overview of the view and is at the same time part of the IGT tutorial step \ref org_mitk_gui_qt_igttracking. All parts containing instructions
 for the tutorial begin with the bold printed label <b>Tutorial</b>.
 
 \imageMacro{QmitkIGTTracking_ScreenshotMitk.png,"MITK Screenshot with the TrackingToolbox activated",16.00}
 
 \section QmitkMITKIGTTrackingToolboxWorkflow General workflow Introduction
 
 Currently the devices Polaris, Aurora (both Northern Digital Inc. (NDI); Waterloo, Ontario, Canada), MicronTracker (Claron Technology, Inc.; Toronto, Ontario, Canada) and Optitrack (NaturalPoint) are supported (see <a href="http://mitk.org/wiki/Mitk-Tracking-Device_Support_Levels"> Hardware Tracking Device Support</a>). Different tracking hardware can be used via OpenIGTLink connections (see \ref IGTTutorialStepOpenIGTLink "Open IGT Link tutorial"
 ). For this Tracking Toolbox tutorial, we will use a virtual tracking device, which allows you to use simulated tracking data. This is very helpful if you want to test or implement some tracking application and don't have the hardware always available.
 
 A general Workflow with the Tracking Toolbox may be:
 
 <ul>
 <li> Configuration of a tracking device
 <li> Adding or loading a toolfile which holds tool definitions
 <li> Start tracking
 <li> Logging tracked data
 </ul>
 
 <b>Tutorial:</b> In the following sections, we will get familiar with each of these points using the Virtual Tracking Device.
 
 \section QmitkMITKIGTTrackingToolboxConnecting Tracking Device Configuration
 
 The tracking device can be specified in the tracking device configuration section located in the upper area of the tracking tab. As shown in the screenshot below, you choose your tracking device in the drop down menu.
 
 If you use a real tracking system, you might need to set some parameters like the serial port for Aurora or Polaris or the host name for your OpenIGTLink connection. Most implemented tracking device include an option to test your conection. Therefore you just need to press the button "test connection". The results are displayed in the small black box on the right.
 
 <b>Tutorial:</b> For a first introduction, please select the virtual tracking device in the drop-down-menu. You should see an option to add some jittering to the simulated data.
 
 \imageMacro{QmitkIGTTracking_ConfigurationWidget.png,"Tracking Device Configuration",8.55}
 
 \section Tracking Tools
 
 For tracking, you need information about your tools. You can either add single tools, load previously created tool storages or for some devices auto-detect all available tools. The best way to edit tools after creation/loading is \ref org_mitk_views_igtnavigationtoolmanager view. Creation of new tools or loading of existing tool storages can be done within the Tracking Tool Widget.
 
 \imageMacro{QmitkIGTTracking_NavigationToolManagement_TrackingTools.png, "The tracking tool widget for adding or loading tools.",9.00}
 
 All added or loaded tools will then be displayed in grey as shown in the screenshot below. If you start tracking they will become green if the tools were found and red if they were not found inside the tracking volume.
 \imageMacro{QmitkIGTTracking_TrackingToolsWidget.png,"Added Tracking Tools",9.08}
 
 \subsection QmitkMITKIGTTrackingToolboxAddingTools Adding tools
 The most simple step to begin with is to add new tools with this widget. The same widget is also available within \ref org_mitk_views_igtnavigationtoolmanager view and the single parameters are explained there in more detail.
 \imageMacro{QmitkIGTTracking_NavigationToolManagementAddTool.png,"Adding a new tool", 9.00}
 
 <b>Tutorial:</b> Please click the "Add single tool" button and make sure, that the Virtual Tracker is selected in the drop-down-menu (the tracking device configured in the first step must always match your tools!). You might want to give your tool a new name in the "Basic Information" section and load a surface for visualization in the "Tool Visualization" section (a surface file can be found in your binary folder if you did compile MITK by yourself: MITK-superbuild\MITK-Data\IGT-Data\ClaronTool.stl). If you don't have any surface data, you can just select "use simple cone". Click on "Finished" and repeat this step to add a second tool.
 
 \subsection QmitkMITKIGTTrackingToolboxLoadingTools Loading tools
 To load tools which can be tracked you need a predefined tracking tool storage. You can use the MITK \ref org_mitk_views_igtnavigationtoolmanager view to define a navigation tool storage or to save the tools created within the last step in a toolstorage.
 
 Navigation tool storages can be loaded by pressing the button "Load Tools". Please ensure that the tracking device type of the tools matches the chosen tracking device, otherwise you will get an error message if you try to start tracking.
 
 \subsection QmitkMITKIGTTrackingToolboxAutoDetection Auto detection of tools (only Aurora)
 If you use the Aurora system you also have the possibility to automatically detect the connected tools. In this case a tracking tool storage is created by the software.
 In the Tracking Device Configuration widget, a button "Auto Detection" appears. If you press this button the software connects to the system and automatically detects all connected tools. You will then be asked whether you want to save the detected tools as a tool storage to the hard drive. You might want to do this if you want to use or modify this tool storage later. In the automatically detected tool storage the tools are named AutoDetectedTools1, AutoDetectedTools2, and so on. Small spheres are used as tool surfaces. After autodetection the detected tools are loaded automatically even if you did not save them.
 
 \section QmitkMITKIGTTrackingToolboxStartTracking Start/stop tracking
 To start tracking, you first need to connect to your tracking device ("connect" button). If your tools or tool storage don't match the tracking device or if no connection can be established, this might give an error message here.
 \imageMacro{QmitkIGTTracking_TrackingControl.png,"Tracking Control to start tracking.", 9.00}
 If connected succesfully, the start tracking button is enabled. As soon as you clicked this button, the tool information and tools will be highlighted red or green (un-/successful tracking) and in case of successful tracking, it's position will be updated and the tools are visualized in the 3D view of MITK.
 Note that options may not be changed after connecting the tracking device.
 
 You can start, freeze, unfreeze and stop the tracking as long as you are connected. If you want to finish your tracking, please stop an disconnect your tracking device.
 
 <b>Tutorial:</b> Please click "connect" and "start tracking". Both tools should move within the tracking volume, the position data should be updated in the tool widget and be highlighted green. You can freeze, unfreeze and stop/restart the tracking as often as you like. When finished, please stop and disconnect.
 
 \section QmitkMITKIGTTrackingOptions Options
 
 In the options tab you can enable or disable the visualization of the tracking volume and of the tool quaternions. If enabled, the tool quaternions are shown in the tool information. You can also define the update rate of the tracking data. The update rate should not be set higher than the update rate of the tracking system. Other options might be available here depending on the newest developement within MITK-IGT.
 \imageMacro{QmitkIGTTracking_Options.png,"Recorded logging data.", 9.00}
 
 \section QmitkMITKIGTTrackingToolboxLogging Logging features
 The logging feature of the Tracking Toolbox supports logging in XML or CSV format.
 If your device is tracking, you are able to log the tracking data by using the logging tab. You first must define a file name. You can then choose whether you want comma seperated (csv) or xml format. Press "Start Logging" to start logging. You can also limit the number of logged frames, which will cause the logging to stop automatically after the given number.
 
 \imageMacro{QmitkIGTTracking_LoggingWidget.png,"Tracking options.", 9.00}
 
 <b>Tutorial:</b> Please connect and start tracking as you already did in the last step, switch to the logging tab, specify a csv file and start logging for a view seconds. Stop the tracking after a short period of time. You should now find the specified file which should look similar to the following screenshot and contain position data for both tools:
 \imageMacro{QmitkIGTTracking_LogFile.png,"Recorded logging data.", 9.00}
 
 Return to the overview of the IGT Tracking Plugin views: \ref org_mitk_gui_qt_igttracking
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkNavigationDataPlayer.dox b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkNavigationDataPlayer.dox
index 24acaf66d1..89ef20256f 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkNavigationDataPlayer.dox
+++ b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/QmitkNavigationDataPlayer.dox
@@ -1,29 +1,29 @@
 /**
 \page org_mitk_views_navigationdataplayer The NavigationData Player
 
-\imageMacro{../resources/iconTrackingDataPlayer.png,"Icon of the NavigationData Player",2.00}
+\imageMacro{iconTrackingDataPlayer.png,"Icon of the NavigationData Player",2.00}
 
 \tableofcontents
 
 \section NavigationDataPlayerOverview
 The navigation data player plays recorded or artificial navigation data of one ore more tracking tools and visualizes their trajectory.
 It can also make the data available als a NavigationDataSource to Plugins that require a stream of tracking data, without having to create a tracking device.
 
 \imageMacro{QmitkIGTTracking_NavigationDataPlayer.png, "The Navigation Data Player", 7}
 
 To use it, select a set of recorded navigation data using the "Open File" button.
 The Player will show the number of tools and the number of frames in the file.
 Select the sequential player if you want to play the data with a specified tempo (set the update Interval accordingly).
 Use the Time-based player to play the data in the speed they were originally acquired in.
 
 <ul>
 <li>Check "Repeat" to repeat the data as a loop indefinitely.
 <li>Check "Register as Microservice" to make the data available as a microservice TrackingDataSource. Other Filters can then be connected to it from other plugins. This is useful for development purposes or to replay previously recorded Situations.
 <li> Check "Display" to render the data in the render Window.
 </ul>
 
 <b>Tutorial:</b> As part of the IGT tutorial, you might try to replay your recorded data from step \ref org_mitk_views_igttrackingtoolbox. You should see two spheric tools moving within the tracking volume. Note that the tool storage is not included in the navigation data player at the moment, and hence all tools are represented as spheres.
 
 Return to the overview of the IGT Tracking Plugin views: \ref org_mitk_gui_qt_igttracking
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/TrackingTool.png b/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/TrackingTool.png
deleted file mode 100644
index 0d9066df41..0000000000
Binary files a/Plugins/org.mitk.gui.qt.igttracking/documentation/UserManual/TrackingTool.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropper.dox b/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropper.dox
index ef2b68b13d..91a2f08bc4 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropper.dox
+++ b/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/QmitkImageCropper.dox
@@ -1,52 +1,52 @@
 /**
 \page org_mitk_views_imagecropper The Image Cropper
 
-\imageMacro{crop.svg,"Icon of the Image Cropper Plugin.",20}
+\imageMacro{imagecropper-dox.svg,"Icon of the Image Cropper Plugin.",20}
 
 \section org_mitk_views_imagecropperUsage Usage
 
 The Image Cropper Plugin allows to crop and mask subvolumes out of the original image volume by defining a cubic bounding shape.
 
 \imageMacro{BoundingBox_ImageCropperView.png,"Bounding Shape.",12.00}
 
 A new bounding shape can be created by selecting an image and pressing the 'New' button. The bounding shape appears as a child node in the data manager. Alternatively, an existing bounding shape can be selected.
 
 \imageMacro{Basic_ImageCropperView.png,"Basic Settings.",7.09}
 
 This bounding shape can be placed at an arbitrary position in the volume and can be easily adjusted by using the handles on each of the faces. When activated, the handles are shown in red, otherwise, they are colored white. Hovering over either the shape or a single handle allows modifying the bounding shape. Moving the handles changes the respective extent of the bounding shape, whereas moving the shape itself changes its position.
 
 
 As soon as the bounding shape is placed at the desired position, pressing the button 'Crop' creates a new image assigned to the original image as a child node containing only the selected subvolume. The size of the subvolume equals the size of the bounding shape.  
 Pressing the 'Mask' button keeps the original image size but masks out the area not contained within the bounding shape bounds.
 In the case of 3D+t images, the whole time series is cropped by default.
 
 
 \section org_mitk_views_imagecropperAdvanced Advanced settings
 
 In the advanced settings view you find additional features:
 \imageMacro{Advanced_ImageCropperView.png,"Advanced Settings.",7.09}
 
 \subsection org_mitk_views_imagecropperMaskOutsidePixel Mask with outside pixel
 
 Assigns the value of the voxels outside of the bounding shape when 'Mask' is used.
 
 
 \subsection org_mitk_views_imagecropperAdvancedOverwrite Overwrite original image
 
 By enabling this checkbox the image is replaced by the cropped subvolume. Be careful to use this option since there is no undo action available.
 
 \subsection org_mitk_views_imagecropperAdvancedTimestep Crop current time step only
 
 If you have an xD + t image, the whole time series (all timesteps) is cropped by default. In this case, the 'time geometry' of the current time step is used.
 
 If the checkbox 'Only crop current time step' is ticked, the xD + t image is reduced to an xD image (e.g., 3D+t --> 3D) with the current time step only. That can be useful if you want to extract a single image or its corresponding subvolume of the time series. 
 
 \section org_mitk_views_imagecropperIssues Current issues
 
 Cropping 2D images is not supported unless the are 3D images containing only a single slice. The user will be notified by a warning and the input is handled as a single label image.
 
 Right now changing the shape or rotation of the bounding shape is not supported but might be integrated in the future.
 
 Furthermore, a warning appears when the bounding shape is not aligned with the image. In this case, the handles can not be used correctly and get deactivated. You can continue to alter them by performing a 'Reinit' on the image.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/crop.svg b/Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/imagecropper-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/crop.svg
rename to Plugins/org.mitk.gui.qt.imagecropper/documentation/UserManual/imagecropper-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/QmtikImageNavigator.dox b/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/QmtikImageNavigator.dox
index e158d98694..d98606feaf 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/QmtikImageNavigator.dox
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/QmtikImageNavigator.dox
@@ -1,15 +1,15 @@
 /**
 \page org_mitk_views_imagenavigator The Image Navigator
 
-\imageMacro{image_navigator.svg,"Icon of the Image Navigator",2.00}
+\imageMacro{imagenavigator-dox.svg,"Icon of the Image Navigator",2.00}
 
 \imageMacro{QmtikImageNavigator_ImageNavigator.png,"Image Navigator",7.47}
 
 Fast movement through the available data can be achieved by using the Image Navigator. 
 By moving the sliders around you can scroll quickly through the slides and timesteps. 
 By entering numbers in the relevant fields you can jump directly to your point of interest.
 
 The "Show detail" checkbox enables you to see the world coordinates in millimetres
 and the index/voxel coordinates.  These may be edited to jump to a specific location.
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/image_navigator.svg b/Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/imagenavigator-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/image_navigator.svg
rename to Plugins/org.mitk.gui.qt.imagenavigator/documentation/UserManual/imagenavigator-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.lasercontrol/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.lasercontrol/documentation/UserManual/Manual.dox
deleted file mode 100644
index d94dda6a62..0000000000
--- a/Plugins/org.mitk.gui.qt.lasercontrol/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_mitk_gui_qt_lasercontrol The Laser Control
-
-\imageMacro{icon.png,"Icon of Lasercontrol",2.00}
-
-\tableofcontents
-
-\section org_mitk_gui_qt_lasercontrolOverview Overview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.lasercontrol/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.lasercontrol/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Plugins/org.mitk.gui.qt.lasercontrol/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Plugins/org.mitk.gui.qt.lasercontrol/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.lasercontrol/documentation/doxygen/modules.dox
deleted file mode 100644
index 1ecfa33fe9..0000000000
--- a/Plugins/org.mitk.gui.qt.lasercontrol/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mitk_gui_qt_lasercontrol org.mitk.gui.qt.lasercontrol
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mitk_gui_qt_lasercontrol_internal Internal
-  \ingroup org_mitk_gui_qt_lasercontrol
-
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.lasercontrol plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/documentation/UserManual/Manual.dox
index 2e852eeafa..0f87905d06 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.evaluator/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.matchpoint.evaluator/documentation/UserManual/Manual.dox
@@ -1,56 +1,56 @@
 /**
 \page org_mitk_views_matchpoint_evaluator The MatchPoint Registration Evaluation View
 
 \imageMacro{map_evaluator_doc.svg, "Icon of the MatchPoint Registration Evaluator", 3}
 
 \tableofcontents
 
 \section MAP_REGEVAL_Introduction Introduction
 This view offers the possibility to evaluate the quality of the registration/mapping of two given images by visual inspection.
 This can either by used to assess the visual quality of a registration or to assess how well the image contents are already aligned
 by default. To achieve the latter, one may select no registration. Then the images will be displayed in evaluation mode assuming an identity transform (so no mapping).
 It is one of several MatchPoint registration plug-ins.\n
 
 \section MAP_REGEVAL_Usage Usage
 \imageMacro{map_view_evaluator_example.png, "Example screenshot showing the main elements of the view.", 14}
 (1) The currently selected registration that should be used to map the moving image for evaluation. Click to change. If no registration is selected, a direct evaluation will be performed.\n
 (2) Reset button will remove the currently selected registration.\n
 (3) Auto select option. If active the view will try to deduce and automatically select (if loaded in the application) the moving and target image when the registration changes. The view assumes that the moving and target images used to determine the registration should be used.\n
 (4) The currently selected moving data. Click to change.\n
 (5) The currently selected target data. Click to change.\n
 (6) Start/Stop button used to activate/deactivate the evaluation. This button become active when at least the moving and the target image are selected.\n
 (7) Selection of the visualization style. (only visible if evaluation is active)\n
 (8) Style specific settings. (only visible if evaluation is active)\n
 
-If the evaluation view is active you can choose between different modes of visualization. For more details see \ref MAP_REGEVAL_Styles.\n
+If the evaluation view is active you can choose between different modes of visualization. For more details see \ref MAP_REGEVAL_Styles .\n
 To stop the evaluation mode, you may use the "Stop evaluation" button or just close the evaluation view.
 
 \remark The evaluation view will use the level window settings of the used images. So to change the level windowing of the evaluation view, you must change the
 level windowing of the respective input images (moving image and target image).
 
 \section MAP_REGEVAL_Accuracy Evaluating accuracy
 <b>Important note:</b> Please be aware, that a visual inspection of registration quality is only a weak surrogate for a thorough accuracy analysis based on representative and suitable ground truth data. From a visually good mapping you can not deduce a correct registration. This is especially true if the degrees of freedom of the registration increases. For a rigid registration it might by feasible to discern correct and incorrect registration. But for none rigid registrations you definitely you should use this view only for first visual inspection (to check if it SEEMS to do the right thing and is worth further exploration) or illustrating the registration effect for registration you have assessed in a sound way.
 
 \section MAP_REGEVAL_Styles Visualization styles
 You can choose from the following visualization styles to evaluate the registration/mapping quality:\n
 \li "Blend": Blends the images with a user defined weight. Default is 50:50.
 \imageMacro{map_view_blend_settings.png, "Settings of the Blend style", 8}
 (1) Click to set the weights to 100% target image.\n
 (2) Click to set the weights to 50:50 (equal blend).\n
 (3) Slider to adjust the weights between target image and the mapped input image. The spin box shows the weight of the mapped input image.\n
 (4) Click to set the weights to 100% mapped input image.\n
 (5) Click to toggle the weight between both images.\n
 \imageMacro{map_style_blend.png, "Example for mode: Blend (50:50)", 5}
 \li "Checkerboard": Checkerboard style that composes both images by showing image 1 in all light squares and image 2 in all dark squares. You can define the resolution/number of squares of the checkerboard.
 \imageMacro{map_style_checkerboard.png, "Example for mode: Checkerboard", 5}
 \li "Color blend": Color blend of the images (blue: target image; yellow: moving). Areas where you see no color implies good intensity matchings.
 \imageMacro{map_style_color_blend.png, "Example for mode: Color blend", 5}
 \li "Contour": Blend mode that displays one image as blue "background" and the other image in yellow contours. You can choose the role of the images.
 \imageMacro{map_style_contour.png, "Example for mode: Contour", 5}
 \li "Difference": Displays the absolute difference of both images.
 \li "Wipe": Blend mode that makes a rectilinear combination of the images. You can choose the mode how the images are splitted. The split is synchronized with the current selection. So you may interact with the split border to position it on interesting areas.
 \imageMacro{map_style_wipe_cross.png, "Example for mode: Wipe cross", 5}
 \imageMacro{map_style_wipe_horizontal.png, "Example for mode: Wipe horizontal", 5}
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.framereg/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.matchpoint.framereg/documentation/UserManual/Manual.dox
index 39073f4f70..ed515cb4ea 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.framereg/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.matchpoint.framereg/documentation/UserManual/Manual.dox
@@ -1,55 +1,55 @@
 /**
 \page org_mitk_views_matchpoint_framereg The MatchPoint Frame Correction View
 
 \imageMacro{"map_framereg_icon_doc.svg", "Icon of the MatchPoint Algorithm Control", 3}
 
 \tableofcontents
 
 \section MAP_FRAME_Introduction Introduction
 This view offers the user a way to use a selected registration algorithm in order to apply a frame correction to a selected 3D+t image. 
 This is for example useful if you have a dynamic image with motion artifacts in some time points and you want to reduce/remove these motion artifacts.
 
 
 \section MAP_FRAME_Usage Usage
 \imageMacro{"map_framereg_example.png" , "Example screenshot of the view.", 15}
-To use the view, a 3D+t image must be selected and a registration algorithm must be loaded. For the selection of an algorithm please see \ref org_mitk_views_matchpoint_algorithm_browser.\n
+To use the view, a 3D+t image must be selected and a registration algorithm must be loaded. For the selection of an algorithm please see \ref org_mitk_views_matchpoint_algorithm_browser .\n
 The correction is performed such that every time frame of the image is registered to the first time frame. And the corrected time frames are mapped to the same geometry as the first frame.\n
 If an algorithm is loaded and an input images is selected, the view will automatically switch to the <i>Execution</i> tab.
 
 \subsection MAP_FRAME_Usage_selection Algorithm selection tab
 \imageMacro{map_step1_selection.png, "Details of the algorithm selection tab.", 6}
 In this tab, you can load the algorithm selected in the MatchPoint Algorithm Browser. In the area below the selection button the profile information of the registration algorithm is displayed.
 For a detailed description of the profile characteristics the user is referred to \ref org_mitk_views_matchpoint_algorithm_browser .\n
 When clicking the <i>Load selected algorithm</i> button, the selected algorithm will be used by the view for the frame correction and the name of the algorithm will be displayed in the text field <i>Loaded algorithm</i> at the top of the view.\n 
 At this point, it has no effect if you change the the selection in the algorithm browser. The view will keep the loaded algorithm until you choose to load another one.
 
 \subsection MAP_FRAME_Usage_exec Execution tab
 \imageMacro{map_step2_execution.png, "Details of the execution tab.", 6}
 In this tab you can specify a name for the correction job (this will determine the names of the result nodes in the data manager).\n
 Clicking the <i>Start</i> button will trigger the correction process.
 
 \subsection MAP_FRAME_Usage_settings Settings tab
 \imageMacro{map_step3_settings.png, "Details of the settings tab.", 6}
 In this tab, you can configure the \ref MAP_FRAME_Mapper_Settings which are used for the corrected frames, or parameterize the loaded algorithm (before it starts), if it offers any possibility to do so.
 
 \subsubsection  MAP_FRAME_Mapper_Settings Mapping settings
 For the mapping of corrected images, you have several settings available:\n
 \li <b>Allow undefined pixels</b> Activate to handle pixels of the result image that are not in the field of view of the input image. These pixels will get the <i>padding value</i>.
 \li <b>Allow error pixels</b> Activate to handle pixels of the result image that can not be mapped because the registration does not support this part of the output image. These pixels will get the <i>error value</i>.
 \li <b>Interpolator</b> Set to choose the interpolation strategy that should be used for mapping. See details at \ref MAP_FRAME_Interpolation .
 
 \subsubsection  MAP_FRAME_Interpolation Interpolation
 You can choose from the following interpolation strategies:\n
 \li <b>Nearest Neighbour</b> Use the value of the nearest pixel. Fastest, but high interpolation errors for gray value images. Right choice for label images or masks.
 \li <b>Linear"</b> Fast linear interpolation with often sufficient quality. Tends to blur edges.
 \li <b>BSpline (3rd order)</b> Good trade off between time and quality.
 \li <b>Windowed Sinc (Hamming)</b> Good interpolation quality but very time consuming.
 \li <b>Windowed Sinc (Welch)</b> Good interpolation quality but very time consuming.
 
 \subsection MAP_FRAME_Usage_frame_selection Frame selection tab
 \imageMacro{map_step4_frameselection.png, "Details of the frame selection tab.", 6}
 In this tab you can specify the frames of the currently selected image that should be corrected. As default all frames of an image will be selected.
 If you only select specific frames, these frames will be corrected whilst all other frames will be just copied unchanged.
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.mapper/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.matchpoint.mapper/documentation/UserManual/Manual.dox
index c3f3652037..293ac2fd36 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.mapper/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.matchpoint.mapper/documentation/UserManual/Manual.dox
@@ -1,79 +1,79 @@
 /**
 \page org_mitk_views_matchpoint_mapper The MatchPoint Image Mapper View
 
 \imageMacro{map_mapper_icon_doc.svg, "Icon of the MatchPoint Image Mapper",3}
 
 \tableofcontents
 
 \section MAP_MAPPER_Introduction Introduction
 This view offers the possibility to map any loaded image or point set using a user selected registration object.
 When mapping images the user can control the field of view (image geometry) the image should be mapped into, as well as the interpolation strategy and padding values that should be used.
 
 It is one of several MatchPoint registration plugins.
 
 <b>Typical usage scenarios</b>\n
 You have registered image I1 onto image I2. Now you want to
 \li (Most obvious) map I1 onto I2 with the registration, e.g. to make a joint statistical analysis.
 \li map image I3 (e.g. an other MRI sequence of the same session) also onto I2 with the same registration.
 \li map a segmentation created on I1 also onto I2 with the same registration.
 \li map a point set of image I1 also onto I2 with the same registration.
 
 \section MAP_MAPPER_Usage Usage
 To use the mapper at least the input (image or point set) must be selected. Additionally, you may select a registration object and, in case the input is an image, an optional reference image.
 
 The reference image defines the geometry (field of view, orientation, spacing) that should be used for the result image.
 The view will try to automatically determine the reference image. By default it is the target image that was used to determine the selected registration.
 If auto selection cannot determine the reference (e.g. because it was not specified or it is currently not loaded), the input image will be selected as reference.
 The reference image can be also defined by the user explicitly by activating manual selection.
 
 REMARK: If you map point sets you can ignore the reference image slot. It has no effect.
 
 REMARK: The mapping results will be added as child nodes to the used input node.
 
 REMARK: If you do not select an registration the view will assume that you make an identity transform. This is a convenient way if you
 just want to resample an image into the geometry of an other image (when no registration is needed). Also in this use case you can take
 advantage of the different interpolation and sub/super sampling strategies.
 
 \imageMacro{map_mapper_instructions.png, "Main elements of the mapper view.", 7}
 (1) The currently selected registration that will be used for mapping. Click to change.\n
 (2) Reset button that will remove the current selected registration and switch back to an identity transform.\n
 (3) The currently selected input data, that will be mapped. Click to change.\n
 (4) The currently (automatically or by user) selected reference image, that defines the geometry of the result. Click to change.\n
 (5) The name of the result data in the data manager.\n
-(6) The start button(s) to commence the mapping process. For details regarding the two options see \ref MAP_MAPPER_Refine.\n
+(6) The start button(s) to commence the mapping process. For details regarding the two options see \ref MAP_MAPPER_Refine .\n
 (7) Log windows with messages regarding the mapping process.\n
 
 
 \section MAP_MAPPER_Refine Mapping or geometry refinement
 The mapper view offers two options to map images:\n
 \li "Map" (default)
 \li "Refine geometry"
 For images "Map" fills the pixels of the output image by interpolating input image pixels using the registration object. This option always works,
 but may take longer and introduces interpolation errors, because a new image is resampled.\n
 The second option "Refine geometry" is only offered, if the registration (more precisely its inverse kernel) is matrix based and the selected data is an image.
 In this case it just clones the image and refines its image geometry (origin and orientation) to project it to the position indicated by the registration; thus no interpolation artefacts are introduced.
 \remark If you want to use a mapped image in conjunction with the image statistics plugin and a mask of the reference image (or you want to proceed any other computation that expects the voxel to be in the same grid for direct numeric comparison), you must use "Map" to ensure the same geometry
 (including the same image grid; including same spacing and resolution). Otherwise operations like the images statistics plugin will fail.
 
 \section MAP_MAPPER_Settings Settings
 \imageMacro{map_mapper-settings.png, "Available settings for mapping images.", 7}
 If you map the image (and not just refine the geometry), you have several settings available:\n
 \li "Allow undefined pixels": Activate to handle pixels of the result image that are not in the field of view of the input image. These pixels will get the "padding value".
 \li "Allow unregistered pixels": Activate to handle pixels of the result image that can not be mapped because the registration does not support this part of the output image. These pixels will get the "error value".
 \li "Interpolator": Set to choose the interpolation strategy that should be used for mapping.
 \li "Activate super/sub sampling": Activate if you want to use origin and orientation of the reference image but want to alter the spacing.
 
 \section MAP_MAPPER_Interpolation Interpolation
 You can choose from the following interpolation strategies:\n
 \li "Nearest Neighbor": Use the value of the nearest pixel. Fastest, but high interpolation errors for gray value images. Right choice for label images or masks.
 \li "Linear": Fast linear interpolation with often sufficient quality. Tends to blur edges.
 \li "BSpline (3rd order)": Good trade off between time and quality.
 \li "Windowed Sinc (Hamming)": Good interpolation quality but very time consuming.
 \li "Windowed Sinc (Welch)": Good interpolation quality but very time consuming.
 
 \section MAP_MAPPER_Masks Handling of masks/segmentations
 If you select an mask as input image, the plugin will be automatically reconfigured to settings that are suitable for the task of mapping masks.
 Most importantly the interpolator will be set to "Nearest Neighbor".
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
index f371747b7c..f65817f42d 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkImageStatistics.dox
@@ -1,63 +1,63 @@
 /**
 \page org_mitk_views_imagestatistics The Image Statistics View
 
-\imageMacro{bar-chart2.svg,"Icon of the Image Statistics View",2.00}
+\imageMacro{bar-chart2-dox.svg,"Icon of the Image Statistics View",2.00}
 
 \section QmitkImageStatisticsUserManualSummary Summary
 
 This view provides an easy interface to quickly compute some features of a whole image or a region of interest.
 
 This document will tell you how to use this view, but it is assumed that you already know how to use MITK in general.
 
 Please see \ref QmitkImageStatisticsUserManualDetails for more detailed information on usage and supported filters.
 
 \section QmitkImageStatisticsUserManualDetails Details
 
 Manual sections:
 
 - \ref QmitkImageStatisticsUserManualOverview
 - \ref QmitkImageStatisticsUserManualUsage
 
 \section QmitkImageStatisticsUserManualOverview Overview
 
 This view provides an easy interface to quickly compute some features of a whole image or a region of interest.
 
 \imageMacro{QmitkMeasurementToolbox_Interface.png,"The interface",9.10}
 
 \section QmitkImageStatisticsUserManualUsage Usage
 
 
 To select the input data, either use the quick selection button (labeled "+"), or select the input data via the "Input Data" tab.
 
 \imageMacro{QmitkImageStatistics_InputData.png,"Select the input data via the \"Input data\" tab (marked red) or via the quick selection button (marked yellow)",10}
 
 \subsection QmitkImageStatisticStatistics Statistics
 After selection of an image or a binary mask as input data, the image statistics are calculated and displayed in the "Statistics" section. If masks (ROIs: segmentations, planarfigures, ...) are selected, the statistics for these masks are shown. For time data the statistics for each time step are calculated correspondingly.
 
 An example of parts of the calculated statistical features (Mean, Median, StandardDeviation, RMS, Max, MaxPosition, Min, MinPosition, Voxel, Volume [mm^3], Skewness, Kurtosis, Uniformity, Entropy, MPP, UPP and Variance) for different timesteps and different masks is pictured below.
 
 \imageMacro{QmitkImageStatistics_statistics.png, "Example of parts of the statistics for different masks and timestamps", 1.00}
 
 Check "Ignore zero-valued voxels" to hide voxels with grayvalue zero.
 
 \subsection QmitkImageStatisticHistogram Histogram
 
 Beneath the statistics window is the histogram window, which shows the histogram of the current selection.
 
 The histogram window is currently only available for a single image and no or one ROI: When selection multiple images and/or multiple masks, the histogram window is deactivated!
 
 Draw a rectangular window with a pressed left button to zoom in on the histogram. With a double click in the view area you can zoom out to the default viewport. You can also pan the view in horizontal or vertical direction by dragging with the left mouse button in the respective direction. Additionally, different options like "Custom Zoom", to set the maximum and minimum value, or by adjusting the number of bins, can be used to modify the view.
 
 If the mask is not a closed planar figure or a segmentation an intensity profile is created instead of the histogram.
 
 A tooltip is available by hovering over one of the bins.
 
 \subsection QmitkImageStatisticsUserManualCopytoClipboard Copy to Clipboard
 
 At the bottom of each view is a "Copy to Clipboard" button, allowing to copy the respective data in csv format to the clipboard.
 Be aware of the following information regarding this functionality:
 \li The values are separated by tabulator.
 \li  Numeric values will be converted using the system language (e.g. with German as system language the decimal separator will be ",", with English it will be '.').
 \li  One can directly copy'n'paste into Excel (and alike) as long as Excel supports/is configured to the system language
 
 */
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
index e1372508d9..0cac52c084 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
@@ -1,90 +1,90 @@
 /**
 \page org_mitk_views_measurement The Measurement View
 
-\imageMacro{measurement.svg,"Icon of the Measurement View",2.00}
+\imageMacro{measurement-dox.svg,"Icon of the Measurement View",2.00}
 
 <h1>Overview</h1>
 
 The Measurement view allows you to measure distances, angles, paths and several geometric figures on 2D images or image slices of 3D and 4D images. The measurement view is repeatedly useable with the same or different measurement figures that are related to the chosen image and can be saved together with it for future use. 
 
 
 \imageMacro{QmitkMeasurementToolbox_BasicScreenEdited.jpg,"Image with measurements",16.00}
 
 
 <h1>Usage</h1>
 
 The first step to perform measurements is to select a reference image on top of the view. All resulting measurements will be assigned as child nodes of the image in the data manager. The standard working plane is 'Axial' but the other standard view planes ('Saggital' and 'Coronal') are also valid for measurements. 
 
 
 \imageMacro{QmitkMeasurementToolbox_MeasurementView.jpg,"Measurement View",7.60}
 
 After selecting an image, you can click on any of the geometrical symbols. The respective measurement will appear as soon as you click on the image location you want to measure.
 
 The view offers a variety of measurement options that are introduced in the following:
 
 <ul>
 <li> <b>Line:</b>
 
 Draws a line between two set points and returns the distance between these points.
 
 <li> <b>Path:</b>
 
 Draws a line between several set points (two and more) and calculates the overall length, which is all lines length summed up. Add the final point by double left-click.
 
 <li> <b>Angle:</b>
 
 Draws two lines from three set points connected in the second set point and return the inner angle at the second point.
 
 <li> <b>Four Point / Double Angle:</b>
 
 Draws two lines that may but do not have to intersect from four set points. The returned angle is the one depicted in the icon.
 
 <li> <b>Circle:</b>
 
 Draws a circle by setting two points, whereas the first set point is the center and the second the radius of the circle. The measured values are the radius and the included area.
 
 <li> <b>Ellipse:</b>
 
 Draws an ellipse that can be modified by three points. The middle point can be used to move the whole measurement. The lower point modifies the ellipse axes. The right point can be used to modify the radius of the ellipse. The measured values are the major and minor axes and the area.
 
 <li> <b>Double Ellipse:</b>
 
 Draws two ellipses by adjusting four points. The middle point can be used to move the whole measurement. The left point is used to adjust the distance between the two ellipses. The lower point modifies the ellipse axes. The right point can be used to modify the radius of the ellipse. Can be used for measuring e.g. the wall thickness of a vessel. The measured values are the major and minor axes and the thickness.
 
 <li> <b>Rectangle:</b>
 
 Draws a rectangle by setting two points at the opposing edges of the rectangle starting with the upper left corner. The measured values are the circumference and the included area.
 
 <li> <b>Polygon:</b>
 
 Draws a closed polygon that can have an arbitrary number of points. New points are added by left mouse-click. To finish the drawing the user can double click on the last control point. The measured values are circumference and area.
 
 <li> <b>Bezier curve:</b>
 
 Draws a bezier curve by adding some control points with left mouse-click. To finish the drawing the user can double-click on the last control point. The measured value is the length of the bezier curve.
 
 <li> <b>Subdivision Polygon:</b>
 
 Draws a closed subdivision polygon by adding some control points with left mouse-click. To finish the drawing the user can double-click on the last control point. The measured value is the circumference of the polygon.
 </ul>
 
 <h2>Fixed sizes of measurement figures</h2>
 The measurement view offers a fixed size for circle and double ellipses to preset a radius and a thickness. This is useful e.g. for diagnostic studies where you want to derive gray value statistics from a well defined region.
 
 <h2>Modify measurements</h2>
 
 All measurements can be modified later on by moving the respective control points. Note that they can only be modified if the view is open.
 
 <h2>Multiple measurement figures</h2>
 
 When applying more than one measurement figure to the image the actual measurement figure is depicted in red and the displayed values belong to this measurement figure. All other measurement figures appear white. They can be selected by a left-mouse click on the respective node.
 
 
 <h2>Save the measurement information</h2>
 The entire scene containing the image and the measurement figures can be saved for future use. Scenes are saved with a '.mitk' extension by pressing 'Save Project' and contain all nodes and relevant information. Alternatively, you can just save the measurement solely (with file extension '.pf') by right-click on the node in the data manager.
 
 The content of the measurement widget can be copied to the clipboard with the corresponding button for further use in a table calculation program (e.g. Open Office Calc etc.).
 
 <h2>Remove measurement figures or image</h2>
 If the single measurement figures or the image is not needed any longer, it can be removed solely or as an entire group. The image can't be removed without simultaneously removing all the dependent measurement figures that belong to the image tree in the data manager. To remove, just select the wanted items in the data manager list by right-clicking on the respective node or, if several items wanted to be removed, right-click on all wanted by simultaneously holding the ctrl-button pressed.
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/bar-chart.svg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/bar-chart.svg
deleted file mode 100644
index a756ada699..0000000000
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/bar-chart.svg
+++ /dev/null
@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="111.72881"
-   height="83.7966"
-   viewBox="0 0 111.72881 83.7966"
-   id="svg2"
-   version="1.1"
-   inkscape:version="0.92.3 (2405546, 2018-03-11)"
-   sodipodi:docname="bar-chart.svg">
-  <metadata
-     id="metadata10">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <defs
-     id="defs8" />
-  <sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1680"
-     inkscape:window-height="988"
-     id="namedview6"
-     showgrid="false"
-     inkscape:zoom="0.45814732"
-     inkscape:cx="1024"
-     inkscape:cy="768"
-     inkscape:window-x="-8"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="svg2"
-     inkscape:snap-page="false"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0" />
-  <g
-     id="g813"
-     transform="translate(0,-1580.2034)">
-    <path
-       inkscape:connector-curvature="0"
-       style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.05455508"
-       id="path4"
-       d="m 34.915254,1622.1017 v 27.9322 H 20.949153 v -27.9322 z m 20.949153,-27.9322 v 55.8644 H 41.898305 v -55.8644 z m 55.864403,62.8474 V 1664 H 0 v -83.7966 h 6.9830508 v 76.8135 z m -34.915251,-48.8813 v 41.8983 H 62.847458 v -41.8983 z m 20.949153,-20.9492 v 62.8475 H 83.79661 v -62.8475 z" />
-  </g>
-</svg>
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/bar-chart2.svg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/bar-chart2-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/bar-chart2.svg
rename to Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/bar-chart2-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/measurement.svg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/measurement-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/measurement.svg
rename to Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/measurement-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMaker.dox b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMaker.dox
index 2cbc42acca..474d73a10f 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMaker.dox
+++ b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkMovieMaker.dox
@@ -1,64 +1,64 @@
 /**
-\page org_mitk_views_moviemaker The Movie Maker
+\page org_mitk_views_moviemaker The Movie Maker View
 
 \imageMacro{moviemakericon_black.svg,"Icon of the Movie Maker Plugin.",2.00}
 
 \tableofcontents
 
 \section org_mitk_views_moviemakerOverview Overview
 
 The Movie Maker View allows you to create basic animations of your scene and to record them to video files.
 Individual animations are arranged in a timeline and can be played back sequential or in parallel.
 
 The Movie Maker View uses the external FFmpeg command line utility to write compressed video files.
 
 <b>You have to manually install FFmpeg and set the corresponding path in "External Programs" in the MITK Workbench Preferences (Ctrl+P) in order to record your movies to video files.</b>
 
 \imageMacro{QmitkMovieMaker_Preferences.png,"The External Programs preferences page.",12.00}
 
 \section org_mitk_views_moviemakerUsage Usage
 
 \imageMacro{QmitkMovieMaker_MovieMakerView.png,"The Movie Maker View.",16.00}
 
 To create a movie you have to add an animation to the timeline by clicking the "Add animation" button.
 You can choose between the available types of animations, e.g., Orbit or Slice.
 
 The timeline surrounding bottons allow you to arrange, remove, or add further animations to your movie.
 
 Each animation can be set to either begin with the previous animation, i.e., run in parallel, or to start after the previous animation, i.e., run sequential.
 In combination with delays, rather complex animation arrangements are possible.
 
 To set animation specific parameters, select the corresponding animation in the timeline first.
 
 You can play back, pause and stop your movie with the according controls at the bottom of the Movie Maker View.
 Click the "Record" button to finally record your movie to a video file with the specified number of frames per second.
 You have to choose the render window which you want to record.
 
 \subsection org_mitk_views_moviemakerOrbitUsage Orbit Animation
 
 The Orbit animation rotates the camera in the 3D window around the scene.
 Align the camera directly in the 3D window and enter the number of degrees for the orbitting.
 If you are planning to have a specific view in the middle of your movie you can play the movie and pause it at the specific frame of interest.
 Adjust the camera in the 3D window and restart the animation.
 
 \imageMacro{QmitkMovieMaker_Orbit.png,"The Orbit animation.",12.00}
 
 \subsection org_mitk_views_moviemakerSliceUsage Slice Animation
 
 The Slice animation slices through an image.
 You can choose the image plane (axial, sagittal, or coronal), as well as the start and end points of the slicing.
 Use the image navigator in the bottom left of the Workbench to get an idea of the desired values.
 Check "Reverse" in order to slice from the higher slice number to the lower slice number.
 
 \imageMacro{QmitkMovieMaker_Slice.png,"The Slice animation.",12.00}
 
 \subsection org_mitk_views_moviemakerTimeUsage Time Animation
 
 The Time animation steps through the individual time steps of the current scene.
 You can specify the range of the animated time steps.
 Use the image navigator in the bottom left of the Workbench to get an idea of the desired values.
 Check "Reverse" in order to step from later time steps to previous time steps.
 
 \imageMacro{QmitkMovieMaker_Time.gif,"The Time animation.",12.00}
 
 */
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMaker.dox b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMaker.dox
index 10230cc3cb..1c8f51d029 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMaker.dox
+++ b/Plugins/org.mitk.gui.qt.moviemaker/documentation/UserManual/QmitkScreenshotMaker.dox
@@ -1,18 +1,18 @@
 /**
-\page org_mitk_views_screenshotmaker The Screenshot Maker
+\page org_mitk_views_screenshotmaker The Screenshot Maker View
 
 This view provides the functionality to create and save screenshots of the data.
 
 \imageMacro{QmitkMovieMaker_ScreenshotMakerInterface.png,"The Screenshot Maker User Interface",7.09}
 
 \section QmitkScreenshotMakerUserManualUse Usage
 
 The first section offers the option to create a screenshot of selected view plane (axial, sagittal or coronal). Upon clicking the 'Single' button in the '2D Screenshot' section, the Screenshot Maker asks for a filename in which the screenshot is to be stored. The 'Multiplanar' button asks for a folder, in which screenshots of the three 2D views will be stored with default names.
 
 If you tick the 'All Components' checkbox, you can take a screenshot of every channel of your multi-channel image. Otherwise, only the visible channel is captured.
 
 The '3D Screenshots (High-res)' section works the same as the simple screenshot section, aside from the fact, that the user can choose a magnification ('Upsampling') factor. The 'Single' button creates a screenshot of the current 3D render window and the 'Multiplanar' button creates three screenshots from different perspectives.
 
 In the 'Options' section, one can choose the background color for the screenshots, default is black.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/QmitkMultiLabelSegmentation.dox b/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/QmitkMultiLabelSegmentation.dox
index 327c866b27..c0f9d94840 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/QmitkMultiLabelSegmentation.dox
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/QmitkMultiLabelSegmentation.dox
@@ -1,118 +1,118 @@
 /**
 \page org_mitk_views_multilabelsegmentation The Multilabel Segmentation
 
-\imageMacro{"multilabelsegmentation.svg", "Icon of the MultiLabelSegmentation Plugin", 12}
+\imageMacro{"multilabelsegmentation-dox.svg", "Icon of the MultiLabelSegmentation Plugin", 12}
 
 The difference between a binary and a multi-label segmentation is that a multi-label segmentation can not only contain more than one label but also more than one layer. This allows you to create different labels for different regions of interest encapsulated in one single image. The difference between labels and layers is that labels on one layer cannot overlap but labels on different layers can.
 <br>
 The <b>Multilabel Segmentation plugin</b> consists of two views which can be used for:
 <ul>
   <li> manual and (semi-)automatic segmentation of anatomical and pathological structures in medical images via <b>the Multilabel Segmentation View</b>
   <li> multilabel segmentation postprocessing via \subpage org_mitk_views_multilabelsegmentationutilities
 </ul>
 
 Hereinafter, a description is given on how multi-label segmentations can be created and modified. Please refer to \ref org_mitk_views_segmentation for a description of the general segmentation tools.
 
 \tableofcontents
 
 \section org_mitk_views_multilabelsegmentationUserManualCreateOpenSaveImportAdd Data Selection
 
 In the 'MultiLabel Segmentation' view you can first select an image. Thereafter, you can either create a new segmentation session by pressing the symbol right to the selection widget or select an existing one.
 
 \imageMacro{"org_mitk_views_multilabelsegmentationIMGtoolbar.png", "Data selection",12}
 
 
 \section org_mitk_views_multilabelsegmentationUserManualLayerTable Segmentation Layers
 Once you started a segmentation session you can add or delete different layers. You can use the layers independently and switch layers by the left and right arrows.
 
 
 \imageMacro{"org_mitk_views_multilabelsegmentationIMGlayerManager.png", "Layer selection",12}
 
 \subsection org_mitk_views_multilabelsegmentationUserManualLayerCreation Creating a New Layer
 
 A layer is a set of labels that occupy a non-overlapping anatomical space. The best way to describe them is by a real use case. Imagine you are working on a radiotherapy planning application. In the first layer of your segmentation
 session, you would like to trace the contours of the liver and neighboring organs. You can accommodate all these segmentations in separate labels because they all occupy different anatomical regions and do not overlap. Now say you would like to segment the arteries and veins inside the liver. If you don't trace them in a different layer, you will overwrite the previous ones. You may also need a third layer for segmenting the different irrigation territories in the liver and a fourth layer to contain the lesion you would like to treat.
 
 \section org_mitk_views_multilabelsegmentationUserManualLabelTable Segmentation Labels
 
 For each layer, you can add one or more labels. Pressing the double arrow on the right, all created labels are shown in the 'Lable Table'. The following label properties are available:
 
 <ul>
   <li><b>Name:</b></li> the name of the label. Can be a predefined one or any other.
   <li><b>Locked:</b></li> whether the label is locked or editable. A locked label cannot be overwritten by another.
   <li><b>Color:</b></li> the color of the label.
   <li><b>Visible:</b></li> whether the label is currently visible or hidden.
 </ul>
 
 
 \imageMacro{"org_mitk_views_multilabelsegmentationIMGlabeltable.png", "The 'Label Table' shows all labels in the current segmentation session", 12}
 
 \subsection org_mitk_views_multilabelsegmentationUserManualLabelCreation Creating a New Label
 
 Click the 'New Label' button to add a new label. A dialog will show up to enter the name and color. Preset organ names and
 corresponding colors are offered while you type in, but you can set any name. The new name - if not known - will be automatically remembered and made available the next time you create a new label. In the current implementation of the plugin, the maximum number of labels is restricted to 255. If you need more, you will have to create a new segmentation session.
 
 
 \subsection org_mitk_views_multilabelsegmentationUserManualLabelPresets Saving and Loading Label Set Presets
 
 Label set presets are useful to share a certain style or scheme between different segmentation sessions or to provide templates for new segmentation sessions.
 
 The properties of all labels in all layers like their names, colors, and visibilities are saved as a label set preset by clicking on the 'Save label set preset' button.
 Label set presets are applied to any segmentation session by clicking on the 'Load label set preset' button.
 If a label for a certain value already exists, its properties are overridden by the preset.
 If a label for a certain value does not yet exist, an empty label with the label properties of the preset is created.
 The actual segmentations of labels are unaffected as label set presets only store label properties.
 
 
 \subsection org_mitk_views_multilabelsegmentationUserManualLabelSearch Searching a Label
 
 It may happen that many labels (e.g. > 200) are present in a segmentation session and therefore manual searching can be time-consuming.
 The 'Label Search' edit box allows for quickly finding the label you want. Just start writing its name and you will get assistance for completing its name. If the label you were searching is found, press 'enter' and it will become the active one.
 
 
 \subsection org_mitk_views_multilabelsegmentationUserManualLabelEditing Label Editing
 
 Here the actual segmentation takes place. First of all, you have to select the active label by clicking on the corresponding row in the 'Label Table'. Note that only one label can be active at the time. Then you can select segmentation tool in the toolbox.
 
 \imageMacro{"org_mitk_views_multilabelsegmentationIMGSegmentationToolbox.png", "Segmentation toolbox", 12}
 
 
 \note Not all segmentation tools can be found here. This is because some of the semi-automatic tools can not be applied in case of multiple labels.
 
 \subsection org_mitk_views_multilabelsegmentationUserManualOperationsOnLabels Operations on Labels
 
 Depending on your selection in the 'Label Table', several actions are offered:
 
 \subsubsection org_mitk_views_multilabelsegmentationUserManualOperationsOnSingleSelection Single Label Selection
 
 If you right click on any label in the table, a pop-up menu offers the following actions to be performed on the selected label:
 
 <ul>
 <li><b>Rename...</b></li> : change the name and/or color of the selected label.
 <li><b>Remove...</b></li> : delete the selected label.
 <li><b>Erase...</b></li> : only clear the contents of the selected label.
 <li><b>Merge...</b></li> : merge two labels by selecting a second label.
 <li><b>Random color </b></li> : assign a random color to the label.
 <li><b>View only </b></li> : make all labels except the current selected label invisible.
 <li><b>View/Hide all </b></li> : make all labels visible / invisible
 <li><b>Lock/Unlock all </b></li> : lock or unlock all labels.
 <li><b>Create surface </b></li> : generate a surface out of the selected label.
   <li><b>Create mask </b></li> : generate a mask out of the selected label. A mask is a binary image with "1" inside and "0" outside.
   <li><b>Create cropped mask </b></li> : generate a binary mask out of the selected label. Crop changes the extent of the resulting image to the extent of the label.
 </ul>
 
 \imageMacro{"org_mitk_views_multilabelsegmentationIMGLabelTableSingleSelectionContextMenu.png", "Context menu for single label selection", 12}
 
 \subsubsection org_mitk_views_multilabelsegmentationUserManualOperationsOnMultipleSelection Multiple Label Selection
 
 You can select more than one label by shift-click on other labels. If more than one label is selected, different options will appear in the menu:
 
 \imageMacro{"org_mitk_views_multilabelsegmentationIMGLabelTableMultipleSelectionContextMenu.png", "Context menu for multiple label selection", 12}
 
 <ul>
   <li><b>Merge selection on current label</b></li> : transfer the contents of the selected labels in the 'Label Table' into the current one.
   <li><b>Remove selected labels</b></li> : delete the selected labels.
   <li><b>Erase selected labels</b></li> : only clear the contents of the selected labels.
 </ul>
 
 */
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/multilabelsegmentation.svg b/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/multilabelsegmentation-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/multilabelsegmentation.svg
rename to Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/multilabelsegmentation-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/multilabelsegmentation.png b/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/multilabelsegmentation.png
deleted file mode 100644
index b5c3bd21ff..0000000000
Binary files a/Plugins/org.mitk.gui.qt.multilabelsegmentation/documentation/UserManual/multilabelsegmentation.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.openigtlink/documentation/UserManual/Manual.dox
deleted file mode 100644
index f063230e77..0000000000
--- a/Plugins/org.mitk.gui.qt.openigtlink/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_mitk_gui_qt_igtlplugin The IGT Plugin
-
-\imageMacro{icon.png,"Icon of Igtlplugin",2.00}
-
-\tableofcontents
-
-\section org_mitk_gui_qt_igtlpluginOverview Overview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.openigtlink/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Plugins/org.mitk.gui.qt.openigtlink/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.openigtlink/documentation/doxygen/modules.dox
deleted file mode 100644
index 7da567195c..0000000000
--- a/Plugins/org.mitk.gui.qt.openigtlink/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mitk_gui_qt_igtlplugin org.mitk.gui.qt.igtlplugin
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mitk_gui_qt_igtlplugin_internal Internal
-  \ingroup org_mitk_gui_qt_igtlplugin
-
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.igtlplugin plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/QmitkOverlayManager.dox b/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/QmitkOverlayManager.dox
index 8520e79ce4..19b6d1489b 100644
--- a/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/QmitkOverlayManager.dox
+++ b/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/QmitkOverlayManager.dox
@@ -1,11 +1,11 @@
 /**
 \page org_mitk_gui_qt_overlaymanager The Overlay Manager Plugin
 
-\imageMacro{icon.png,"Icon of Overlaymanager",2.00}
+\imageMacro{overlaymanager-dox.png,"Icon of Overlaymanager",2.00}
 
 \tableofcontents
 
 \section org_mitk_gui_qt_overlaymanagerOverview Overview
 The OverlayManager plugin allows to view all annotations currently managed. Properties of added annotations can be modified. Additionally it is possible to create some basic overlays and register them.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/icon.png b/Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/overlaymanager-dox.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/icon.png
rename to Plugins/org.mitk.gui.qt.overlaymanager/documentation/UserManual/overlaymanager-dox.png
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/documentation/UserManual/Manual.dox
index ee77922748..4add60b8c5 100644
--- a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/documentation/UserManual/Manual.dox
@@ -1,66 +1,66 @@
 /**
 \page org_mitk_views_photoacoustics_imageprocessing The Photoacoustics Imageprocessing Plugin
 
-\imageMacro{pai.png,"Icon of Imageprocessing",2.00}
+\imageMacro{pai-dox.png,"Icon of Imageprocessing",2.00}
 
 \tableofcontents
 
 \section org_mitk_gui_qt_photoacoustics_imageprocessingOverview Overview
 This plugin offers an interface to perform image processing on photoacoustic, as well as ultrasound images, i.e. to use beamforming and post-processing filters. 
 For convenience, image processing can be done automatically for a whole batch of files containing PA or US data.
 
 \section org_mitk_gui_qt_photoacoustics_imageprocessingPrerequisites  Prerequisites
 To use the much more performant openCL filters which run on the graphics card, MITK has to be able to use openCL, for which it is necessary to install the openCL implementation provided by your graphics card vendor.
 
 \section org_mitk_gui_qt_photoacoustics_imageprocessingFiltering Using the filters
 To perform image processing, simply load an image into MITK and select it in the Data manager. Only the selected image will be processed by the filters.
 \imageMacro{QmikPhotoacousticsImageProcessing_DataManager.png,"Select the image to be processed",7.62}
 Before performing reconstruction or using other filters those can be configured using the plugin's settings panel.
 \imageMacro{QmikPhotoacousticsImageProcessing_Settings.png,"The plugin's GUI",7.62}
 
 \subsection org_mitk_gui_qt_photoacoustics_imageprocessingImageDetails Image Details
 To create the .nrrd images necessary for the plugin from raw data, one can use e.g. <a href="https://github.com/mhe/pynrrd">pynrrd</a>, a python package for very straightforward creation of .nrrd images.
 The Beamforming Filter is also able to read certain paramters, as the scan depth and the transducer pitch from the selected image. To this end, the image must have a time-axis spacing in µs and a horizontal spacing in mm.
 
 \subsection org_mitk_gui_qt_photoacoustics_imageprocessingBeamforming The Beamforming Settings
 For beamforming, three beamforming algorithms are available:
 <ul>
 <li>DAS (Delay And Sum)
 <li>DMAS (Delay Multiply And Sum)
 <li>sDMAS (signed Delay Multiply And Sum)
 </ul>
 Each of those can be coupled with either spherical delay calculation or a quadratic approximation for the delays. To supress noise, one of the following apodizations can be chosen to be used when beamforming:
 <ul>
 <li>Box (No apodization)
 <li>Hamming
 <li>Von Hann
 </ul>
 Other Standard beamforming parameters are available, which have to be chosen depending on the source image to attain a correctly reconstructed image.
 As mentioned above, Plugin is able to calculate the used scan depth as well as the transducer pitch from the selected image if the time-axis spacing is in microseconds, and the horizontal spacing in mm. If such a spacing is given, 
 check the box "Auto Get Depth" to make the plugin read those values by itself.
 If the US source or the laser used for imaging is not located at the top of the image, an option is given to cut off pixels at the top of the image until the source. This value should be calibrated by the user 
 to match the used hardware.
 If one wishes to beamform only certain slices of a given image, those can be selected by checking "select slices" and setting the "min" and "max" values accordingly, which are to be understood as closed interval boundaries.
 
 \subsection org_mitk_gui_qt_photoacoustics_imageprocessingBandpass The Bandpass Settings
 The bandpass uses an itk implementation of an 1D Fast Fourier Transform (FFT) to transform the image vertically, then filters the image using a Tukey window in the frequency domain and performs an inverse 1D FFT to get the filtered image.
 The "smoothness" of the tukey window can be chosen by using the "Tukey window alpha" parameter. The Tukey window interpolates between a Box window (alpha = 0) and a Von Hann window (alpha = 1).
 The filtered frequencies can be set by defining the High and Low pass frequencies.
 
 \subsection org_mitk_gui_qt_photoacoustics_imageprocessingCrop The Crop Filter Settings
 The crop filter cuts off parts of the image at the top and the bottom. The amount of pixels cut off can be configured using the "Cut Top" and "Cut Bottom" parameters.
 
 \subsection org_mitk_gui_qt_photoacoustics_imageprocessingBMode The BMode Filter Settings
 The B-mode filters available are:
 <ul>
 <li>An absolute filter
 <li>An envelope detection filter
 </ul>
 If desired, the filter can also resample the image to a given spacing; to do this, check the "Do Resampling" box and set the desired spacing in mm.
 Afterwards a logarithmic filter can be applied, if "Add Logfilter" is checked.
 
 \subsection org_mitk_gui_qt_photoacoustics_imageprocessingBatch Batch Processing
 When processing large amounts of data, an option is available to automatically process multiple images by applying all filters in order to those images and saving the resulting images. 
 In the first row of the Batch Processing Panel one can select which filters should be applied to the image; in the second row one can select whether the resulting image from the filter should be saved.
 After pressing the "Start Batch Processing" button, one can choose first the images to be processed, and then the folder where they will be saved.
 */
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/documentation/UserManual/pai.png b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/documentation/UserManual/pai-dox.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/documentation/UserManual/pai.png
rename to Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/documentation/UserManual/pai-dox.png
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/files.cmake b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/files.cmake
index e4fe8ebf7d..4b9c855389 100644
--- a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/files.cmake
+++ b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/files.cmake
@@ -1,37 +1,36 @@
 set(SRC_CPP_FILES
 
 )
 
 set(INTERNAL_CPP_FILES
   org_mitk_gui_qt_photoacoustics_imageprocessing_Activator.cpp
   PAImageProcessing.cpp
 )
 
 set(UI_FILES
   src/internal/PAImageProcessingControls.ui
 )
 
 set(MOC_H_FILES
   src/internal/org_mitk_gui_qt_photoacoustics_imageprocessing_Activator.h
   src/internal/PAImageProcessing.h
 )
 
 set(CACHED_RESOURCE_FILES
   resources/pai.svg
-  resources/photoacousticsIcon.png
   plugin.xml
 )
 
 set(QRC_FILES
 
 )
 
 set(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/resources/pai.png b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/resources/pai.png
deleted file mode 100644
index 1b8dc34c11..0000000000
Binary files a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/resources/pai.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/resources/photoacousticsIcon.png b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/resources/photoacousticsIcon.png
deleted file mode 100644
index 8c0e9f9c88..0000000000
Binary files a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/resources/photoacousticsIcon.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/UserManual/Manual.dox
deleted file mode 100644
index 4497cf1a23..0000000000
--- a/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_mitk_gui_qt_photoacoustics_pausmotioncompensation The Pausmotioncompensation
-
-\imageMacro{icon.png,"Icon of Pausmotioncompensation",2.00}
-
-\tableofcontents
-
-\section org_mitk_gui_qt_photoacoustics_pausmotioncompensationOverview Overview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/doxygen/modules.dox
deleted file mode 100644
index a8a13b7f31..0000000000
--- a/Plugins/org.mitk.gui.qt.photoacoustics.pausmotioncompensation/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mitk_gui_qt_photoacoustics_pausmotioncompensation org.mitk.gui.qt.photoacoustics.pausmotioncompensation
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mitk_gui_qt_photoacoustics_pausmotioncompensation_internal Internal
-  \ingroup org_mitk_gui_qt_photoacoustics_pausmotioncompensation
-
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.photoacoustics.pausmotioncompensation plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/documentation/UserManual/Manual.dox
index 177ecacda1..f0c5887d21 100644
--- a/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/documentation/UserManual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/documentation/UserManual/Manual.dox
@@ -1,37 +1,32 @@
 /**
 \page org_mitk_gui_qt_photoacoustics_spectralunmixing The spectral unmixing (SU) plugin
 
-\imageMacro{icon.png,"Icon of Spectralunmixing",2.00}
+\imageMacro{photoacoustics_spectralunmixing-dox.png,"Icon of Spectralunmixing",2.00}
 
-\table of contents
-<ul>
-<li> Introduction
-<li> Overview
-<li> How to add an additional algorithm
-</ul>
+\tableofcontents
 
 \section org_mitk_gui_qt_photoacoustics_spectralunmixingIntroduction
 The spectral unmixing plugin provides a GUI tool to perform spectral unmixing of multispectral MITK images. It was designed to unmix beamformed photoacoustic images. The outputs are MITK images for every chosen absorber (endmember). Furthermore it is possible to calculate the oxygen saturation of the multispectral input if the endmembers oxy- and deoxyhemoglobin are selected in the GUI as well as an output image that contains the information about the relative error between unmixing result and the input image.
 Detailed information about the Plugin, the baseclass and its subclasses can be found in their header files. If you want to call the SU filter from your own class have a look at the “mitkSpectralUnmixingTest.cpp”. There you find information about which functions are callable or have to be called from your class to guarantee the promised functionality of the SU filter.
 
 \section org_mitk_gui_qt_photoacoustics_spectralunmixingOverview
 <ul>
 <li> supports several linear Eigen solvers collected in the “mitkPALinearSpectralUnmixingFilter”
 <li> supports several linear Vigra solvers collected in the “mitkPASpectralUnmixingVigraFilter”
 <li> calculates oxygen saturation with the “mitkPASpectralUnmixingSO2”
 </ul>
 
 \section How to add an additional algorithm:
 If the algorithm fits in one of the existing classes you can ignore steps 0. – 3.
 0. Have a look at the commit rMITK36cfd1731089: implement three empty classes for Simplex, Lagrange and Vigra SU algorithms. Which actually are exactly the first (not all!) steps to implement a new algorithm.
 1. Add your future header and cpp file to files.cmake
-2. Create a header file which needs at least the methods shown in header.png
-\imageMacro{header.png,"empty header for a new SU algorithm",2.00}
-3. Create a cpp file which takes an Eigen endmember matrix and an Eigen input vector as inputs and returns an Eigen vector as result. A structure like in the cpp.png is recommended. If your class will consist of more than one algorithm you should have an if/else decision between them with an enum like in the cpp.png otherwise you can directly return your result.
-\imageMacro{cpp.png,"example cpp file for a new SU algorithm",2.00}
-4. In the Plugin you just have to add another “else if” like in the plugin.png. The string in the else if has to be the same then selectable in the GUI(step 5).
-\imageMacro{plugin.png,"changes of Plugin for a new SU algorithm",2.00}
-5. To make you algorithm selectable you have to add to the GUI Combobox. Klick at 1. (GUI.png), then at 2. and then name your algorithm 3. like in step 4.
-\imageMacro{GUI.png,"changes of GUI for a new SU algorithm",2.00}
+2. Create a header file which needs at least the methods shown in header.PNG
+\imageMacro{header.PNG,"empty header for a new SU algorithm",2.00}
+3. Create a cpp file which takes an Eigen endmember matrix and an Eigen input vector as inputs and returns an Eigen vector as result. A structure like in the cpp.PNG is recommended. If your class will consist of more than one algorithm you should have an if/else decision between them with an enum like in the cpp.PNG otherwise you can directly return your result.
+\imageMacro{cpp.PNG,"example cpp file for a new SU algorithm",2.00}
+4. In the Plugin you just have to add another “else if” like in the plugin.PNG. The string in the else if has to be the same then selectable in the GUI(step 5).
+\imageMacro{plugin.PNG,"changes of Plugin for a new SU algorithm",2.00}
+5. To make you algorithm selectable you have to add to the GUI Combobox. Klick at 1. (GUI.PNG), then at 2. and then name your algorithm 3. like in step 4.
+\imageMacro{GUI.PNG,"changes of GUI for a new SU algorithm",2.00}
 
 */
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/documentation/UserManual/icon.png b/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/documentation/UserManual/photoacoustics_spectralunmixing-dox.png
similarity index 100%
rename from Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/documentation/UserManual/icon.png
rename to Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/documentation/UserManual/photoacoustics_spectralunmixing-dox.png
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteraction.dox b/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteraction.dox
index 8145e8f5d4..a52cb52ad6 100644
--- a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteraction.dox
+++ b/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteraction.dox
@@ -1,59 +1,59 @@
 /**
 \page org_mitk_views_pointsetinteraction The Point Set Interaction
 
-\imageMacro{pointset_interaction.svg,"Icon of the Point Set Interaction View",2.00}
+\imageMacro{pointset_interaction-dox.svg,"Icon of the Point Set Interaction View",2.00}
 
 <h1>Overview</h1>
 
 This view allows you to define multiple sets of points, to fill them with points and to save them in so called PointSets.
 
 \imageMacro{QmitkPointSetInteraction_Screenshot.png,"PointSet Annotations in MITK",16.00}
 
 This document will tell you how to use this view, but it is assumed that you already know how to navigate through the slices of an image using the
 four window view. Please read the application manual for more information.
 
 <h1>Usage</h1>
 
 
 <h2>Create new PointSet</h2>
 
 First of all you have to select a PointSet to use this view. You can either select an existing PointSet in the data manager or you can create a new one. This is done by clicking the 'Add pointset...' button.
 
 \imageMacro{QmitkPointSetInteraction_AddPointSet.png,"The Add pointset... dialog",8.64}
 
 In the pop-up dialog, you have to specify a name for the new PointSet. Afterwards, it appears as a new node in the data manager.
 
 
 <h2>Add new points </h2>
 
 To set points you have to toggle the 'Set Points'  button (<b>+</b>), the leftmost of the seven buttons on the bottom of the view.
 Points can be defined by performing a left mouse button click while holding the 'Shift'-key pressed in the four window view.
 Alternatively, you can set a new point by pressing the button next to the left most button (<b>+ xyz</b>) and adding a new point location directly.
 
 The 'Current pointset' area contains a list of all points in the current PointSet node with index and position.
 
 \imageMacro{QmitkPointSetInteraction_CurrentPointSetArea.png,"PointSet Interaction View",6.52}
 
 
 <h2>Remove points </h2>
 
 To erase a point from the list press either the third button or the delete key on your keyboard.
 
 <h2>Modify point position</h2>
 
 By using the 'up' and 'down' arrow buttons, the index location of a point in the PointSet can be altered.
 
 
 <h2>Save and load a PointSet</h2>
 
 With the two last buttons PointSets can be saved and loaded.
 With the 'save' button, the entire PointSet can be saved to the harddrive. The user is prompted to select a filename.
 PointSets are saved in XML fileformat but have to have a '.mps' file extension. A previously saved PointSet can be loaded and all of its points appear in the list and the four window view as well as a node in the data manager.
 
 
 <h2>Modify points</h2>
 
 You can select a single point in the render window, if the 'Set Points' button is toggled. If you keep the mouse button pressed, you can move the points by moving the mouse and then releasing the mouse button. With the delete key you can remove the selected points.
 
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteraction_Icon.png b/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteraction_Icon.png
deleted file mode 100644
index c3d1d306ca..0000000000
Binary files a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/QmitkPointSetInteraction_Icon.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/pointset_interaction.svg b/Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/pointset_interaction-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/pointset_interaction.svg
rename to Plugins/org.mitk.gui.qt.pointsetinteraction/documentation/UserManual/pointset_interaction-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/UserManual/Manual.dox
deleted file mode 100644
index d9fee1b600..0000000000
--- a/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_mitk_gui_qt_pointsetinteractionmultispectrum The Point Set Interaction Multispectrum
-
-\imageMacro{icon.png,"Icon of Pointsetinteractionmultispectrum",2.00}
-
-\tableofcontents
-
-\section org_mitk_gui_qt_pointsetinteractionmultispectrumOverview Overview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/doxygen/modules.dox
deleted file mode 100644
index 6f341778a0..0000000000
--- a/Plugins/org.mitk.gui.qt.pointsetinteractionmultispectrum/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mitk_gui_qt_pointsetinteractionmultispectrum org.mitk.gui.qt.pointsetinteractionmultispectrum
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mitk_gui_qt_pointsetinteractionmultispectrum_internal Internal
-  \ingroup org_mitk_gui_qt_pointsetinteractionmultispectrum
-
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.pointsetinteractionmultispectrum plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.properties/documentation/UserManual/PropertiesView.dox b/Plugins/org.mitk.gui.qt.properties/documentation/UserManual/PropertiesView.dox
index 2b4644144a..2450b2f9c7 100644
--- a/Plugins/org.mitk.gui.qt.properties/documentation/UserManual/PropertiesView.dox
+++ b/Plugins/org.mitk.gui.qt.properties/documentation/UserManual/PropertiesView.dox
@@ -1,57 +1,57 @@
 /**
-\page org_mitk_views_properties The Properties
+\page org_mitk_views_properties The Properties View
 
-\imageMacro{icon.svg,"Icon of the Properties View.",2.00}
+\imageMacro{properties-dox.svg,"Icon of the Properties View.",2.00}
 
 \tableofcontents
 
 \section org_mitk_views_propertiesOverview Overview
 
 The Properties View allows you to inspect and change properties of a selected data node and its attached data.
 This View is only for advanced users and developers, as it is easy to alter the program state in unexpected ways.
 It can be considered as a complete exposure of parts of the backend that are usually supposed to be accessed only through dedicated frontend components like the color or opacity widgets in the context menu of a data node in the Data Manager View.
 
 \section org_mitk_views_propertiesUsage Usage
 
 \imageMacro{view.png,"The Properties View.",12.00}
 
 \subsection org_mitk_views_propertiesUsagePropertyListTypes Property list types
 
 After you selected a data node, the Property View allows you to switch between several property lists that are attached to the selected data node and its actual data.
 By default, you see the common data node property list.
 
 There are two types of property lists: data node property lists and data property lists.
 
 Data node property lists consist of properties that the application attaches mainly for rendering settings.
 They are not intrinsically part of the actual data and are only persisted when saving the MITK scene as a whole.
 A typical example of such a property is "visible", which decides if the data should be rendered or hidden.
 
 The common data node property list is applied to all render windows but there are also render window specific data node property lists.
 Any property that is found in both the common list and a render window specific list is overriden by the latter one.
 For example, if you want to hide an image only in the 3d render window but show it in all other render windows, you check "visible" in the common list, add the same property to the 3d render window specific list, and uncheck it there.
 
 There is only a single data property list.
 It represents the true metadata of the selected data like DICOM tags of a DICOM image.
 When saving specific data, most data properties are written to the data file, as long as the selected file format supports metadata.
 A popular example is the NRRD image format that allows to save custom key value pairs in text format in the file header.
 Not all data properties are meant for persistence, though.
 To check if a certain data property will be written to a metadata-enabled file format, click on it in the properties tree view and check if there is a save icon at the bottom in the additional property info box.
 
 \subsection org_mitk_views_propertiesUsageFilter Filter
 
 Property lists can be quite large and complex, shown as a tree structure in the Properties View.
 To quickly find properties of interest you can use the filter text box, which will filter the properties while you type.
 
 \subsection org_mitk_views_propertiesUsageEditProperties Edit properties
 
 Most property value types like numbers, strings, boolean values, or colors can be edited by either clicking or double-clicking in the Value column.
 For example, to edit color properties, double-click on the colored Value cell.
 You can either enter a color by name like "yellow", in hex notation like "#ffff00" (or abbreviated "#ff0"), or click on the "..." button to open a color picker dialog.
 
 \subsection org_mitk_views_propertiesUsagePropertyInfos Additional property information
 
 Some properties have additional information attached like a description, aliases, or a persistence flag.
 This information is shown at the bottom of the Properties View.
 When no additional information is available, the additional property info box is hidden.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.properties/documentation/UserManual/icon.svg b/Plugins/org.mitk.gui.qt.properties/documentation/UserManual/properties-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.properties/documentation/UserManual/icon.svg
rename to Plugins/org.mitk.gui.qt.properties/documentation/UserManual/properties-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/QmitkRadiomicsArithmetricView.dox b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/QmitkRadiomicsArithmetricView.dox
index edd1426650..fb56062e54 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/QmitkRadiomicsArithmetricView.dox
+++ b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/QmitkRadiomicsArithmetricView.dox
@@ -1,23 +1,23 @@
 /**
 \page org_mitk_views_radiomicsarithmetricview Image Arithmetrics
 
 Allows to perform basic arithmetic operations with all images. By default, the resulting image will be of the same type as the first input image. This also means that all operations will be perfomed using the same datatype as the input image. This can lead to rounding errors if an integer data type is used. It is possible to avoid this problem by creating a double-based image as result image by selecting the corresponding option. 
 
 There are three different types of operations: 
 \li Single Image Operations: These are operations that are performed on each voxel value and do not need any additional parameter. Typical operations are calculating the absolute value of an image, or calculating an trigometric value. 
 \li Single Image Operations: These are operations that are performed on each voxel value and do not need any additional parameter. Typical operations are calculating the absolute value of an image, or calculating an trigometric value. 
 \li Single Image and Double Value Operation: These are the basic mathematical operations (add, subtract, multiply, and dividive). 
 \li Two Images Operations: Allows to perfom basic operations between two images. 
 
-\subsection IA_SingleImageOperations Single Image Operations
+\section IA_SingleImageOperations Single Image Operations
 Allows to perfom a arithmetic operation to each voxel of an image independently. Be aware that some operations expect a specific input range. This range is usually not tested for, and it might cause an error if the range if values outside of the expceted range occure. Also, some operations are rather expensive with respect to the calculation time and take some time to finish. 
 
-\subsection IA_SingleImageAndDoubleValue Single Image and Double Value Operation
+\section IA_SingleImageAndDoubleValue Single Image and Double Value Operation
 Performs a basic mathematical operation (add, subtract, multiply, and divide) between an image and a floating point value. The operation is execuded for each voxel independently. There are two options if the order of the input is relevant (i.e. for subtraction and division) to enable both ways. 
 
-\subsection IA_TwoImages Two Image Operations
+\section IA_TwoImages Two Image Operations
 This allows to perfom mathematical operations between two images. The second image needs to be specified within this panel. Both images must match in size, it is also assumed (but not checked) that both images share the same geometry. This means that the corresponding voxels of both images share the same geometrical space. 
 
 The first image, that would also be used for other operations, is used as "Image", while the image specified in the panel is used as "Second Image". In general, the first image is also used as first parameter in the mathematical operation. 
 
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_01_Basic.dox b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_01_Basic.dox
index c07b77e924..8955702e42 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_01_Basic.dox
+++ b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_01_Basic.dox
@@ -1,30 +1,27 @@
 /**
 \page org_mitk_views_radiomicstutorial_gui_01_basic GUI based Radiomics Tutorial - Basic handling of MITK 
 
-\subsection Basic handling of MITK 
+\section Basic handling of MITK 
 
 Open a MITK Workbench which also includes MITK Phenotyping. You should see something similar to figure 1. At the top you'll see a bar (1), (2) with different important operations like open and saving data, different important views (like DICOM Window, Image Navigator and View Navigator), and a list of all Views included in your version (2). Items are grouped, and depending on the width of your screen might be hidden behind small arrows. 
 
 The Data Manager (3) is usually placed at the left, although it could be also open at other positions. It is used to organize open images and other data items. Below it you see the Image Navigator (4) which helps to navigate through the 3D data. It allows to change the position within the data either in real-world coordinates (in mm) or by specifiying a slice number. 
 
 In the center of your application you should see the Displays (5), which will display the images. It usually consists of four views, showing axial, sagittal, coronal and a 3D view of the data. It is possible to rearange the single displays and configure them to your wishes with the three small buttons which will become visible if the mouse is in the upper right corner of display. 
 
 Beside these elements, there are various open views (6). You can close them with the cross and reopen them using the bar at the top (2). It is also possible to rearrange all Views to various positions left, right, above, or below the displays. 
 
 An important view is the "View Navigator". In figure 1 it is hidden behind the Data Manager (3) and could be made visible with a click on the corresponding bar left of the "Data Manager" bar. The View Navigator is an easy and straight forward tool to show all available views and open them. It allows to search through all views. Offering a search function it allows to find views using their name of just searching for a functionality you are looking for. 
 
 \imageMacro{RadiomicsTutorial_GUI_Step1_01_Overview.png,"Overview of MITK Workbench with active MITK Phenotyping",1}
 
-\subsection Loading image data
+\section Loading image data
 In order to calculate the radiomics features using the graphical interface you first need to load the data into the graphical environment. This can be done in different ways. If you want to load an DICOM series, it is sufficient to load a single image if the other images of the series are within the same folder. MITK will then combine all Series DICOM Images to a single 3D Image. 
 
 \li Open an Image using the "Open File" menu item: If you click on the "Open File" item in the "File" menu or the "Open File" button in the top bar you will be presented a standard file dialog of your system. Select the image you want to load and click "Open". 
 
 \li Drag n' Drop: Select the image you want to load with your standard data managing tool, for example with the explorer on windows or finder on Mac. Drag and drop the file into the open MITK Workbench window, the image will then be loaded if possible. If you 
 
 \li DICOM Browser: MITK offers the basic possibiliy to manage and handle DICOM images using the DICOM Browser. You can enable this view by clicking on "DICOM", right of the "Redo"-Button. Within the DICOM Browser, it is possible to read complete folders, and load specific series into the workbench. For more information see \ref org_mitk_gui_qt_dicombrowser .
 
-
-
-
 */
diff --git a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_02_Segmenting.dox b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_02_Segmenting.dox
index ac82cd942d..33ebf61e73 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_02_Segmenting.dox
+++ b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_02_Segmenting.dox
@@ -1,19 +1,18 @@
 /**
 \page org_mitk_views_radiomicstutorial_gui_02_Segmentation GUI based Radiomics Tutorial - Creating a basic Segmentation
 
+\section Creating a basic Segmentation
 
-\subsection Creating a basic Segmentation
 The first step is to create a new segmentation that can be used to calculate radiomics features. You might skip this step if you already have an segmentation at hand. Ti For this, we load the image we want to process and open the segmentation view. The easiest way to do this is to open the "View Navigator" and search for segmentation. The Segmentation view can then be opened by simply double-clicking on the view in the "View Navigator". 
 
 With this view, we will create an One-Level segmentation. It would also be possible to create a multi-label segmentation where more than one structure can be segmented using the MultiLabel segmentation. Howerver, MITK Phenotyping is currently only supporting one Label per mask, so there would be no benefit in doing so. In addition, the created segmentation could be extended further if needed. 
 
-\imageMacro{RadiomicsTutorial_GUI_Step2_01_Preparation.png,"MITK Workbench with open Segmentation View and loaded image. If you want to have the same view, you can go to the position indicated by the 'Image Navigator'",1}
+\imageMacro{RadiomicsTutorial_GUI_Step2_01_Preparation.png,"Segmentation View and loaded image in the MITK Workbench. Go to the position indicated in the Image Navigator for the same view.",1}
 
 To now create a segmentation, we press the "New"-Button in the Data Selection part of the "Segmentation"-View. After giving the segmentation a name and probably selecting a new color if red isn't what we want, we can see a new image in the "Data Manager", the segmentation image. The segmentation can now be edited using the segmentation tools, either slice-by-slice wise or the whole 3D volume using one of the 3D tools. A good description of the different tools and their implication can be found a \ref org_mitk_views_segmentation . The different modes and options are also described there. 
 
 We create a simple segmentation of a rib in a few slices, as indiciated by the following picture. At this point, we suggest that you play around to get used to the segmentation tool and then try to roughly reproduce our results. It is not necessary to obtain a one-to-one solution of our segmentation. 
 
 \imageMacro{RadiomicsTutorial_GUI_Step2_02_StartSegmentation.png,"Basic segmentation of a rib we created in 6 slices. The color of the segmentation is changed to orange for bone.",1}
 
-
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_03_Preprocessing.dox b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_03_Preprocessing.dox
index 33b6af06c5..d715dcd58d 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_03_Preprocessing.dox
+++ b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_03_Preprocessing.dox
@@ -1,23 +1,21 @@
 /**
 \page org_mitk_views_radiomicstutorial_gui_03_preprocessing GUI based Radiomics Tutorial - Preprocessing the data
 
-\subsection Preprocessing the data
+\section Preprocessing the data
 The first step we take is to resample the data. To do so, we open the "Radiomics Transformation" View and select the "Resample Image" panel. We start by resampling the original image and therefore select the original picture (for us, Pic3D). Right-clicking on the image in the "Data Manager" and selecting the option "Details" gives us more information on the image. As we can see, our image has a spacing of [1, 1, 3], with an inplane resolution of 1x1mm and a out-of-plane resolution of 3 mm. We therefore decide to resample the image to an isotropic resolution of 1x1x1 mm.
 
 \imageMacro{RadiomicsTutorial_GUI_Step3_01_DetailView.png,"Details showing the spacing of the original image.",1} 
 
 To resample the image, we de-select "Dimension X" and "Dimension Y" option and set the "Dimension Z" option to 1, as indiciated by the image above. This tells the resampling algorithm to change only the last dimension to the value we specified. We further select to have the output image as double and chose B-Spline as resampling algorithm. This is a fast and still accurate option for resampling. To learn more about the other interpolation modes, refer to \ref org_mitk_views_matchpoint_mapper .
 
 After resampling the original image, we also need to resample the segmentation. For this, we select the segmentation, leave the dimensions unchanged. Remove the "Output as double" option, as segmentations are not double values and choose a linear interpolation, which seems to be a better solution for resampling masks. We also check the option that we are resampling a mask. 
 
 After performing those two steps, there should be two additional, resampled images in the "Data Manager". 
 
 As a second step, we calculate some Laplacian of Gaussian images of the resampled image that allow us to capture more detailed information. For this, we select the panel "Laplacian of Gaussian" of the "Radiomics Transformation"-view and perform the algorithm three times with different sigma values (we chose 1,2, and 4). Make sure that you selected the right image to calculate the image, i.e. the resampled image. 
 
 Finally, we clear the mask to obtain a clear segmentation of the target structure and remove possible resampling artifacts. To do so, we open the "Radiomics Mask Processing" View and select the resampled image and the resampled mask. We then select a lower limit only and set it to 160. Since we are working with MR, this is not a fixed value but something we manually determined. With this set, we perform the mask reducing by cklicking "Clean Mask based on Intervall". After this, we have the resampled image, three LoG images and a resampled and cleaned mask. The result should look similar to the next picture. You can also see the final image structure we obtained from our processing. It might help you to compare your results, although it is not necessary to obtain the same structure as long as you have all necessary images. 
 
 \imageMacro{RadiomicsTutorial_GUI_Step3_02_FinishedPreprocessing.png,"Final results with a completed resampling",1} 
 
-
-
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_04_FeatureCalculating.dox b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_04_FeatureCalculating.dox
index 82077815fa..2ac32167bb 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_04_FeatureCalculating.dox
+++ b/Plugins/org.mitk.gui.qt.radiomics/documentation/doxygen/tutorial_gui/RadiomicsTutorial_GUI_04_FeatureCalculating.dox
@@ -1,44 +1,41 @@
 /**
 \page org_mitk_views_radiomicstutorial_gui_04_featurecalulation GUI based Radiomics Tutorial - Calculating the Radiomics Features
 
-\subsection Calculating the Radiomics Features
+\section Calculating the Radiomics Features
 The most important step of a radiomic study is the calculating of the features. With MITK Phenotyping this is done using the "Radiomics Statistic" View. Open it using the View Navigator. Within this view, we select the resampled image and the resampled and cleaned mask. In a first step, we select the features we aim to calculate. For this tutorial we chose four features:
 \li Volumetric Features
 \li First Order Numerics
 \li Intensity Volume Histogram
 \li Co-occurence Based Features
 
 After selecting the features, we need to configure the features. We start with the "Intenstiy Volume Histogram" Features. Because this Feature class makes an uncommon use of the internal histogram, it makes sense to set the histogram parameter for this feature individually. To do so, click on the "+" next to the feature class name. You should see a list of feature specific parameter. Activate the following parameter and set them to the given parameter: 
 \li ivoh::minimum 159.5
 \li ivoh::maximum 900.5
 \li ivoh::binsize 1.0
 This configures a histogram that starts from 160 and ranges to 900 with a binsize of 1. Since the minimum and maximum parameter specify the borders of the histogram, we added /subtracted the half of the binsize, so that the middle of the bins will be on a integer. 
 
 After this step switch to the "Configuration Parameter" panel. Select the default parameters for the histogram: 
 \li Minimum Intensity 160
 \li Maximum Intensity 900
 \li Number of Bins 32
 You will recognize that we chose a quite different setting for the histogram this time. Instead of the histogram binsize, we selected the number of bins. Don't forget to activate the features. 
 
 As we will calculate multiple features, also activate the "Encode Parameter in Name" option. After this, you can enable the feature calculation by pressing "Execute". You should see the results of the feature calculation process in the table below the configuration list. 
 
 We will now calculate the Co-occurence based feature with a different number of bins. For this, change the "Number of Bins" to 64, and deselect all features except the "Co-occurence based Features". In order to keep the previous results, execute the algorithm this time using the button "Execute & Append". The results will be appended to the results shown at the table in the bottom. 
 
 Now select a different image and repeat the calculation of the Co-occurence feature with a bin number of 64. Then reselect the "First Order Numberics" and "Intensity Volume Histogram" again and set the number of Bins back to 32. You don't need to recalculate "Volumetric Features" as these features are based on the shape and therefore won't change if only the image is changed. 
 
 You will now have a long list of features. To further process these features, press the "Table to Clipboard" button. You can now paste the results in your favourit editor or statistic program and perfom the analysis of the radiomic study. 
 
 To give you some ideas how the results look like, here are some results from our experiment. If you used the same image and made a similar mask, you should obtain similar results, although small differences might be based on variations of the segmentation:
-\li Pic3D__Resampled;Bone__Resampled__MaskRange;Co-occurenced Based Features::Min-160_Max-900_Bins-64_Range-1::Mean Sum Average;52.5338
-\li Pic3D__Resampled;Bone__Resampled__MaskRange;Co-occurenced Based Features::Min-160_Max-900_Bins-32_Range-1::Mean Sum Average;26.7659
-\li Pic3D__Resampled__LoG__Sigma-1;Bone__Resampled__MaskRange;Co-occurenced Based Features::Min-160_Max-900_Bins-64_Range-1::Overall Sum Average;2
-\li Pic3D__Resampled__LoG__Sigma-1;Bone__Resampled__MaskRange;Co-occurenced Based Features::Min-160_Max-900_Bins-32_Range-1::Overall Sum Average;2
-\li Pic3D__Resampled;Bone__Resampled__MaskRange;First Order Numeric::Min-160_Max-900_Bins-32::Mean;420.761
-\li Pic3D__Resampled__LoG__Sigma-1;Bone__Resampled__MaskRange;First Order Numeric::Min-160_Max-900_Bins-32::Mean;-137.746
+\li Pic3D__Resampled;Bone__Resampled__MaskRange;Co-occurenced Based Features::Min-160_Max-900_Bins-64_Range-1::%Mean Sum Average;52.5338
+\li Pic3D__Resampled;Bone__Resampled__MaskRange;Co-occurenced Based Features::Min-160_Max-900_Bins-32_Range-1::%Mean Sum Average;26.7659
+\li Pic3D__Resampled__LoG__Sigma-1;Bone__Resampled__MaskRange;Co-occurenced Based Features::Min-160_Max-900_Bins-64_Range-1::%Overall Sum Average;2
+\li Pic3D__Resampled__LoG__Sigma-1;Bone__Resampled__MaskRange;Co-occurenced Based Features::Min-160_Max-900_Bins-32_Range-1::%Overall Sum Average;2
+\li Pic3D__Resampled;Bone__Resampled__MaskRange;First Order Numeric::Min-160_Max-900_Bins-32::%Mean;420.761
+\li Pic3D__Resampled__LoG__Sigma-1;Bone__Resampled__MaskRange;First Order Numeric::Min-160_Max-900_Bins-32::%Mean;-137.746
 
 You can see that the parameters used as well as image used have a clear impact on the final features. You can also see how the name of the image, the mask, and the parameters are encoded so that you are able to reproduce how the results were obtained.
 
-
-
-
 */
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.remeshing/documentation/UserManual/QmitkRemeshing.dox b/Plugins/org.mitk.gui.qt.remeshing/documentation/UserManual/QmitkRemeshing.dox
index 884f46b296..32ba21171f 100644
--- a/Plugins/org.mitk.gui.qt.remeshing/documentation/UserManual/QmitkRemeshing.dox
+++ b/Plugins/org.mitk.gui.qt.remeshing/documentation/UserManual/QmitkRemeshing.dox
@@ -1,19 +1,19 @@
 /**
-\page org_mitk_views_remeshing The Remeshing
+\page org_mitk_views_remeshing The Remeshing View
 
 \imageMacro{RemeshingIcon.png,"Icon of the Remeshing Plugin.",2.00}
 
 \tableofcontents
 
 \section org_mitk_views_remeshingOverview Overview
 
 The Remeshing View allows you to remesh surfaces.
 If done right, remeshing can dramatically increase the quality of your surface mesh.
 However, you might lose precision if you reduce the vertex density of your surface mesh too strong.
 Even when you preserve the detail of your mesh, there might be a tiny distance between your original surface and the remeshed surface.
 Hence, be careful when using remeshed surfaces for evaluation purposes and always keep the original versions.
 
 \section org_mitk_views_remeshingUsage Usage
 
 The Remeshing View provides details on its parameters in its user interface. When in doubt, start with the default parameters and iterate to your desired result by reducing the density parameter.
 */
diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/UserManual/Manual.dox
deleted file mode 100644
index 62b08443be..0000000000
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_mitk_gui_qt_renderwindowmanager The Renderwindowmanager
-
-\imageMacro{icon.png,"Icon of Renderwindowmanager",2.00}
-
-\tableofcontents
-
-\section org_mitk_gui_qt_renderwindowmanagerOverview Overview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/doxygen/modules.dox
deleted file mode 100644
index be02fac9a8..0000000000
--- a/Plugins/org.mitk.gui.qt.renderwindowmanager/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mitk_gui_qt_renderwindowmanager org.mitk.gui.qt.renderwindowmanager
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mitk_gui_qt_renderwindowmanager_internal Internal
-  \ingroup org_mitk_gui_qt_renderwindowmanager
-
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.renderwindowmanager plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
index 771ab561da..ea04956862 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
@@ -1,299 +1,299 @@
 /**
 \page org_mitk_views_segmentation The Segmentation View
 
-\imageMacro{segmentation.svg,"Icon of the segmentation view",2.00}
+\imageMacro{segmentation-dox.svg,"Icon of the segmentation view",2.00}
 
 <i>Some of the features described below are closed source additions to the open source toolkit MITK and are not  available in every application.</i>
 
 \tableofcontents
 
 \section org_mitk_views_segmentationUserManualOverview Overview
 
 Segmentation is the act of partitioning an image into subsets by either manual or automated delineation to create i.e. a distinction between foreground and background.
 The MITK <b>segmentation plugin</b> allows you to create segmentations of anatomical and pathological structures in medical images.
 The plugin consists of a number of views:
 <ul>
   <li> <b>Segmentation View</b>: Manual and (semi-)automatic segmentation
   <li> \subpage org_mitk_views_segmentationutilities : Segmentation post-processing
 </ul>
 In this documentation, the features and usage of the segmentation view will be described.
 For an introduction to the segmentation utilities and clipping plane views, please be referred to the respective documentation pages.
 
 \imageMacro{QmitkSegmentationPlugin_Overview.png,"Segmentation plugin overview", 16.00}
 
 \section org_mitk_views_segmentationPreferences Preferences
 The segmentation plugin offers a number of preferences which can be set via the MITK Workbench application preferences:
 
 \imageMacro{QmitkSegmentationPreferences.png,"Segmentation preferences", 10.00}
 
 <ul>
   <li> <b>Slim view:</b> Allows you to show or hide the tool button description of the segmentation view
   <li> <b>2D display:</b> Specify whether the segmentation is drawn as outline or as a transparent overlay
   <li> <b>3D display:</b> Activate 3D volume rendering for your segmentation
   <li> <b>Data node selection mode:</b> If activated the segmentation image is automatically chosen from the data manager selection.
   <li> <b>Smoothed surface creation:</b> Set certain smoothing parameters for surface creation
 </ul>
 
 
 \section org_mitk_views_segmentationUserManualTechnical Technical Issues
 
 The segmentation plugin makes a number of assumptions:
 <ul>
   <li> Images must be 2D, 3D, or 3D+t.
   <li> Images must be single-values, i.e. CT, MRI or "normal" ultrasound. Images from color doppler or photographic (RGB) images are only partially supported (please be aware that some tools might not be compatible with this image type).
   <li> Segmentations are handled as binary images of the same extent as the original image.
 </ul>
 
 \section org_mitk_views_segmentationUserManualImageSelection Data Selection & Creating New Segmentations
 
 To select a reference image for the segmentation, click on the <i>Patient Image</i> selection widget and choose a suitable image from the selection available in the data manager.
 By default the auto selection mode is enabled (see \ref org_mitk_views_segmentationPreferences).\n
 Once a patient image is selected, a new segmentation can be created on this reference image by clicking the <i>New...</i> button to the right of the <i>Segmentation</i> selection widget.
 An input field will appear which allows you to set the name and display color of the segmentation. Notice that the input field suggests names once you start typing and that it also suggests colors for known organ names.
 Once generated the segmentation will be added with "binary mask" icon to the data manager as sub-node of the reference image. This item is automatically selected for you, allowing you to start editing the new segmentation right away.
 
 
 \subsection org_mitk_views_segmentationUserManualManualKringeling2 Selecting Segmentations for Editing
 Alternatively to creating a new segmentation, an existing one can be edited as well.
 As you might have segmented multiple structures within a single image, the application needs to know which of them to use for editing.
 For that you click the segmentation selection widget and a selection field will open, containing all suitable segmentations for the parent dataset available in the data manager.
 
 
 \section org_mitk_views_segmentationUserManualToolOverview Segmentation Tool Overview
 
 MITK offers a comprehensive set of slice-based 2D and (semi-)automated 3D segmentation tools.
 The manual 2D tools require some user interaction and can only be applied to a single image slice whereas the 3D tools operate on the whole image. The 3D tools usually only
 require a small amount of user interaction, i.e. placing seed points or setting/adjusting parameters.
 You can switch between the different toolsets by selecting the 2D or 3D tab in the segmentation view.
 
 \imageMacro{QmitkSegmentation_ToolOverview.png,"An overview of the existing 2D and 3D tools in MITK.",5.50}
 
 \section org_mitk_views_segmentationUserManualManualKringeling 2D Segmentation Tools
 
 With 2D manual contouring you define which voxels are part of the segmentation and which ones are not. This allows you to create segmentations of any structures of interest in an image.
 You can also use manual contouring to correct segmentations that result from sub-optimal automatic methods.
 The drawback of manual contouring is that you might need to define contours on many 2D slices. However, this is mitigated by the interpolation feature, which will make suggestions for a segmentation.
 
 \subsection org_mitk_views_segmentationUserManualManualKringeling3 Selecting Editing Tools
 
 To start using one of the editing tools, click its button from the displayed toolbox.
 The selected editing tool will be active and its corresponding button will stay pressed until you click the button again.
 Selecting a different tool also deactivates the previous one.\n
 If you have to delineate a lot of images, shortcuts to switch between tools becomes convenient. For that, just hit the first letter of each tool to activate it (A for Add, S for Subtract, etc.).
 
 \subsection org_mitk_views_segmentationUserManualManualKringeling4 Using Editing Tools
 
 All of the editing tools work by the same principle: you use the mouse (left button) to click anywhere in a 2D window (any of the orientations axial, sagittal, or coronal),
 move the mouse while holding the mouse button and release to finish the editing action.
 Multi-step undo and redo is fully supported by all editing tools. Use the application-wide undo button in the toolbar to revert erroneous %actions.
 
 <i>Remark</i>: If you are familiar with the MITK Workbench, you know that clicking and moving the mouse in any of the 2D render windows will move around the crosshair that defines what part of the image is displayed.
 This behavior is disabled whilst any of the manual segmentation tools are active- otherwise you might have a hard time concentrating on the contour you are drawing.
 
 
 \subsection org_mitk_views_segmentationUserManualAddSubtractTools Add and Subtract Tools
 \imageMacro{QmitkSegmentation_IMGIconAddSubtract.png,"Add and Subtract Tools",7.70}
 
 Use the left mouse button to draw a closed contour. When releasing the mouse button, the contour will be added (Add tool) to or removed (Subtract tool) from the current segmentation.
 Adding and subtracting voxels can be iteratively repeated for the same segmentation. Holding CTRL / CMD while drawing will invert the current tool's behavior (i.e. instead of adding voxels, they will be subtracted).
 
 \subsection org_mitk_views_segmentationUserManualPaintWipeTools Paint and Wipe Tools
 \imageMacro{QmitkSegmentation_IMGIconPaintWipe.png,"Paint and Wipe Tools",7.68}
 
 Use the <i>Size</i> slider to change the radius of the round paintbrush tool. Move the mouse in any 2D window and press the left button to draw or erase pixels.
 Holding CTRL / CMD while drawing will invert the current tool's behavior (i.e. instead of painting voxels, they will be wiped).
 
 \subsection org_mitk_views_segmentationUserManualRegionGrowingTool Region Growing Tool
 \imageMacro{QmitkSegmentation_IMGIconRegionGrowing.png,"Region Growing Tool",3.81}
 
 Click at one point in a 2D slice widget to add an image region to the segmentation with the region growing tool.
 Region Growing selects all pixels around the mouse cursor that have a similar gray value as the pixel below the mouse cursor. This enables you to quickly create segmentations of structures that have a good contrast to surrounding tissue.
 The tool operates based on the current level window, so changing the level window to optimize the contrast for the ROI is encouraged.
 Moving the mouse up/down is different from left/right: Moving up the cursor while holding the left mouse button widens the range for the included grey values; moving it down narrows it. Moving the mouse left and right will shift the range.
 The tool will select more or less pixels, corresponding to the changing gray value range.
 
 
 
 
 \if THISISNOTIMPLEMENTEDATTHEMOMENT
 A common issue with region growing is the so called "leakage" which happens when the structure of interest is connected to other pixels, of similar gray values, through a narrow "bridge" at the border of the structure.
 The Region Growing tool comes with a "leakage detection/removal" feature. If leakage happens, you can left-click into the leakage region and the tool will try to automatically remove this region (see illustration below).
 
 \imageMacro{QmitkSegmentation_IMGLeakage.png,"Leakage correction feature of the Region Growing tool",11.28}
 \endif
 
 
 \subsection org_mitk_views_segmentationUserManualCorrectionTool Correction Tool
 <br>
 \imageMacro{QmitkSegmentation_IMGIconCorrection.png,"Correction Tool",3.77}
 
 You do not have to draw a closed contour to use the Correction tool and do not need to switch between the Add and Substract tool to perform
 small corrective changes. The following figure shows the usage of this tool:
 <ul>
 <li> a) If the user draws a line which %starts and ends outside the segmenation a part of it is cut off.
 <li> b) If the line is drawn fully inside the segmentation the marked region is added to the segmentation.
 </ul>
 
 \imageMacro{QmitkSegmentation_IMGCorrectionActions.png,"Usage of the Correction tool.",13.50}
 <br>
 
 \subsection org_mitk_views_segmentationUserManualFillTool Fill Tool
 \imageMacro{QmitkSegmentation_IMGIconFill.png,"Fill Tool",3.81}
 
 Left-click inside a segmentation with holes to completely fill all holes. Left-click inside a hole to fill only this specific hole.
 
 \subsection org_mitk_views_segmentationUserManualEraseTool Erase Tool
 
 \imageMacro{QmitkSegmentation_IMGIconErase.png,"Erase Tool",3.79}
 
 This tool removes a connected part of pixels that form a segmentation. You may use it to remove single segmentations (left-click on specific segmentation) or to clear a whole slice at once (left-click outside a segmentation).
 
 \subsection org_mitk_views_segmentationUserManualLiveWireTool Live Wire Tool
 
 \imageMacro{QmitkSegmentation_IMGIconLiveWire.png,"Live Wire Tool",3.01}
 
 The Live Wire Tool acts as a magnetic lasso with a contour snapping to edges of objects.
 
 \imageMacro{QmitkSegmentation_IMGLiveWireUsage.PNG,"Steps for using the Live Wire Tool",16.00}
 
 <ul>
 <li>(1) To start the tool you have to double-click near the edge of the object you want to segment. The initial anchor point will snap to the edge within a 3x3 region.
 <li>(2) Move the mouse. You don't have trace the edge of the object. The contour will automatically snap to it.
 <li>(3) To fix a segment you can set anchor points by single left mouse button click.
 <li>(4) Go on with moving the mouse and setting anchor points.
 <li>(5) To close the contour double-click on the initial anchor point.
 <li>(6) After closing, the contour can be edited by moving, inserting and deleting anchor points.
 </ul>
 
 The contour will be transferred to its binary image representation by deactivating the tool.
 
 \subsection org_mitk_views_segmentationUserManual2DFastMarchingTool 2D Fast Marching Tool
 
 \imageMacro{QmitkSegmentation_IMG2DFastMarchingUsage.png,"2D Fast Marching Tool",3.01}
 
 Provides a fast marching based 2D interaction segmentation tool. You start with setting seed points in an image slice. Via several sliders you can adapt parameters and see the fast marching result instantly.
 
 \subsection org_mitk_views_segmentationUserManualManualKringeling5 2D and 3D Interpolation
 
 Creating segmentations using 2D manual contouring for large image volumes may be very time-consuming, because structures of interest may cover a large range of slices.
 The segmentation view offers two helpful features to mitigate this drawback:
 <ul>
 <li> 2D Interpolation
 <li> 3D Interpolation
 </ul>
 
 The <b>2D Interpolation</b> creates suggestions for a segmentation whenever you have a slice that
 <ul>
 <li> has got neighboring slices with segmentations (these do not need to be direct neighbors but could also be a couple of slices away) AND
 <li> is completely clear of a manual segmentation, i.e. there will be no suggestion if there is even only a single pixel of segmentation in the current slice.
 </ul>
 
 \imageMacro{QmitkSegmentation_2DInterpolation.png,"2D Interpolation Usage",3.01}
 
 Interpolated suggestions are displayed as outlines, until you confirm them as part of the segmentation.
 To confirm single slices, click the <i>Confirm for single slice</i> button below the toolbox. You may also review the interpolations visually and then accept all of them at once by selecting <i>Confirm for all slices</i>.
 
 The <b>3D interpolation</b> creates suggestions for 3D segmentations. That means if you start contouring, from the second contour onwards, the surface of the segmented area will be interpolated based on the given contour information.
 The interpolation works with all available manual tools. Please note that this is currently a pure mathematical interpolation, i.e. image intensity information is not taken into account.
 With each further contour the interpolation result will be improved, but the more contours you provide the longer the recalculation will take.
 To achieve an optimal interpolation result and in this way a most accurate segmentation you should try to describe the surface with sparse contours by segmenting in arbitrary
 oriented planes. The 3D interpolation is not meant to be used for parallel slice-wise segmentation, but rather segmentations in i.e. the axial, coronal and sagittal plane.
 
 \imageMacro{QmitkSegmentation_3DInterpolationWrongRight.png,"3D Interpolation Usage",16.00}
 
 You can accept the interpolation result by clicking the <i>Confirm</i>-button below the tool buttons.
 In this case the 3D interpolation will be deactivated automatically so that the result can be post-processed without any interpolation running in the background.
 
 Additional to the surface, black contours are shown in the 3D render window, which mark all the drawn contours used for the interpolation.
 You can navigate between the drawn contours by clicking on the corresponding <i>position</i> nodes in the data manager which are stored as sub-nodes of the selected segmentation.
 If you do not want to see these nodes just uncheck the <i>Show Position Nodes</i> checkbox and these nodes will be hidden.
 
 If you want to delete a drawn contour we recommend to use the Erase-Tool since Redo/Undo is not yet working for 3D interpolation.
 The current state of the 3D interpolation can be saved across application restart. For that, just click on save project during the interpolation is active.
 After restarting the application and load your project you can click on "Reinit Interpolation" within the 3D interpolation GUI area.
 
 
 \section org_mitk_views_segmentationUserManual3DSegmentationTools 3D Segmentation Tools
 
 The 3D tools operate on the whole image and require usually a small amount of interaction like placing seed-points or specifying certain parameters. All 3D tools provide
 an immediate segmentation feedback, which is displayed as a transparent green overlay. For accepting a preview you have to press the <i>Confirm</i> button of the selected tool.
 The following 3D tools are available:
 
 \subsection org_mitk_views_segmentationUserManual3DThresholdTool 3D Threshold Tool
 
 The thresholding tool simply applies a 3D threshold to the patient image. All pixels with values equal or above the selected threshold are labeled as part of the segmentation.
 You can change the threshold by either moving the slider of setting a certain value in the spinbox.
 
 \imageMacro{QmitkSegmentation_3DThresholdTool.png,"3D Threshold tool",10.00}
 
 \subsection org_mitk_views_segmentationUserManual3DULTool 3D Upper/Lower Threshold Tool
 
 The Upper/Lower Thresholding tool works similar to the simple 3D threshold tool but allows you to define an upper and lower threshold. All pixels with
 values within this threshold interval will be labeled as part of the segmentation.
 
 \imageMacro{QmitkSegmentation_3DULThresholdTool.png,"3D Upper/Lower Threshold tool",10.00}
 
 \subsection org_mitk_views_segmentationUserManual3DOtsuTool 3D Otsu Tool
 
 The 3D Otsu tool provides a more sophisticated thresholding algorithm. It allows you to define a number of regions. Based on the image histogram the pixels will
 then be divided into different regions. The more regions you define the longer the calculation will take. You can select afterwards which of these regions you want to confirm as segmentation.
 
 \imageMacro{QmitkSegmentation_3DOtsuTool.png,"3D Otsu tool",10.00}
 
 \subsection org_mitk_views_segmentationUserManual3DFMTool 3D Fast Marching Tool
 
 The 3D Fast Marching tool works similar to the 2D pendant but on the whole image. Depending on your image size the calculation might take some time.
 You can interactively set the parameters of the algorithm via the GUI. The resulting segmentation will be automatically updated.
 
 \imageMacro{QmitkSegmentation_3DFMTool.png,"3D Fast Marching tool",10.00}
 
 \subsection org_mitk_views_segmentationUserManual3DRGTool 3D Region Growing Tool
 
 The 3D Region Growing tool works similar to the 2D pendant. At the beginning you have to place a seedpoint and define a threshold interval. If you press
 <i>Run Segmentation</i> a preview is calculated. By moving the <i>Adapt region growing</i> slider you can interactively adapt the segmentation result.
 
 \imageMacro{QmitkSegmentation_3DRGTool.png,"3D Region Growing tool",10.00}
 
 \subsection org_mitk_views_segmentationUserManual3DWatershedTool 3D Watershed Tool
 
 This tool provides a watershed based segmentation algorithm. For a detailed explanation of the parameters level and threshold, please be referred to https://itk.org/Doxygen/html/classitk_1_1WatershedImageFilter.html .
 Remark: The tool is (due to its implementation) faster if you use lower levels. So in doubt you should start with high levels (supposed to undersegment) and then lower the levels until you are happy.
 
 \imageMacro{QmitkSegmentation_3DWatershedTool.png,"3D Watershed tool",10.00}
 
 \subsection org_mitk_views_segmentationUserManualPickingTool Picking Tool
 
 The Picking tool allows you to select islands within your segmentation. This is especially useful if e.g. a thresholding provided you with several areas within
 your image but you are just interested in one special region.
 
 \imageMacro{QmitkSegmentation_PickingTool.png,"Picking tool",10.00}
 
 \section org_mitk_views_segmentationUserManualPostprocessing Additional things you can do with segmentations
 
 Segmentations are never an end in themselves. Consequently, the segmentation view adds a couple of "post-processing" actions, accessible through the context-menu of the data manager.
 
 \imageMacro{QmitkSegmentation_IMGDataManagerContextMenu.png,"Context menu items for segmentations.",10.58}
 
 <ul>
 <li> <b>Create polygon %model</b> applies the marching cubes algorithm to the segmentation. This polygon %model can be used for visualization in 3D or other applications such as stereolithography (3D printing).
 <li> <b>Create smoothed polygon %model</b> uses smoothing in addition to the marching cubes algorithm, which creates models that do not follow the exact outlines of the segmentation, but look smoother.
 <li> <b>Autocrop</b> can save memory. Manual segmentations have the same extent as the patient image, even if the segmentation comprises only a small sub-volume. This invisible and meaningless margin is removed by autocropping.
 </ul>
 
 
 \section org_mitk_views_segmentationof3DTImages Segmentation of 3D+t images
 
 For segmentation of 3D+t images, some tools give you the option to choose between creating dynamic and static masks.
 <ul>
 <li> Dynamic masks can be created on each time frame individually.
 <li> Static masks will be defined on one time frame and will be the same for all other time frames.
 </ul>
 In general, segmentation is applied on the time frame that is selected when execution is performed. If you alter the time frame, the segmentation preview is adapted.
 
 
 
 \section org_mitk_views_segmentationUserManualTechnicalDetail Technical Information for Developers
 
 For technical specifications see \subpage QmitkSegmentationTechnicalPage and for information on the extensions of the tools system \subpage toolextensions .
 
 */
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentationPreferences.tiff b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentationPreferences.tiff
deleted file mode 100644
index 7659e33ad7..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentationPreferences.tiff and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentationUtilities.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentationUtilities.dox
index 2355581d0b..0d9b10b310 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentationUtilities.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentationUtilities.dox
@@ -1,80 +1,80 @@
 /**
 \page org_mitk_views_segmentationutilities The Segmentation Utilities View
 
-\imageMacro{segmentation_utilities.svg,"Icon of the Segmentation Utilities View",5.00}
+\imageMacro{segmentation_utilities-dox.svg,"Icon of the Segmentation Utilities View",5.00}
 
 \imageMacro{QmitkSegmentationUtilities_Overview.png,"The Segmentation Utilities View",16.00}
 
 \tableofcontents
 
 \section org_mitk_views_segmentationUtilitiesManualOverview Overview
 
 The <b>Segmentation Utilities View</b> allows to postprocess existing segmentations. Currently five different operations exist:
 
 <ul>
 	<li> \ref org_mitk_views_segmentationUtilitiesBooleanOperations
 	<li> \ref org_mitk_views_segmentationUtilitiesContourToImage
 	<li> \ref org_mitk_views_segmentationUtilitiesImageMasking
 	<li> \ref org_mitk_views_segmentationUtilitiesMorphologicalOperations
 	<li> \ref org_mitk_views_segmentationUtilitiesSurfaceToImage
 </ul>
 
 \section org_mitk_views_segmentationUtilitiesDataSelection Data Selection
 
 All postprocessing operations provide one or more selection widgets, which allow to select the data for the operation.
 
 \section org_mitk_views_segmentationUtilitiesBooleanOperations Boolean operations
 
 Boolean operations allows to perform the following fundamental operations on two segmentations:
 
 <ul>
 	<li> <b>Difference:</b> Subtracts the second segmentation from the first segmentation.
 	<li> <b>Intersection:</b> Extracts the overlapping areas of the two selected segmentations.
 	<li> <b>Union:</b> Combines the two existing segmentations.
 </ul>
 
 The selected segmentations must have the same geometry (size, spacing, ...) in order for the operations to work correctly.
 The result will be stored in a new data node as a child node of the first selected segmentation.
 
 \imageMacro{QmitkSegmentationUtilities_BooleanOperations.png,"Boolean operations",6.00}
 
 \section org_mitk_views_segmentationUtilitiesContourToImage Contour to image
 
 Contour to image allows to create a segmentation out of a given contour-model.
 The operation requires a contour model set and a reference image.
 The created segmentation image will have the same geometrical properties like the reference image (dimension, size and Geometry3D).
 
 \imageMacro{QmitkSegmentationUtilities_ContourToImage.png,"Contour to image",6.00}
 
 \section org_mitk_views_segmentationUtilitiesImageMasking Image masking
 
 Image masking allows to mask an image with either an existing segmentation or a surface.
 The operation requires an image and a binary image mask or a surface.
 The result will be an image containing only the pixels that are covered by the respective mask.
 
 \imageMacro{QmitkSegmentationUtilities_ImageMasking.png,"Image masking",6.00}
 
 \section org_mitk_views_segmentationUtilitiesMorphologicalOperations Morphological operations
 
 Morphological operations are applied to a single segmentation image. Based on a given structuring element the underlying segmentation will be modfied.
 The plugin provides a <b>ball</b> and a <b>cross</b> as structuring elements. The follow operations are available:
 
 <ul>
 	<li> <b>Dilation:</b> Each labeled pixel within the segmentation will be dilated based on the selected structuring element.
 	<li> <b>Erosion:</b> Each labeled pixel within the segmentation will be eroded based on the selected structuring element.
 	<li> <b>Opening:</b> A dilation followed by an erosion, used for smoothing edges or eliminating small objects.
 	<li> <b>Closing:</b> An erosion followed by an dilation, used for filling small holes.
 	<li> <b>Fill Holes:</b> Fills bigger holes within a segmentation.
 </ul>
 
 \imageMacro{QmitkSegmentationUtilities_MorphologicalOperations.png,"Morphological operations",6.00}
 
 \section org_mitk_views_segmentationUtilitiesSurfaceToImage Surface to image
 
 Surface to image allows to create a segmentation out of a given surface.
 The operation requires a surface and a reference image.
 The created segmentation image will have the same geometrical properties like the reference image (dimension, size and Geometry3D).
 
 \imageMacro{QmitkSegmentationUtilities_SurfaceToImage.png,"Surface to image",6.00}
 
 **/
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_3DTools.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_3DTools.png
deleted file mode 100644
index 52551edad8..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_3DTools.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_FromSurfaceAfter.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_FromSurfaceAfter.png
deleted file mode 100644
index 9c840864e5..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_FromSurfaceAfter.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_FromSurfaceBefore.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_FromSurfaceBefore.png
deleted file mode 100644
index 92600569e5..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_FromSurfaceBefore.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGApplication.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGApplication.png
deleted file mode 100644
index 3fbfad5228..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGApplication.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGCorrectionActionsx.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGCorrectionActionsx.png
deleted file mode 100644
index 648dc52668..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGCorrectionActionsx.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGDatamanagerview.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGDatamanagerview.png
deleted file mode 100644
index 7f33eb723e..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGDatamanagerview.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGPreferences.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGPreferences.png
deleted file mode 100644
index ef8d4b7a63..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_IMGPreferences.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_Icon.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_Icon.png
deleted file mode 100644
index 3ebadd306f..0000000000
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_Icon.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/segmentation.svg b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/segmentation-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/segmentation.svg
rename to Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/segmentation-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/segmentation_utilities.svg b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/segmentation_utilities-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/segmentation_utilities.svg
rename to Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/segmentation_utilities-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/UserManual/Manual.dox b/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/UserManual/Manual.dox
deleted file mode 100644
index 994c6468d9..0000000000
--- a/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/UserManual/Manual.dox
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
-\page org_mitk_gui_qt_spectrocamrecorder The Spectrocamrecorder
-
-\imageMacro{icon.png,"Icon of Spectrocamrecorder",2.00}
-
-\tableofcontents
-
-\section org_mitk_gui_qt_spectrocamrecorderOverview Overview
-Describe the features of your awesome plugin here
-<ul>
-<li>Increases productivity
-<li>Creates beautiful images
-<li>Generates PhD thesis
-<li>Brings world peace
-</ul>
-
-*/
diff --git a/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/UserManual/icon.xpm b/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/UserManual/icon.xpm
deleted file mode 100644
index 9057c20bc6..0000000000
--- a/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/UserManual/icon.xpm
+++ /dev/null
@@ -1,21 +0,0 @@
-/* XPM */
-static const char * icon_xpm[] = {
-"16 16 2 1",
-" 	c #FF0000",
-".	c #000000",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                ",
-"                "};
diff --git a/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/doxygen/modules.dox
deleted file mode 100644
index cbcca5b2ac..0000000000
--- a/Plugins/org.mitk.gui.qt.spectrocamrecorder/documentation/doxygen/modules.dox
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
-  \defgroup org_mitk_gui_qt_spectrocamrecorder org.mitk.gui.qt.spectrocamrecorder
-  \ingroup MITKPlugins
-
-  \brief Describe your plugin here.
-
-*/
-
-/**
-  \defgroup org_mitk_gui_qt_spectrocamrecorder_internal Internal
-  \ingroup org_mitk_gui_qt_spectrocamrecorder
-
-  \brief This subcategory includes the internal classes of the org.mitk.gui.qt.spectrocamrecorder plugin. Other
-  plugins must not rely on these classes. They contain implementation details and their interface
-  may change at any time. We mean it.
-*/
diff --git a/Plugins/org.mitk.gui.qt.toftutorial/documentation/Manual/Manual.dox b/Plugins/org.mitk.gui.qt.toftutorial/documentation/Manual/Manual.dox
index 00b0777dde..b64b37f1bb 100644
--- a/Plugins/org.mitk.gui.qt.toftutorial/documentation/Manual/Manual.dox
+++ b/Plugins/org.mitk.gui.qt.toftutorial/documentation/Manual/Manual.dox
@@ -1,13 +1,13 @@
 /**
 \page org_toftutorial The ToF Tutorial
 
-\imageMacro{icon.png,"Icon of ToFTutorial",2}
+\imageMacro{icon_tof_tutorial.png,"Icon of ToFTutorial",2}
 
 Available sections:
   - \ref ToFTutorialOverview
 
 \section ToFTutorialOverview
 This is the description for the ToFTutorial.
 
 */
 
diff --git a/Plugins/org.mitk.gui.qt.toftutorial/documentation/Manual/icon_tof_tutorial.png b/Plugins/org.mitk.gui.qt.toftutorial/documentation/Manual/icon_tof_tutorial.png
new file mode 100644
index 0000000000..13aab8a1c8
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.toftutorial/documentation/Manual/icon_tof_tutorial.png differ
diff --git a/Plugins/org.mitk.gui.qt.toftutorial/files.cmake b/Plugins/org.mitk.gui.qt.toftutorial/files.cmake
index d3c0aac915..00515cb366 100644
--- a/Plugins/org.mitk.gui.qt.toftutorial/files.cmake
+++ b/Plugins/org.mitk.gui.qt.toftutorial/files.cmake
@@ -1,37 +1,36 @@
 set(SRC_CPP_FILES
 
 )
 
 set(INTERNAL_CPP_FILES
   QmitkToFTutorialView.cpp
   mitkPluginActivator.cpp
 )
 
 set(UI_FILES
   src/internal/QmitkToFTutorialViewControls.ui
 )
 
 set(MOC_H_FILES
   src/internal/QmitkToFTutorialView.h
   src/internal/mitkPluginActivator.h
 )
 
 set(CACHED_RESOURCE_FILES
   plugin.xml
   resources/icon_tof_tutorial.svg
 )
 
 set(QRC_FILES
-  resources/QmitkToFTutorialView.qrc
 )
 
 set(CPP_FILES)
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
 
diff --git a/Plugins/org.mitk.gui.qt.toftutorial/resources/QmitkToFTutorialView.qrc b/Plugins/org.mitk.gui.qt.toftutorial/resources/QmitkToFTutorialView.qrc
deleted file mode 100644
index 7b41198d69..0000000000
--- a/Plugins/org.mitk.gui.qt.toftutorial/resources/QmitkToFTutorialView.qrc
+++ /dev/null
@@ -1,5 +0,0 @@
-<!DOCTYPE RCC><RCC version="1.0">
- <qresource prefix="/QmitkToFTutorialView">
-     <file>icon.xpm</file>
- </qresource>
- </RCC>
diff --git a/Plugins/org.mitk.gui.qt.toftutorial/resources/icon.png b/Plugins/org.mitk.gui.qt.toftutorial/resources/icon.png
deleted file mode 100644
index dfa18097dd..0000000000
Binary files a/Plugins/org.mitk.gui.qt.toftutorial/resources/icon.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.toftutorial/resources/icon.xpm b/Plugins/org.mitk.gui.qt.toftutorial/resources/icon.xpm
deleted file mode 100644
index 62b8ad5692..0000000000
--- a/Plugins/org.mitk.gui.qt.toftutorial/resources/icon.xpm
+++ /dev/null
@@ -1,2635 +0,0 @@
-/* XPM */
-static char * icon_xpm[] = {
-"100 100 2532 2",
-"  	c None",
-". 	c #F3F3F3",
-"+ 	c #ACACAC",
-"@ 	c #7E7E7E",
-"# 	c #7C7C7C",
-"$ 	c #5E5E5E",
-"% 	c #E3E3E4",
-"& 	c #A1A1A3",
-"* 	c #8B8B8A",
-"= 	c #646464",
-"- 	c #474747",
-"; 	c #121212",
-"> 	c #323232",
-", 	c #6B6B6B",
-"' 	c #EAEAEA",
-") 	c #C9CACA",
-"! 	c #98989A",
-"~ 	c #777779",
-"{ 	c #454547",
-"] 	c #4A4A4A",
-"^ 	c #2C2C2C",
-"/ 	c #3B3B3B",
-"( 	c #181818",
-"_ 	c #1D1D1D",
-": 	c #252526",
-"< 	c #343435",
-"[ 	c #C3C3C2",
-"} 	c #D5D5D5",
-"| 	c #B0B1B3",
-"1 	c #B8B9BC",
-"2 	c #707174",
-"3 	c #707276",
-"4 	c #414245",
-"5 	c #454647",
-"6 	c #444444",
-"7 	c #383838",
-"8 	c #2F2F2F",
-"9 	c #262626",
-"0 	c #202020",
-"a 	c #1B1C1D",
-"b 	c #19191B",
-"c 	c #161618",
-"d 	c #5D5D5D",
-"e 	c #C8C8C8",
-"f 	c #C5C7C9",
-"g 	c #B0B6B9",
-"h 	c #A1A4A8",
-"i 	c #8F8F95",
-"j 	c #48484D",
-"k 	c #505153",
-"l 	c #515152",
-"m 	c #2B2B2B",
-"n 	c #404040",
-"o 	c #222222",
-"p 	c #212223",
-"q 	c #18191A",
-"r 	c #232326",
-"s 	c #131315",
-"t 	c #727274",
-"u 	c #BFBFBE",
-"v 	c #D0D4D7",
-"w 	c #BEC3C6",
-"x 	c #B6BABD",
-"y 	c #B2B6BC",
-"z 	c #AEB4B9",
-"A 	c #909499",
-"B 	c #86888D",
-"C 	c #57585C",
-"D 	c #3F3F3F",
-"E 	c #4B4B4A",
-"F 	c #343434",
-"G 	c #414141",
-"H 	c #28292B",
-"I 	c #2F3032",
-"J 	c #232226",
-"K 	c #343438",
-"L 	c #201F22",
-"M 	c #3D3D3F",
-"N 	c #8F8F90",
-"O 	c #B9B8BA",
-"P 	c #C9C9CB",
-"Q 	c #B8B8B8",
-"R 	c #8B8D8E",
-"S 	c #D3D7DA",
-"T 	c #B9BDC1",
-"U 	c #B3B7BB",
-"V 	c #AAAEB2",
-"W 	c #A3A9AD",
-"X 	c #9FA3A8",
-"Y 	c #83878B",
-"Z 	c #747578",
-"` 	c #5B5B5D",
-" .	c #434343",
-"..	c #505050",
-"+.	c #424242",
-"@.	c #373737",
-"#.	c #353637",
-"$.	c #323335",
-"%.	c #2F3133",
-"&.	c #323235",
-"*.	c #353537",
-"=.	c #3C3C3E",
-"-.	c #39393A",
-";.	c #302F30",
-">.	c #464546",
-",.	c #4A4A4C",
-"'.	c #F3F3F4",
-").	c #D3D4D6",
-"!.	c #D0D2D5",
-"~.	c #E2E5E7",
-"{.	c #E2E4E6",
-"].	c #4B4A4B",
-"^.	c #4F4F4F",
-"/.	c #BCBFBF",
-"(.	c #B6BABF",
-"_.	c #A7ACB0",
-":.	c #9FA4A8",
-"<.	c #9CA0A4",
-"[.	c #8B8F92",
-"}.	c #797A7D",
-"|.	c #6A6A6A",
-"1.	c #595958",
-"2.	c #454545",
-"3.	c #3D3D3D",
-"4.	c #363636",
-"5.	c #323334",
-"6.	c #303133",
-"7.	c #333436",
-"8.	c #3D3E40",
-"9.	c #333335",
-"0.	c #2C2C2D",
-"a.	c #3A3A3A",
-"b.	c #373738",
-"c.	c #3B3B3E",
-"d.	c #3B3B3F",
-"e.	c #A0A0A1",
-"f.	c #E5E7E8",
-"g.	c #D0D2D3",
-"h.	c #CED0D2",
-"i.	c #D7DADC",
-"j.	c #E3E6E8",
-"k.	c #E0E4E7",
-"l.	c #DADEE1",
-"m.	c #D7DCE0",
-"n.	c #D4DADC",
-"o.	c #DCE0E1",
-"p.	c #999898",
-"q.	c #2A2A2B",
-"r.	c #656668",
-"s.	c #B0B6BA",
-"t.	c #A1A5AA",
-"u.	c #999BA0",
-"v.	c #919297",
-"w.	c #757679",
-"x.	c #666667",
-"y.	c #5A5A5B",
-"z.	c #505051",
-"A.	c #3B3B3C",
-"B.	c #3C3C3C",
-"C.	c #393939",
-"D.	c #2F3031",
-"E.	c #363739",
-"F.	c #363638",
-"G.	c #313136",
-"H.	c #35353B",
-"I.	c #38383E",
-"J.	c #38373C",
-"K.	c #3D3C41",
-"L.	c #2F2F31",
-"M.	c #636363",
-"N.	c #BDBFBF",
-"O.	c #AEB2B4",
-"P.	c #B3B7BA",
-"Q.	c #CACED1",
-"R.	c #D1D6D9",
-"S.	c #D9DDE0",
-"T.	c #DBDFE2",
-"U.	c #D6DADD",
-"V.	c #D1D5D8",
-"W.	c #CED2D5",
-"X.	c #D3D6D8",
-"Y.	c #DADDDE",
-"Z.	c #616364",
-"`.	c #2C2D2D",
-" +	c #8D8F94",
-".+	c #9B9EA4",
-"++	c #919296",
-"@+	c #7A7B7F",
-"#+	c #6B6C6D",
-"$+	c #4E4E51",
-"%+	c #474748",
-"&+	c #333333",
-"*+	c #424241",
-"=+	c #40403F",
-"-+	c #222223",
-";+	c #2D2E30",
-">+	c #333438",
-",+	c #37383C",
-"'+	c #39383C",
-")+	c #434247",
-"!+	c #575659",
-"~+	c #4D4D4D",
-"{+	c #B1B1B1",
-"]+	c #C6C6C7",
-"^+	c #BBBDC0",
-"/+	c #A4A6A9",
-"(+	c #A6A9AC",
-"_+	c #BDC1C4",
-":+	c #BBBFC2",
-"<+	c #BABEC1",
-"[+	c #C8CCCF",
-"}+	c #D2D6D9",
-"|+	c #D2D7DA",
-"1+	c #D5D9DC",
-"2+	c #D4D7DA",
-"3+	c #D2D5D7",
-"4+	c #D7D9DB",
-"5+	c #D4D6D9",
-"6+	c #C9CED0",
-"7+	c #BFC4C7",
-"8+	c #939395",
-"9+	c #3F3F41",
-"0+	c #5B5D5F",
-"a+	c #7D7E82",
-"b+	c #8B8C8F",
-"c+	c #6D6E70",
-"d+	c #5A5A5C",
-"e+	c #333332",
-"f+	c #3E3E3D",
-"g+	c #313133",
-"h+	c #2E2E30",
-"i+	c #2D2E31",
-"j+	c #2E2F31",
-"k+	c #343538",
-"l+	c #3D3D40",
-"m+	c #454648",
-"n+	c #535353",
-"o+	c #515151",
-"p+	c #353534",
-"q+	c #AAAAA9",
-"r+	c #CCCDCC",
-"s+	c #7F8184",
-"t+	c #999B9E",
-"u+	c #9A9C9F",
-"v+	c #96989D",
-"w+	c #9CA0A3",
-"x+	c #A6ABAE",
-"y+	c #AEB2B5",
-"z+	c #ADB0B2",
-"A+	c #B5B6B9",
-"B+	c #B6B8BC",
-"C+	c #C3C5C9",
-"D+	c #CDCFD4",
-"E+	c #CED1D4",
-"F+	c #D7D8DB",
-"G+	c #D1D3D5",
-"H+	c #CFD1D3",
-"I+	c #E0E0E2",
-"J+	c #E4E5E7",
-"K+	c #D4D6D8",
-"L+	c #BCBFC3",
-"M+	c #B5B8BC",
-"N+	c #BBBEC2",
-"O+	c #A8AAAC",
-"P+	c #77787A",
-"Q+	c #3B3C3F",
-"R+	c #3A3B3C",
-"S+	c #666768",
-"T+	c #606062",
-"U+	c #515153",
-"V+	c #4A4A4B",
-"W+	c #353536",
-"X+	c #2E2E2F",
-"Y+	c #2D2D2F",
-"Z+	c #2A2B2B",
-"`+	c #2F2F30",
-" @	c #424243",
-".@	c #514F4E",
-"+@	c #535252",
-"@@	c #48494A",
-"#@	c #403F3D",
-"$@	c #51514C",
-"%@	c #434244",
-"&@	c #424143",
-"*@	c #E9E8EA",
-"=@	c #646567",
-"-@	c #565757",
-";@	c #2C2D2F",
-">@	c #7A7E7E",
-",@	c #979B9F",
-"'@	c #95989E",
-")@	c #9DA1A5",
-"!@	c #9FA3A6",
-"~@	c #A0A4A7",
-"{@	c #A9ABAD",
-"]@	c #AEAFB1",
-"^@	c #B2B3B5",
-"/@	c #C0C1C5",
-"(@	c #CECFD4",
-"_@	c #D3D4D7",
-":@	c #D2D3D5",
-"<@	c #C9CACC",
-"[@	c #CCCDCF",
-"}@	c #D6D7D9",
-"|@	c #DEDFE0",
-"1@	c #D9DADC",
-"2@	c #AEAFB4",
-"3@	c #A7AAAE",
-"4@	c #A3A7AA",
-"5@	c #9EA2A5",
-"6@	c #9D9FA2",
-"7@	c #4D4E4E",
-"8@	c #181918",
-"9@	c #404041",
-"0@	c #58585B",
-"a@	c #323234",
-"b@	c #444242",
-"c@	c #43423F",
-"d@	c #4B4B47",
-"e@	c #504E50",
-"f@	c #302C39",
-"g@	c #100A20",
-"h@	c #6A6871",
-"i@	c #C0C0C0",
-"j@	c #727475",
-"k@	c #4D5153",
-"l@	c #414547",
-"m@	c #55585A",
-"n@	c #606163",
-"o@	c #424342",
-"p@	c #191A19",
-"q@	c #6B6F6F",
-"r@	c #A2A7A9",
-"s@	c #93989B",
-"t@	c #9FA2A5",
-"u@	c #A2A4A6",
-"v@	c #ADAEB0",
-"w@	c #BDBEC0",
-"x@	c #C0C1C4",
-"y@	c #CDCED0",
-"z@	c #CECFD1",
-"A@	c #D5D6D8",
-"B@	c #D4D5D7",
-"C@	c #CECFD0",
-"D@	c #BFC0C2",
-"E@	c #B5B6B7",
-"F@	c #B1B2B5",
-"G@	c #A8A9AD",
-"H@	c #A0A3A7",
-"I@	c #9A9EA1",
-"J@	c #979A9D",
-"K@	c #939498",
-"L@	c #8A8B8B",
-"M@	c #666767",
-"N@	c #282828",
-"O@	c #1C1C1E",
-"P@	c #49494A",
-"Q@	c #494949",
-"R@	c #454548",
-"S@	c #4F4F51",
-"T@	c #4B4B4B",
-"U@	c #3D3E3D",
-"V@	c #555555",
-"W@	c #434148",
-"X@	c #2D2633",
-"Y@	c #1B1327",
-"Z@	c #201732",
-"`@	c #120C1F",
-" #	c #969599",
-".#	c #C2C2C2",
-"+#	c #9A999D",
-"@#	c #393A3D",
-"##	c #303134",
-"$#	c #424346",
-"%#	c #45464A",
-"&#	c #4C4E52",
-"*#	c #505257",
-"=#	c #5B5E63",
-"-#	c #686C70",
-";#	c #636368",
-">#	c #0B0B0C",
-",#	c #484848",
-"'#	c #A1A2A3",
-")#	c #969799",
-"!#	c #9E9EA0",
-"~#	c #A1A2A4",
-"{#	c #A3A4A6",
-"]#	c #CBCCCE",
-"^#	c #CED0CF",
-"/#	c #D0D1D1",
-"(#	c #C3C4C4",
-"_#	c #C7C9CB",
-":#	c #BABBBF",
-"<#	c #B7B8BD",
-"[#	c #B0B1B4",
-"}#	c #ABACB0",
-"|#	c #A5A6AA",
-"1#	c #9C9FA4",
-"2#	c #93969B",
-"3#	c #898A8E",
-"4#	c #78797A",
-"5#	c #636365",
-"6#	c #070708",
-"7#	c #303030",
-"8#	c #4C4C4C",
-"9#	c #444445",
-"0#	c #3A3A3C",
-"a#	c #343331",
-"b#	c #5D5A59",
-"c#	c #585256",
-"d#	c #21162B",
-"e#	c #22162D",
-"f#	c #24182F",
-"g#	c #261A32",
-"h#	c #25192F",
-"i#	c #2D2531",
-"j#	c #AEAEAE",
-"k#	c #737373",
-"l#	c #252525",
-"m#	c #151515",
-"n#	c #585859",
-"o#	c #2C2C2E",
-"p#	c #16151A",
-"q#	c #424347",
-"r#	c #404146",
-"s#	c #46474B",
-"t#	c #494A4E",
-"u#	c #4F5155",
-"v#	c #55595E",
-"w#	c #717379",
-"x#	c #797B7E",
-"y#	c #2C2D2E",
-"z#	c #79797B",
-"A#	c #9B9B9D",
-"B#	c #9F9FA2",
-"C#	c #A0A1A3",
-"D#	c #BABBBD",
-"E#	c #C3C4C6",
-"F#	c #C9CBCC",
-"G#	c #C3C4C5",
-"H#	c #BABBBE",
-"I#	c #B9BABF",
-"J#	c #B3B4B8",
-"K#	c #AFB0B4",
-"L#	c #A7A8AC",
-"M#	c #9FA0A4",
-"N#	c #979A9F",
-"O#	c #919398",
-"P#	c #8E8F94",
-"Q#	c #636467",
-"R#	c #606162",
-"S#	c #5D5D5E",
-"T#	c #4C4C4B",
-"U#	c #0C0C0C",
-"V#	c #3D3D3C",
-"W#	c #333437",
-"X#	c #444248",
-"Y#	c #54505B",
-"Z#	c #2A2336",
-"`#	c #170B27",
-" $	c #291C37",
-".$	c #2A1D34",
-"+$	c #281D32",
-"@$	c #2A1E33",
-"#$	c #251B2D",
-"$$	c #4B454F",
-"%$	c #5B5C5C",
-"&$	c #696969",
-"*$	c #000000",
-"=$	c #0C0C0D",
-"-$	c #161717",
-";$	c #121214",
-">$	c #38373B",
-",$	c #35363A",
-"'$	c #37383B",
-")$	c #414247",
-"!$	c #434448",
-"~$	c #47484B",
-"{$	c #4B4D52",
-"]$	c #525559",
-"^$	c #595C60",
-"/$	c #62656B",
-"($	c #6D6F74",
-"_$	c #7A7E81",
-":$	c #29282A",
-"<$	c #48484A",
-"[$	c #949597",
-"}$	c #9FA0A2",
-"|$	c #AAABAD",
-"1$	c #BBBCBE",
-"2$	c #BCBDC0",
-"3$	c #B9B9BD",
-"4$	c #B4B5B9",
-"5$	c #B0B1B5",
-"6$	c #ACADB1",
-"7$	c #A6A7AB",
-"8$	c #909297",
-"9$	c #8D9196",
-"0$	c #8F9296",
-"a$	c #9D9EA2",
-"b$	c #595A5C",
-"c$	c #565655",
-"d$	c #484846",
-"e$	c #50504F",
-"f$	c #161616",
-"g$	c #353535",
-"h$	c #3A3C3D",
-"i$	c #2E263B",
-"j$	c #221734",
-"k$	c #2A1E38",
-"l$	c #2E213A",
-"m$	c #2E203A",
-"n$	c #2E2139",
-"o$	c #2D2136",
-"p$	c #2E2236",
-"q$	c #291F30",
-"r$	c #69656D",
-"s$	c #CDCDCE",
-"t$	c #727374",
-"u$	c #59595A",
-"v$	c #191C1D",
-"w$	c #131518",
-"x$	c #131417",
-"y$	c #151619",
-"z$	c #121314",
-"A$	c #0D0E10",
-"B$	c #0B0C0E",
-"C$	c #252629",
-"D$	c #1F2021",
-"E$	c #0F1010",
-"F$	c #323337",
-"G$	c #3A3B3F",
-"H$	c #343539",
-"I$	c #444547",
-"J$	c #464749",
-"K$	c #4B4C50",
-"L$	c #505155",
-"M$	c #58595D",
-"N$	c #5D6064",
-"O$	c #65696C",
-"P$	c #696D71",
-"Q$	c #757779",
-"R$	c #6F6F71",
-"S$	c #343537",
-"T$	c #232324",
-"U$	c #767675",
-"V$	c #A7A8A9",
-"W$	c #B2B3B7",
-"X$	c #B9BABC",
-"Y$	c #B8B9BB",
-"Z$	c #B1B2B4",
-"`$	c #A7A8AB",
-" %	c #A1A2A6",
-".%	c #97989C",
-"+%	c #8E8F93",
-"@%	c #9DA1A4",
-"#%	c #919496",
-"$%	c #6E6E6F",
-"%%	c #575757",
-"&%	c #373636",
-"*%	c #3A3B3B",
-"=%	c #111214",
-"-%	c #3B3C3E",
-";%	c #3A3C3E",
-">%	c #323036",
-",%	c #30223D",
-"'%	c #30233C",
-")%	c #31243E",
-"!%	c #32243E",
-"~%	c #31253D",
-"{%	c #31253B",
-"]%	c #32263A",
-"^%	c #34273C",
-"/%	c #33283A",
-"(%	c #747479",
-"_%	c #E7E7E7",
-":%	c #8B8A8C",
-"<%	c #504F52",
-"[%	c #232427",
-"}%	c #1B1B1E",
-"|%	c #242528",
-"1%	c #1B1E21",
-"2%	c #17191D",
-"3%	c #16171C",
-"4%	c #0A0B0D",
-"5%	c #161719",
-"6%	c #1B1D1E",
-"7%	c #070908",
-"8%	c #252627",
-"9%	c #393A3F",
-"0%	c #16161A",
-"a%	c #444548",
-"b%	c #4A4B4D",
-"c%	c #4D4E52",
-"d%	c #525357",
-"e%	c #5B5D60",
-"f%	c #5F6366",
-"g%	c #64686A",
-"h%	c #68696B",
-"i%	c #717274",
-"j%	c #727375",
-"k%	c #585858",
-"l%	c #1A1A1A",
-"m%	c #A7A7AB",
-"n%	c #B3B4B7",
-"o%	c #B6B7B9",
-"p%	c #B3B4B6",
-"q%	c #B4B5B7",
-"r%	c #A9AAAC",
-"s%	c #AFB0B2",
-"t%	c #A4A5A8",
-"u%	c #B6B7BA",
-"v%	c #8A8B8D",
-"w%	c #5E5F61",
-"x%	c #494A4B",
-"y%	c #3D3E41",
-"z%	c #3B3D3F",
-"A%	c #34303B",
-"B%	c #362843",
-"C%	c #352841",
-"D%	c #362942",
-"E%	c #372A42",
-"F%	c #372B40",
-"G%	c #372C40",
-"H%	c #362A40",
-"I%	c #423847",
-"J%	c #6E6E71",
-"K%	c #959495",
-"L%	c #464645",
-"M%	c #353539",
-"N%	c #343338",
-"O%	c #2B2B30",
-"P%	c #2D2E33",
-"Q%	c #2C2D32",
-"R%	c #16161B",
-"S%	c #1B1A20",
-"T%	c #1A1C21",
-"U%	c #15171D",
-"V%	c #0F1014",
-"W%	c #060709",
-"X%	c #191A1D",
-"Y%	c #2C2D30",
-"Z%	c #080808",
-"`%	c #1A1B1A",
-" &	c #444549",
-".&	c #414246",
-"+&	c #515254",
-"@&	c #494A4C",
-"#&	c #4E4F53",
-"$&	c #575B5E",
-"%&	c #5E6265",
-"&&	c #5E6062",
-"*&	c #808083",
-"=&	c #99999A",
-"-&	c #9F9F9F",
-";&	c #202225",
-">&	c #949598",
-",&	c #AAABAF",
-"'&	c #949698",
-")&	c #202021",
-"!&	c #A3A4A7",
-"~&	c #96979B",
-"{&	c #3E3E3E",
-"]&	c #2B2B2D",
-"^&	c #353142",
-"/&	c #392B47",
-"(&	c #3A2C46",
-"_&	c #3A2D47",
-":&	c #3A2E47",
-"<&	c #3B2F47",
-"[&	c #3C3045",
-"}&	c #3C3145",
-"|&	c #3A2D44",
-"1&	c #4A414D",
-"2&	c #A3A5A3",
-"3&	c #8F8C8A",
-"4&	c #939298",
-"5&	c #212526",
-"6&	c #2B2C2B",
-"7&	c #3C3A3C",
-"8&	c #787982",
-"9&	c #30343B",
-"0&	c #22262D",
-"a&	c #24282E",
-"b&	c #1D2125",
-"c&	c #171A1F",
-"d&	c #191A1E",
-"e&	c #15161A",
-"f&	c #0D0D11",
-"g&	c #131517",
-"h&	c #1E1F21",
-"i&	c #313236",
-"j&	c #2A2A2F",
-"k&	c #3F4044",
-"l&	c #58595E",
-"m&	c #404145",
-"n&	c #505152",
-"o&	c #535357",
-"p&	c #5A5B5F",
-"q&	c #646368",
-"r&	c #767779",
-"s&	c #8F9092",
-"t&	c #919294",
-"u&	c #87888A",
-"v&	c #868789",
-"w&	c #A5A6A8",
-"x&	c #4C4D50",
-"y&	c #1A1C1C",
-"z&	c #6E7070",
-"A&	c #949496",
-"B&	c #A7A7A9",
-"C&	c #B9BCBF",
-"D&	c #A6AAAD",
-"E&	c #7A7D81",
-"F&	c #1E1E1E",
-"G&	c #2A2929",
-"H&	c #262726",
-"I&	c #2A2C2B",
-"J&	c #353635",
-"K&	c #3B3B3A",
-"L&	c #393A3A",
-"M&	c #3A3043",
-"N&	c #3D314B",
-"O&	c #3F324D",
-"P&	c #40334C",
-"Q&	c #41344A",
-"R&	c #403349",
-"S&	c #423648",
-"T&	c #413546",
-"U&	c #45394D",
-"V&	c #433F4B",
-"W&	c #E0DFE1",
-"X&	c #676764",
-"Y&	c #131413",
-"Z&	c #484947",
-"`&	c #222326",
-" *	c #252426",
-".*	c #5F6267",
-"+*	c #6F7278",
-"@*	c #373A41",
-"#*	c #181B20",
-"$*	c #1E2126",
-"%*	c #191B20",
-"&*	c #14151A",
-"**	c #141519",
-"=*	c #18191D",
-"-*	c #0E0F0F",
-";*	c #111212",
-">*	c #1B1C1F",
-",*	c #2D2F32",
-"'*	c #36373B",
-")*	c #3C3D41",
-"!*	c #47484C",
-"~*	c #4B4D4E",
-"{*	c #46484A",
-"]*	c #65666A",
-"^*	c #717276",
-"/*	c #808185",
-"(*	c #818284",
-"_*	c #7E7F81",
-":*	c #7A7B7D",
-"<*	c #808183",
-"[*	c #86888A",
-"}*	c #303131",
-"|*	c #616365",
-"1*	c #141414",
-"2*	c #131313",
-"3*	c #101010",
-"4*	c #171817",
-"5*	c #252826",
-"6*	c #373938",
-"7*	c #434444",
-"8*	c #3C3A3F",
-"9*	c #3E3249",
-"0*	c #463751",
-"a*	c #453652",
-"b*	c #463852",
-"c*	c #473850",
-"d*	c #48394F",
-"e*	c #483A4E",
-"f*	c #47394B",
-"g*	c #493D4E",
-"h*	c #39343E",
-"i*	c #6A696C",
-"j*	c #3A393D",
-"k*	c #212325",
-"l*	c #201F21",
-"m*	c #323438",
-"n*	c #4A4D53",
-"o*	c #6B6D74",
-"p*	c #424449",
-"q*	c #14171C",
-"r*	c #171A1E",
-"s*	c #1B1D21",
-"t*	c #111416",
-"u*	c #0F0F14",
-"v*	c #1C1D21",
-"w*	c #191A1C",
-"x*	c #303135",
-"y*	c #434447",
-"z*	c #48494B",
-"A*	c #48494C",
-"B*	c #7F8081",
-"C*	c #6F7074",
-"D*	c #76777B",
-"E*	c #727377",
-"F*	c #737476",
-"G*	c #747577",
-"H*	c #78797B",
-"I*	c #7A7A7C",
-"J*	c #868788",
-"K*	c #9C9D9F",
-"L*	c #7E8081",
-"M*	c #161617",
-"N*	c #0A0B0B",
-"O*	c #131314",
-"P*	c #121211",
-"Q*	c #0B0B0B",
-"R*	c #0D0D0D",
-"S*	c #0F0F0F",
-"T*	c #111111",
-"U*	c #131412",
-"V*	c #1B1C1B",
-"W*	c #262727",
-"X*	c #2D2D2D",
-"Y*	c #1D1E1E",
-"Z*	c #434443",
-"`*	c #3E3F3F",
-" =	c #3B393F",
-".=	c #433551",
-"+=	c #4F3D59",
-"@=	c #4E3D59",
-"#=	c #4D3D58",
-"$=	c #4D3D55",
-"%=	c #4E3E55",
-"&=	c #4D3F54",
-"*=	c #4C3F52",
-"==	c #3F3443",
-"-=	c #868188",
-";=	c #626262",
-">=	c #4E4D4F",
-",=	c #212125",
-"'=	c #212222",
-")=	c #101012",
-"!=	c #616368",
-"~=	c #484B50",
-"{=	c #191B1F",
-"]=	c #121217",
-"^=	c #1B1E22",
-"/=	c #15151A",
-"(=	c #0A0B0F",
-"_=	c #1E1F23",
-":=	c #292A2E",
-"<=	c #2D2E32",
-"[=	c #38393A",
-"}=	c #39393B",
-"|=	c #3F4042",
-"1=	c #4F5051",
-"2=	c #6C6C6D",
-"3=	c #9C9C9D",
-"4=	c #696B6D",
-"5=	c #6B6C70",
-"6=	c #6B6C6F",
-"7=	c #696A6C",
-"8=	c #747473",
-"9=	c #898989",
-"0=	c #858586",
-"a=	c #565858",
-"b=	c #343636",
-"c=	c #131312",
-"d=	c #040404",
-"e=	c #121312",
-"f=	c #111110",
-"g=	c #5E5E5D",
-"h=	c #444545",
-"i=	c #1C1C1C",
-"j=	c #323433",
-"k=	c #3E403F",
-"l=	c #3E403E",
-"m=	c #403B43",
-"n=	c #4F3F5E",
-"o=	c #574463",
-"p=	c #554560",
-"q=	c #55445E",
-"r=	c #55445D",
-"s=	c #53455B",
-"t=	c #524458",
-"u=	c #544557",
-"v=	c #322A37",
-"w=	c #DDDBDD",
-"x=	c #6D6E6E",
-"y=	c #201F24",
-"z=	c #1D1F1E",
-"A=	c #292A2D",
-"B=	c #292A2F",
-"C=	c #2D2D32",
-"D=	c #26282D",
-"E=	c #595C61",
-"F=	c #474A4F",
-"G=	c #181A1F",
-"H=	c #0B0B10",
-"I=	c #212327",
-"J=	c #25262A",
-"K=	c #28292D",
-"L=	c #2E2F33",
-"M=	c #2A2C2C",
-"N=	c #6B6C6B",
-"O=	c #525255",
-"P=	c #4F5153",
-"Q=	c #55585B",
-"R=	c #56595C",
-"S=	c #5C5D61",
-"T=	c #616266",
-"U=	c #5D5E62",
-"V=	c #646568",
-"W=	c #6E6F70",
-"X=	c #797A7A",
-"Y=	c #171917",
-"Z=	c #131512",
-"`=	c #0C0D0B",
-" -	c #030303",
-".-	c #11110F",
-"+-	c #0F0F10",
-"@-	c #1B1B1B",
-"#-	c #3D3F3E",
-"$-	c #413949",
-"%-	c #624E74",
-"&-	c #5F4D6B",
-"*-	c #604D69",
-"=-	c #614E69",
-"--	c #604D68",
-";-	c #5D4B64",
-">-	c #594A5A",
-",-	c #625661",
-"'-	c #4A494C",
-")-	c #2B2A2C",
-"!-	c #1A1A1D",
-"~-	c #1F2121",
-"{-	c #1A1B1D",
-"]-	c #38393C",
-"^-	c #26272B",
-"/-	c #1E2025",
-"(-	c #46484D",
-"_-	c #46494D",
-":-	c #1C1C21",
-"<-	c #171B1F",
-"[-	c #1D1F23",
-"}-	c #202124",
-"|-	c #232429",
-"1-	c #232428",
-"2-	c #28282D",
-"3-	c #444645",
-"4-	c #595A59",
-"5-	c #37383A",
-"6-	c #4B4D4F",
-"7-	c #4F5255",
-"8-	c #525558",
-"9-	c #57595D",
-"0-	c #5B5C60",
-"a-	c #5B5C5D",
-"b-	c #555557",
-"c-	c #363738",
-"d-	c #090909",
-"e-	c #0E0E0E",
-"f-	c #161815",
-"g-	c #121412",
-"h-	c #131414",
-"i-	c #090809",
-"j-	c #0A0A0A",
-"k-	c #010101",
-"l-	c #020202",
-"m-	c #060606",
-"n-	c #292A2A",
-"o-	c #1F1F20",
-"p-	c #3C3D3D",
-"q-	c #3F413F",
-"r-	c #4F425C",
-"s-	c #725C83",
-"t-	c #6C5878",
-"u-	c #6D5875",
-"v-	c #6D5873",
-"w-	c #6A5870",
-"x-	c #67596B",
-"y-	c #5A555E",
-"z-	c #414346",
-"A-	c #999A9C",
-"B-	c #6D6D6E",
-"C-	c #191919",
-"D-	c #1E2020",
-"E-	c #151719",
-"F-	c #282A2E",
-"G-	c #242428",
-"H-	c #2C2D31",
-"I-	c #38383D",
-"J-	c #24292D",
-"K-	c #1D1F22",
-"L-	c #1D1E22",
-"M-	c #27282B",
-"N-	c #2B2B2E",
-"O-	c #333435",
-"P-	c #353638",
-"Q-	c #404143",
-"R-	c #434446",
-"S-	c #47484A",
-"T-	c #4C4D4F",
-"U-	c #565759",
-"V-	c #545558",
-"W-	c #404043",
-"X-	c #1F1F1F",
-"Y-	c #0F100F",
-"Z-	c #1F2122",
-"`-	c #222421",
-" ;	c #1F2226",
-".;	c #191A1A",
-"+;	c #161818",
-"@;	c #070807",
-"#;	c #171718",
-"$;	c #16171A",
-"%;	c #18181B",
-"&;	c #373736",
-"*;	c #3B3B3D",
-"=;	c #69577A",
-"-;	c #80668C",
-";;	c #806489",
-">;	c #7E6883",
-",;	c #736576",
-"';	c #5E575F",
-");	c #4D4C4C",
-"!;	c #5B5B59",
-"~;	c #6F6F6F",
-"{;	c #292929",
-"];	c #1A1919",
-"^;	c #1C1E1D",
-"/;	c #151518",
-"(;	c #27282C",
-"_;	c #2A2B2F",
-":;	c #28292C",
-"<;	c #202023",
-"[;	c #2C2C2F",
-"};	c #303234",
-"|;	c #1F2024",
-"1;	c #373939",
-"2;	c #424444",
-"3;	c #212323",
-"4;	c #313234",
-"5;	c #38393B",
-"6;	c #424345",
-"7;	c #2F3131",
-"8;	c #0B0C0C",
-"9;	c #252425",
-"0;	c #2E302C",
-"a;	c #333431",
-"b;	c #3D363E",
-"c;	c #232726",
-"d;	c #242625",
-"e;	c #202321",
-"f;	c #1E1F1F",
-"g;	c #070707",
-"h;	c #050505",
-"i;	c #211F22",
-"j;	c #282A2D",
-"k;	c #37353C",
-"l;	c #8E779D",
-"m;	c #8D7496",
-"n;	c #806F82",
-"o;	c #645E66",
-"p;	c #514C4D",
-"q;	c #5F5C58",
-"r;	c #7F7F78",
-"s;	c #767777",
-"t;	c #191B1A",
-"u;	c #191C1B",
-"v;	c #18191B",
-"w;	c #323338",
-"x;	c #222328",
-"y;	c #2B2C2E",
-"z;	c #363639",
-"A;	c #2D3134",
-"B;	c #212528",
-"C;	c #222225",
-"D;	c #1A1C1A",
-"E;	c #282A2C",
-"F;	c #1C1C1F",
-"G;	c #202223",
-"H;	c #282A2B",
-"I;	c #272829",
-"J;	c #393A3C",
-"K;	c #46474A",
-"L;	c #343536",
-"M;	c #1B1B1C",
-"N;	c #111312",
-"O;	c #202024",
-"P;	c #222321",
-"Q;	c #2B2D28",
-"R;	c #44433D",
-"S;	c #37313F",
-"T;	c #3A2E50",
-"U;	c #37294B",
-"V;	c #2C2E2C",
-"W;	c #282A29",
-"X;	c #262827",
-"Y;	c #232425",
-"Z;	c #4C4D4D",
-"`;	c #383938",
-" >	c #5B595D",
-".>	c #908198",
-"+>	c #6A606D",
-"@>	c #504E4F",
-"#>	c #5A5A57",
-"$>	c #7E7E7A",
-"%>	c #6D6D6C",
-"&>	c #161817",
-"*>	c #151618",
-"=>	c #2B2C2F",
-"->	c #36383C",
-";>	c #1D1E21",
-">>	c #2A2C2F",
-",>	c #2B2F33",
-"'>	c #2C2F32",
-")>	c #1B1C20",
-"!>	c #17181A",
-"~>	c #1B1C1E",
-"{>	c #222325",
-"]>	c #2A2A2C",
-"^>	c #0B0C0D",
-"/>	c #030404",
-"(>	c #2B2C2C",
-"_>	c #1F1F17",
-":>	c #413F3F",
-"<>	c #423E4A",
-"[>	c #261C3E",
-"}>	c #322450",
-"|>	c #362554",
-"1>	c #2F2345",
-"2>	c #323430",
-"3>	c #313232",
-"4>	c #303231",
-"5>	c #2B2D2C",
-"6>	c #606061",
-"7>	c #787878",
-"8>	c #323231",
-"9>	c #3E3F3B",
-"0>	c #7E7777",
-"a>	c #A5A3A2",
-"b>	c #AFAFAE",
-"c>	c #7499A1",
-"d>	c #79A1A8",
-"e>	c #7EA5AC",
-"f>	c #7DA4AC",
-"g>	c #7AA1A8",
-"h>	c #739AA1",
-"i>	c #8D8C87",
-"j>	c #1F1D1B",
-"k>	c #171719",
-"l>	c #1A1C1B",
-"m>	c #0E0E10",
-"n>	c #212225",
-"o>	c #252628",
-"p>	c #3A3B40",
-"q>	c #23262A",
-"r>	c #313237",
-"s>	c #303237",
-"t>	c #202025",
-"u>	c #1D1E20",
-"v>	c #121315",
-"w>	c #2A2B2D",
-"x>	c #232325",
-"y>	c #09090C",
-"z>	c #030406",
-"A>	c #141518",
-"B>	c #2B2C2D",
-"C>	c #302E32",
-"D>	c #423C4E",
-"E>	c #281D42",
-"F>	c #281947",
-"G>	c #33264D",
-"H>	c #3B2B55",
-"I>	c #372A4A",
-"J>	c #32342E",
-"K>	c #333533",
-"L>	c #363837",
-"M>	c #2F302F",
-"N>	c #2A2A2A",
-"O>	c #313131",
-"P>	c #282825",
-"Q>	c #3E3E3F",
-"R>	c #2E302B",
-"S>	c #4C4B49",
-"T>	c #474A4C",
-"U>	c #879599",
-"V>	c #849FA4",
-"W>	c #92C5CE",
-"X>	c #9CD5DF",
-"Y>	c #A2DEE9",
-"Z>	c #A6E3EF",
-"`>	c #A8E5F2",
-" ,	c #AAE5F3",
-".,	c #ABE5F3",
-"+,	c #A9E4F2",
-"@,	c #A4E1F0",
-"#,	c #A1DFEF",
-"$,	c #9BD8E9",
-"%,	c #93CFE0",
-"&,	c #89C2D1",
-"*,	c #7CB0BE",
-"=,	c #6B95A1",
-"-,	c #161615",
-";,	c #1A1A19",
-">,	c #171717",
-",,	c #34373A",
-"',	c #2D3033",
-"),	c #2D2F33",
-"!,	c #1E201E",
-"~,	c #191B1B",
-"{,	c #181919",
-"],	c #151514",
-"^,	c #1B1B1A",
-"/,	c #29292B",
-"(,	c #292727",
-"_,	c #353237",
-":,	c #2E2B40",
-"<,	c #271D42",
-"[,	c #251742",
-"},	c #2F1F4A",
-"|,	c #312249",
-"1,	c #35264F",
-"2,	c #3A2B52",
-"3,	c #3E2C5C",
-"4,	c #362D47",
-"5,	c #353431",
-"6,	c #2E2E2E",
-"7,	c #232323",
-"8,	c #040403",
-"9,	c #050504",
-"0,	c #404C4E",
-"a,	c #608185",
-"b,	c #8CBBC4",
-"c,	c #A0DDE8",
-"d,	c #AAE8F5",
-"e,	c #AFEAF8",
-"f,	c #AFE9F7",
-"g,	c #AEE8F6",
-"h,	c #ADE7F6",
-"i,	c #ADE7F5",
-"j,	c #ABE6F5",
-"k,	c #AAE5F5",
-"l,	c #AAE4F5",
-"m,	c #A9E3F4",
-"n,	c #A9E2F4",
-"o,	c #A8E1F3",
-"p,	c #A7E0F3",
-"q,	c #A5DFF2",
-"r,	c #A0DDF1",
-"s,	c #97D7EB",
-"t,	c #8AC8DD",
-"u,	c #78B2C3",
-"v,	c #6292A0",
-"w,	c #616161",
-"x,	c #242424",
-"y,	c #141314",
-"z,	c #0F0E11",
-"A,	c #25252A",
-"B,	c #26272C",
-"C,	c #303537",
-"D,	c #313538",
-"E,	c #26292C",
-"F,	c #212124",
-"G,	c #212322",
-"H,	c #1B1D1C",
-"I,	c #191B19",
-"J,	c #181816",
-"K,	c #121210",
-"L,	c #010100",
-"M,	c #1A191C",
-"N,	c #2B2B29",
-"O,	c #2E2F2B",
-"P,	c #272431",
-"Q,	c #2E2A40",
-"R,	c #1D1639",
-"S,	c #1F173F",
-"T,	c #281C45",
-"U,	c #2C1F47",
-"V,	c #30224A",
-"W,	c #32254D",
-"X,	c #382A52",
-"Y,	c #3C2E57",
-"Z,	c #433161",
-"`,	c #372F43",
-" '	c #353533",
-".'	c #37474A",
-"+'	c #689197",
-"@'	c #97D3DC",
-"#'	c #A9EAF6",
-"$'	c #AEEBF8",
-"%'	c #B0EBF8",
-"&'	c #AFEAF7",
-"*'	c #ADE9F7",
-"='	c #AAE8F7",
-"-'	c #A7E6F6",
-";'	c #A3E5F5",
-">'	c #9FE3F4",
-",'	c #9CE1F4",
-"''	c #99E0F3",
-")'	c #98DFF3",
-"!'	c #99DEF2",
-"~'	c #9ADDF2",
-"{'	c #9CDDF2",
-"]'	c #9EDDF2",
-"^'	c #A0DDF2",
-"/'	c #A2DDF2",
-"('	c #A2DCF1",
-"_'	c #A2DBF1",
-":'	c #A0D9F0",
-"<'	c #98D7EF",
-"['	c #8ACEE8",
-"}'	c #77B6CD",
-"|'	c #6199AA",
-"1'	c #A7A7A7",
-"2'	c #1D1D1C",
-"3'	c #0D0C0F",
-"4'	c #1E1D22",
-"5'	c #191D20",
-"6'	c #303336",
-"7'	c #35373A",
-"8'	c #2F3033",
-"9'	c #242527",
-"0'	c #232524",
-"a'	c #1E1F20",
-"b'	c #1A1D1C",
-"c'	c #191A18",
-"d'	c #060604",
-"e'	c #29282F",
-"f'	c #201D2F",
-"g'	c #221D37",
-"h'	c #211B3C",
-"i'	c #1A163A",
-"j'	c #211A42",
-"k'	c #261C44",
-"l'	c #2C1E46",
-"m'	c #30214A",
-"n'	c #34254E",
-"o'	c #362851",
-"p'	c #3D2D57",
-"q'	c #42325C",
-"r'	c #493768",
-"s'	c #37323F",
-"t'	c #363635",
-"u'	c #2B2B2C",
-"v'	c #323333",
-"w'	c #282929",
-"x'	c #1D1E1D",
-"y'	c #2C3739",
-"z'	c #638B92",
-"A'	c #96D6E0",
-"B'	c #A6EAF7",
-"C'	c #ACEAF8",
-"D'	c #A9E9F7",
-"E'	c #A4E7F6",
-"F'	c #9FE5F6",
-"G'	c #99E3F5",
-"H'	c #92E0F4",
-"I'	c #8CDEF2",
-"J'	c #86DCF2",
-"K'	c #82DAF1",
-"L'	c #7FD8F0",
-"M'	c #7ED7F0",
-"N'	c #7ED6EF",
-"O'	c #7FD5EF",
-"P'	c #82D5EE",
-"Q'	c #87D5EF",
-"R'	c #8CD5EF",
-"S'	c #91D6EF",
-"T'	c #95D6EF",
-"U'	c #99D6EF",
-"V'	c #9BD7EF",
-"W'	c #9CD6EF",
-"X'	c #9BD5EE",
-"Y'	c #92D1EC",
-"Z'	c #81CAE7",
-"`'	c #6BAEC9",
-" )	c #588FA1",
-".)	c #0A0A0B",
-"+)	c #28282B",
-"@)	c #242529",
-"#)	c #2A2C30",
-"$)	c #373B3E",
-"%)	c #191C1E",
-"&)	c #2E3034",
-"*)	c #232426",
-"=)	c #262729",
-"-)	c #202123",
-";)	c #1C1E1F",
-">)	c #131212",
-",)	c #080807",
-"')	c #1E1E25",
-"))	c #1A1936",
-"!)	c #1C1736",
-"~)	c #1C1639",
-"{)	c #1E183D",
-"])	c #1F1A3F",
-"^)	c #231C43",
-"/)	c #291B45",
-"()	c #2E1F48",
-"_)	c #32234C",
-":)	c #372851",
-"<)	c #3C2C57",
-"[)	c #42305D",
-"})	c #49345E",
-"|)	c #4F3A71",
-"1)	c #333039",
-"2)	c #383738",
-"3)	c #212422",
-"4)	c #272928",
-"5)	c #222423",
-"6)	c #2F3230",
-"7)	c #0D0E0E",
-"8)	c #4B676B",
-"9)	c #83C1C9",
-"0)	c #9EE9F6",
-"a)	c #A9EBF8",
-"b)	c #ABEBF8",
-"c)	c #A9EAF7",
-"d)	c #A5E8F7",
-"e)	c #A0E7F6",
-"f)	c #9AE4F5",
-"g)	c #93E2F4",
-"h)	c #8CE0F3",
-"i)	c #84DDF2",
-"j)	c #7EDBF1",
-"k)	c #7AD9F1",
-"l)	c #78D8F0",
-"m)	c #76D6F0",
-"n)	c #75D4EF",
-"o)	c #73D3EE",
-"p)	c #72D1EE",
-"q)	c #71D0ED",
-"r)	c #70CEEC",
-"s)	c #71CDEC",
-"t)	c #74CDEB",
-"u)	c #7ACDEB",
-"v)	c #81CEEC",
-"w)	c #86CFEC",
-"x)	c #8BD0EC",
-"y)	c #90D0EC",
-"z)	c #94D0ED",
-"A)	c #96D0ED",
-"B)	c #93CEEC",
-"C)	c #83C7E8",
-"D)	c #6DBBDE",
-"E)	c #589DB9",
-"F)	c #4F4F4D",
-"G)	c #050506",
-"H)	c #1C1B1F",
-"I)	c #1E1E22",
-"J)	c #292E2F",
-"K)	c #35393D",
-"L)	c #24252A",
-"M)	c #1F1F22",
-"N)	c #1D1D2E",
-"O)	c #181836",
-"P)	c #1B1733",
-"Q)	c #1D1738",
-"R)	c #1F193E",
-"S)	c #21193F",
-"T)	c #271C44",
-"U)	c #2B1E47",
-"V)	c #31224B",
-"W)	c #392A53",
-"X)	c #3E2F5A",
-"Y)	c #453360",
-"Z)	c #4B3662",
-"`)	c #523F74",
-" !	c #323034",
-".!	c #0C0C0B",
-"+!	c #5C8389",
-"@!	c #91DEEA",
-"#!	c #9CE9F7",
-"$!	c #A5EAF7",
-"%!	c #A1E8F7",
-"&!	c #9DE6F6",
-"*!	c #97E4F6",
-"=!	c #91E2F5",
-"-!	c #89E0F4",
-";!	c #81DDF2",
-">!	c #7BDBF1",
-",!	c #77D9F1",
-"'!	c #76D8F0",
-")!	c #74D7F0",
-"!!	c #73D5EF",
-"~!	c #72D4EF",
-"{!	c #70D2EE",
-"]!	c #6FD0ED",
-"^!	c #6DCFEC",
-"/!	c #6CCDEC",
-"(!	c #6ACBEB",
-"_!	c #69C9EA",
-":!	c #67C7E9",
-"<!	c #67C6E8",
-"[!	c #6AC6E8",
-"}!	c #71C6E8",
-"|!	c #78C8E9",
-"1!	c #7FC8E9",
-"2!	c #84C9EA",
-"3!	c #88CAEA",
-"4!	c #8CCAEA",
-"5!	c #8BC9E9",
-"6!	c #7FC2E6",
-"7!	c #67BAE3",
-"8!	c #54A0C3",
-"9!	c #08090A",
-"0!	c #17181C",
-"a!	c #1F2222",
-"b!	c #1F2322",
-"c!	c #303338",
-"d!	c #24272B",
-"e!	c #27282A",
-"f!	c #212224",
-"g!	c #1E1E1F",
-"h!	c #111011",
-"i!	c #1D1C2C",
-"j!	c #181739",
-"k!	c #1C1637",
-"l!	c #1D1739",
-"m!	c #1E193D",
-"n!	c #231841",
-"o!	c #2B1C45",
-"p!	c #2E2048",
-"q!	c #32244D",
-"r!	c #3C2C56",
-"s!	c #41325D",
-"t!	c #483663",
-"u!	c #4F3A67",
-"v!	c #523F71",
-"w!	c #323230",
-"x!	c #0B0C0B",
-"y!	c #292B2A",
-"z!	c #2B2E2D",
-"A!	c #282B2A",
-"B!	c #2D2E2D",
-"C!	c #5A5A5A",
-"D!	c #171919",
-"E!	c #628E93",
-"F!	c #90E5F3",
-"G!	c #96E8F7",
-"H!	c #A0E9F7",
-"I!	c #9FE8F7",
-"J!	c #9AE7F6",
-"K!	c #95E5F6",
-"L!	c #8FE2F5",
-"M!	c #88E0F4",
-"N!	c #80DEF3",
-"O!	c #79DBF2",
-"P!	c #76DAF1",
-"Q!	c #74D8F0",
-"R!	c #72D7F0",
-"S!	c #71D6F0",
-"T!	c #70D5EF",
-"U!	c #6DD0E8",
-"V!	c #65C0D7",
-"W!	c #5FB5CA",
-"X!	c #5EB2C9",
-"Y!	c #5FB9D2",
-"Z!	c #63C4E1",
-"`!	c #66C9EA",
-" ~	c #64C7E9",
-".~	c #62C4E8",
-"+~	c #60C3E7",
-"@~	c #5EC1E6",
-"#~	c #5FBFE6",
-"$~	c #64BFE5",
-"%~	c #6BC0E6",
-"&~	c #72C1E6",
-"*~	c #77C1E6",
-"=~	c #7CC2E6",
-"-~	c #80C3E6",
-";~	c #81C1E6",
-">~	c #76BBE4",
-",~	c #5CB1E0",
-"'~	c #4D9DC5",
-")~	c #EBEBEB",
-"!~	c #1C1D1E",
-"~~	c #1F1F23",
-"{~	c #35383C",
-"]~	c #353A3D",
-"^~	c #22272A",
-"/~	c #111013",
-"(~	c #0F0D10",
-"_~	c #1A1B2F",
-":~	c #1B163A",
-"<~	c #1C1738",
-"[~	c #1E183A",
-"}~	c #20173D",
-"|~	c #271B43",
-"1~	c #2C1D46",
-"2~	c #352550",
-"3~	c #392A56",
-"4~	c #3E2E5A",
-"5~	c #45345E",
-"6~	c #4C3A64",
-"7~	c #533D6B",
-"8~	c #4E3E65",
-"9~	c #323431",
-"0~	c #343634",
-"a~	c #2D2F2E",
-"b~	c #282A28",
-"c~	c #292A28",
-"d~	c #262A2B",
-"e~	c #3E3E3B",
-"f~	c #588086",
-"g~	c #89E3F2",
-"h~	c #8DE6F6",
-"i~	c #98E7F6",
-"j~	c #93E5F5",
-"k~	c #8EE3F5",
-"l~	c #88E1F4",
-"m~	c #81DFF4",
-"n~	c #7ADCF3",
-"o~	c #75DAF2",
-"p~	c #72D9F1",
-"q~	c #71D8F0",
-"r~	c #6FD6F0",
-"s~	c #6ED5F0",
-"t~	c #6DD1EA",
-"u~	c #5BA7B9",
-"v~	c #497C88",
-"w~	c #365258",
-"x~	c #2B3A3E",
-"y~	c #2A3A3C",
-"z~	c #304A52",
-"A~	c #3E6F7D",
-"B~	c #4F97AE",
-"C~	c #59BBDB",
-"D~	c #5CC2E7",
-"E~	c #5ABFE6",
-"F~	c #59BDE5",
-"G~	c #57BBE4",
-"H~	c #56B9E3",
-"I~	c #59B8E3",
-"J~	c #60B8E3",
-"K~	c #66B9E3",
-"L~	c #6BBAE3",
-"M~	c #70BAE3",
-"N~	c #75BBE3",
-"O~	c #75B9E3",
-"P~	c #67B1DF",
-"Q~	c #4DA7DC",
-"R~	c #4292BE",
-"S~	c #30302F",
-"T~	c #1C1D1F",
-"U~	c #1E1E20",
-"V~	c #191B1E",
-"W~	c #1F2225",
-"X~	c #262B2D",
-"Y~	c #212629",
-"Z~	c #27272B",
-"`~	c #121013",
-" {	c #181A2C",
-".{	c #1B173B",
-"+{	c #20173A",
-"@{	c #23183D",
-"#{	c #2A1C45",
-"${	c #30234B",
-"%{	c #362751",
-"&{	c #3B2D55",
-"*{	c #403159",
-"={	c #46365F",
-"-{	c #4E3B66",
-";{	c #57426D",
-">{	c #49395D",
-",{	c #333430",
-"'{	c #2F3130",
-"){	c #151717",
-"!{	c #2D2F2F",
-"~{	c #709CA2",
-"{{	c #7FD4E2",
-"]{	c #82E3F5",
-"^{	c #8EE5F6",
-"/{	c #90E5F5",
-"({	c #8DE4F5",
-"_{	c #87E2F4",
-":{	c #82E0F4",
-"<{	c #7CDDF3",
-"[{	c #75DBF2",
-"}{	c #71D9F1",
-"|{	c #6FD8F1",
-"1{	c #6ED7F0",
-"2{	c #6CD6EF",
-"3{	c #6BD4EF",
-"4{	c #67C9E1",
-"5{	c #528F9C",
-"6{	c #2A3A3E",
-"7{	c #417B8D",
-"8{	c #50ADCD",
-"9{	c #55BCE5",
-"0{	c #54BAE4",
-"a{	c #52B7E3",
-"b{	c #50B5E2",
-"c{	c #4FB3E0",
-"d{	c #50B1E0",
-"e{	c #56B2E0",
-"f{	c #5BB2E0",
-"g{	c #60B2E0",
-"h{	c #66B2E0",
-"i{	c #69B2E0",
-"j{	c #66AFDF",
-"k{	c #51A4DB",
-"l{	c #409ED8",
-"m{	c #3B81AA",
-"n{	c #1F1F1E",
-"o{	c #1A1C1E",
-"p{	c #2B2D31",
-"q{	c #2E3033",
-"r{	c #25272B",
-"s{	c #24272A",
-"t{	c #0E0E0F",
-"u{	c #1A182D",
-"v{	c #1E1739",
-"w{	c #1F1537",
-"x{	c #23163C",
-"y{	c #27183F",
-"z{	c #2C1C46",
-"A{	c #2F214A",
-"B{	c #392A51",
-"C{	c #3E2E56",
-"D{	c #43335C",
-"E{	c #4C3664",
-"F{	c #503E68",
-"G{	c #5C4A73",
-"H{	c #423550",
-"I{	c #30312B",
-"J{	c #312F30",
-"K{	c #353333",
-"L{	c #171818",
-"M{	c #181718",
-"N{	c #2D2B29",
-"O{	c #7AC4CF",
-"P{	c #7AE3F5",
-"Q{	c #7FE2F5",
-"R{	c #87E3F5",
-"S{	c #86E2F4",
-"T{	c #7DDEF3",
-"U{	c #77DCF3",
-"V{	c #72DBF2",
-"W{	c #6ED9F1",
-"X{	c #6CD7F1",
-"Y{	c #6AD6F0",
-"Z{	c #69D5EF",
-"`{	c #67D3EF",
-" ]	c #66CEE8",
-".]	c #4F8E9B",
-"+]	c #3C778A",
-"@]	c #4CAFD5",
-"#]	c #4FB6E3",
-"$]	c #4DB4E1",
-"%]	c #4BB1E0",
-"&]	c #49AFDF",
-"*]	c #48ACDE",
-"=]	c #49ABDE",
-"-]	c #4DABDE",
-";]	c #51AADD",
-">]	c #57AADD",
-",]	c #5BAADD",
-"']	c #5CA9DC",
-")]	c #51A2DA",
-"!]	c #3C99D6",
-"~]	c #3790C8",
-"{]	c #282624",
-"]]	c #151718",
-"^]	c #232626",
-"/]	c #272929",
-"(]	c #1C1C20",
-"_]	c #0E0F10",
-":]	c #161716",
-"<]	c #19132A",
-"[]	c #1F1538",
-"}]	c #221639",
-"|]	c #25183E",
-"1]	c #2A1C43",
-"2]	c #33234C",
-"3]	c #37284F",
-"4]	c #3A2A50",
-"5]	c #3F2F55",
-"6]	c #4D3B64",
-"7]	c #503F66",
-"8]	c #624A7A",
-"9]	c #3B2C48",
-"0]	c #2F322E",
-"a]	c #2D302F",
-"b]	c #2D2E2F",
-"c]	c #333131",
-"d]	c #464442",
-"e]	c #7ADCEC",
-"f]	c #74E0F4",
-"g]	c #7AE1F4",
-"h]	c #7EE1F4",
-"i]	c #7CDFF3",
-"j]	c #78DDF3",
-"k]	c #73DCF2",
-"l]	c #6FDAF1",
-"m]	c #6BD8F1",
-"n]	c #69D7F0",
-"o]	c #67D5EF",
-"p]	c #65D4EF",
-"q]	c #64D2EE",
-"r]	c #63D1EE",
-"s]	c #53A3B6",
-"t]	c #3F89A5",
-"u]	c #49B3E0",
-"v]	c #48B0E0",
-"w]	c #46ADDE",
-"x]	c #44ABDE",
-"y]	c #42A9DD",
-"z]	c #41A6DC",
-"A]	c #43A5DB",
-"B]	c #46A4DA",
-"C]	c #4BA3DA",
-"D]	c #4EA3DA",
-"E]	c #4FA1D9",
-"F]	c #499DD8",
-"G]	c #3895D5",
-"H]	c #3492D3",
-"I]	c #32749F",
-"J]	c #333230",
-"K]	c #0C0E0F",
-"L]	c #161127",
-"M]	c #211538",
-"N]	c #25173E",
-"O]	c #291B42",
-"P]	c #2C1F43",
-"Q]	c #322447",
-"R]	c #37294D",
-"S]	c #3B2C50",
-"T]	c #403055",
-"U]	c #47375E",
-"V]	c #4B3B61",
-"W]	c #533F65",
-"X]	c #635078",
-"Y]	c #342D3B",
-"Z]	c #2D312D",
-"`]	c #242623",
-" ^	c #2D2D2C",
-".^	c #69AEB8",
-"+^	c #73E0F3",
-"@^	c #6FDFF3",
-"#^	c #73DEF3",
-"$^	c #75DEF3",
-"%^	c #73DDF2",
-"&^	c #6FDBF2",
-"*^	c #6BD9F1",
-"=^	c #68D7F0",
-"-^	c #65D6F0",
-";^	c #64D4EF",
-">^	c #62D3EE",
-",^	c #60D1EE",
-"'^	c #5FD0ED",
-")^	c #5CC7E3",
-"!^	c #427883",
-"~^	c #315967",
-"{^	c #44A7D0",
-"]^	c #43ACDE",
-"^^	c #41AADD",
-"/^	c #40A8DC",
-"(^	c #3DA5DB",
-"_^	c #3CA2DA",
-":^	c #3CA0D9",
-"<^	c #3D9ED8",
-"[^	c #409DD8",
-"}^	c #439CD8",
-"|^	c #429AD7",
-"1^	c #3C96D5",
-"2^	c #3290D3",
-"3^	c #2F8DD2",
-"4^	c #2F7EB3",
-"5^	c #31302D",
-"6^	c #18112C",
-"7^	c #201539",
-"8^	c #24163A",
-"9^	c #28193F",
-"0^	c #2C1D44",
-"a^	c #2E2045",
-"b^	c #392B4E",
-"c^	c #3E2E51",
-"d^	c #423158",
-"e^	c #49385F",
-"f^	c #523E66",
-"g^	c #574763",
-"h^	c #5C5764",
-"i^	c #32342F",
-"j^	c #272923",
-"k^	c #6CC0CE",
-"l^	c #6CDEF3",
-"m^	c #6ADDF3",
-"n^	c #6ADCF3",
-"o^	c #6ADBF2",
-"p^	c #69DAF2",
-"q^	c #66D8F1",
-"r^	c #64D7F0",
-"s^	c #62D5F0",
-"t^	c #60D4EF",
-"u^	c #5ED2EE",
-"v^	c #5DD0EE",
-"w^	c #5BCFED",
-"x^	c #5ACDED",
-"y^	c #52B8D1",
-"z^	c #314E54",
-"A^	c #4399BC",
-"B^	c #3FAADD",
-"C^	c #3DA6DC",
-"D^	c #3BA4DB",
-"E^	c #39A1DA",
-"F^	c #389ED9",
-"G^	c #379CD8",
-"H^	c #369AD7",
-"I^	c #3798D6",
-"J^	c #3896D5",
-"K^	c #3693D4",
-"L^	c #318FD2",
-"M^	c #2C8BD1",
-"N^	c #2B89D0",
-"O^	c #2A81BE",
-"P^	c #32302F",
-"Q^	c #202221",
-"R^	c #27292A",
-"S^	c #25262B",
-"T^	c #2B2B2F",
-"U^	c #0B0D0D",
-"V^	c #1A1B18",
-"W^	c #190F31",
-"X^	c #22153A",
-"Y^	c #25173A",
-"Z^	c #2A1C40",
-"`^	c #2C1E42",
-" /	c #312248",
-"./	c #332549",
-"+/	c #382A4D",
-"@/	c #3C2A53",
-"#/	c #493B5D",
-"$/	c #4A4259",
-"%/	c #404142",
-"&/	c #2C2F26",
-"*/	c #69C8D8",
-"=/	c #67DCF2",
-"-/	c #66DBF2",
-";/	c #65DAF2",
-">/	c #63D8F1",
-",/	c #61D7F1",
-"'/	c #60D6F0",
-")/	c #5ED4EF",
-"!/	c #5DD3EF",
-"~/	c #5BD1EE",
-"{/	c #59CFEE",
-"]/	c #58CEED",
-"^/	c #56CCEC",
-"//	c #55CBEC",
-"(/	c #4CADC5",
-"_/	c #458FAE",
-":/	c #3CA7DC",
-"</	c #38A2DA",
-"[/	c #36A0D9",
-"}/	c #359DD8",
-"|/	c #349AD7",
-"1/	c #3298D6",
-"2/	c #3195D5",
-"3/	c #3193D4",
-"4/	c #2F90D3",
-"5/	c #2D8DD1",
-"6/	c #2B8AD1",
-"7/	c #2987CF",
-"8/	c #2885CE",
-"9/	c #2882C3",
-"0/	c #27282D",
-"a/	c #090B0B",
-"b/	c #1B1C1A",
-"c/	c #1A1131",
-"d/	c #21163A",
-"e/	c #26173B",
-"f/	c #2D1F43",
-"g/	c #312348",
-"h/	c #34254B",
-"i/	c #3A2C51",
-"j/	c #463D59",
-"k/	c #3D3A44",
-"l/	c #363735",
-"m/	c #434340",
-"n/	c #63C8DA",
-"o/	c #62DBF2",
-"p/	c #61D9F1",
-"q/	c #60D8F1",
-"r/	c #5ED6F1",
-"s/	c #5DD5F0",
-"t/	c #5BD3EF",
-"u/	c #59D2EE",
-"v/	c #58D0ED",
-"w/	c #56CFED",
-"x/	c #55CDEC",
-"y/	c #53CBEC",
-"z/	c #51C9EB",
-"A/	c #50C8EA",
-"B/	c #47A8C2",
-"C/	c #488DAA",
-"D/	c #38A4DA",
-"E/	c #349FD9",
-"F/	c #339CD8",
-"G/	c #3299D7",
-"H/	c #3097D5",
-"I/	c #2F94D4",
-"J/	c #2E91D4",
-"K/	c #2C8FD2",
-"L/	c #2B8CD1",
-"M/	c #2989D0",
-"N/	c #2887CF",
-"O/	c #2784CD",
-"P/	c #257FCB",
-"Q/	c #2179BE",
-"R/	c #284D65",
-"S/	c #3A3534",
-"T/	c #222021",
-"U/	c #1C1E23",
-"V/	c #26272A",
-"W/	c #292A2C",
-"X/	c #090A0A",
-"Y/	c #1E201F",
-"Z/	c #191234",
-"`/	c #23173A",
-" (	c #26193C",
-".(	c #291D3D",
-"+(	c #2C1C41",
-"@(	c #33244C",
-"#(	c #3A314B",
-"$(	c #3A373F",
-"%(	c #343533",
-"&(	c #4B4A49",
-"*(	c #5FC6D9",
-"=(	c #5ED8F1",
-"-(	c #5CD7F1",
-";(	c #5BD6F0",
-">(	c #5AD4F0",
-",(	c #58D3EF",
-"'(	c #56D1EE",
-")(	c #55D0ED",
-"!(	c #53CEED",
-"~(	c #52CCEC",
-"{(	c #50CAEB",
-"](	c #4EC8EB",
-"^(	c #4DC7EA",
-"/(	c #4CC5E9",
-"((	c #44A5C1",
-"_(	c #4C95B4",
-":(	c #36A1D9",
-"<(	c #319BD7",
-"[(	c #3098D6",
-"}(	c #2F96D5",
-"|(	c #2E93D4",
-"1(	c #2C91D3",
-"2(	c #2B8ED2",
-"3(	c #2A8BD1",
-"4(	c #2888D0",
-"5(	c #2482CD",
-"6(	c #207AC9",
-"7(	c #1B71C4",
-"8(	c #166AC1",
-"9(	c #1566B0",
-"0(	c #403D3D",
-"a(	c #1E1D1E",
-"b(	c #080A0B",
-"c(	c #1C1E1E",
-"d(	c #1C1337",
-"e(	c #23193B",
-"f(	c #271A3C",
-"g(	c #271A43",
-"h(	c #322A49",
-"i(	c #35363D",
-"j(	c #2D2F30",
-"k(	c #413F3D",
-"l(	c #5CC5D8",
-"m(	c #59D7F1",
-"n(	c #58D5F0",
-"o(	c #56D3EF",
-"p(	c #55D2EE",
-"q(	c #53D0ED",
-"r(	c #51CFED",
-"s(	c #50CDEC",
-"t(	c #4ECBEC",
-"u(	c #4DCAEB",
-"v(	c #4CC8EA",
-"w(	c #4AC6E9",
-"x(	c #49C4E9",
-"y(	c #49C3E8",
-"z(	c #42A5C1",
-"A(	c #489CC2",
-"B(	c #319CD7",
-"C(	c #3198D6",
-"D(	c #3196D5",
-"E(	c #2D90D3",
-"F(	c #2A8DD1",
-"G(	c #2687CE",
-"H(	c #207ECB",
-"I(	c #1A75C6",
-"J(	c #166DC2",
-"K(	c #1367BF",
-"L(	c #1265BE",
-"M(	c #1264BD",
-"N(	c #1660A3",
-"O(	c #423C39",
-"P(	c #1F1439",
-"Q(	c #231839",
-"R(	c #261F3E",
-"S(	c #33323A",
-"T(	c #33342D",
-"U(	c #31322F",
-"V(	c #54534B",
-"W(	c #57C2D7",
-"X(	c #55D5EF",
-"Y(	c #54D3EF",
-"Z(	c #52D2EE",
-"`(	c #51D0ED",
-" _	c #4FCFEC",
-"._	c #4ECDEC",
-"+_	c #4DCBEB",
-"@_	c #4CCAEB",
-"#_	c #4BC8EA",
-"$_	c #49C6E9",
-"%_	c #48C4E8",
-"&_	c #46C2E8",
-"*_	c #46C1E7",
-"=_	c #3DA3BE",
-"-_	c #527787",
-";_	c #42A2D3",
-">_	c #3499D6",
-",_	c #3595D5",
-"'_	c #2E8FD2",
-")_	c #2485CD",
-"!_	c #1D7BC9",
-"~_	c #1772C5",
-"{_	c #146CC2",
-"]_	c #1369C1",
-"^_	c #1263BD",
-"/_	c #1164BD",
-"(_	c #1A568C",
-"__	c #1A1B1C",
-":_	c #232328",
-"<_	c #19181F",
-"[_	c #241F40",
-"}_	c #292534",
-"|_	c #333331",
-"1_	c #2F322B",
-"2_	c #4E4A4B",
-"3_	c #3F8E9C",
-"4_	c #3F92A2",
-"5_	c #3F91A1",
-"6_	c #3D8F9F",
-"7_	c #3D8E9E",
-"8_	c #3C8D9E",
-"9_	c #3B8C9D",
-"0_	c #3B8B9D",
-"a_	c #39899D",
-"b_	c #38889C",
-"c_	c #37889D",
-"d_	c #36879C",
-"e_	c #36879D",
-"f_	c #327789",
-"g_	c #5096B6",
-"h_	c #3BA0D9",
-"i_	c #3F9BD7",
-"j_	c #3994D4",
-"k_	c #2B88CF",
-"l_	c #1E7CC9",
-"m_	c #1672C5",
-"n_	c #146EC3",
-"o_	c #1161BC",
-"p_	c #1162B3",
-"q_	c #1D496A",
-"r_	c #101111",
-"s_	c #1F1E21",
-"t_	c #09090B",
-"u_	c #34332E",
-"v_	c #598FA8",
-"w_	c #51A9D9",
-"x_	c #3F99D6",
-"y_	c #378FD1",
-"z_	c #2882CC",
-"A_	c #1E79C8",
-"B_	c #1773C5",
-"C_	c #146FC3",
-"D_	c #1162BC",
-"E_	c #175893",
-"F_	c #444342",
-"G_	c #464642",
-"H_	c #5E93AB",
-"I_	c #56A6D2",
-"J_	c #4198D5",
-"K_	c #378CD0",
-"L_	c #2C84CC",
-"M_	c #237CC9",
-"N_	c #156FC3",
-"O_	c #1160BB",
-"P_	c #115EA8",
-"Q_	c #1B4566",
-"R_	c #5997B6",
-"S_	c #57A7D8",
-"T_	c #4598D4",
-"U_	c #3E90D2",
-"V_	c #3388CE",
-"W_	c #287FCA",
-"X_	c #1E77C6",
-"Y_	c #1670C4",
-"Z_	c #1162B7",
-"`_	c #1A4F7E",
-" :	c #5595B2",
-".:	c #56A2CC",
-"+:	c #4DA2D9",
-"@:	c #4C9BD6",
-"#:	c #4594D3",
-"$:	c #398BCF",
-"%:	c #2C82CB",
-"&:	c #2078C7",
-"*:	c #1770C4",
-"=:	c #1164BA",
-"-:	c #185287",
-";:	c #5692AC",
-">:	c #4D9EC9",
-",:	c #47A2D8",
-"':	c #4F9FD8",
-"):	c #509CD6",
-"!:	c #4795D3",
-"~:	c #3B8CD0",
-"{:	c #2E83CB",
-"]:	c #2279C7",
-"^:	c #1871C4",
-"/:	c #1163B9",
-"(:	c #185388",
-"_:	c #4892B7",
-"::	c #40A0D6",
-"<:	c #429BD6",
-"[:	c #519FD7",
-"}:	c #4F9BD6",
-"|:	c #4694D3",
-"1:	c #3A8CD0",
-"2:	c #2F83CC",
-"3:	c #237AC7",
-"4:	c #1161BB",
-"5:	c #1060B0",
-"6:	c #195082",
-"7:	c #4292B8",
-"8:	c #3299D5",
-"9:	c #4098D5",
-"0:	c #4D9CD6",
-"a:	c #4A99D5",
-"b:	c #4192D2",
-"c:	c #388ACF",
-"d:	c #2D82CB",
-"e:	c #1163BC",
-"f:	c #125BA1",
-"g:	c #1A4A73",
-"h:	c #448FB5",
-"i:	c #2C96D3",
-"j:	c #3893D2",
-"k:	c #4699D5",
-"l:	c #4495D4",
-"m:	c #3C8FD1",
-"n:	c #3488CE",
-"o:	c #2A81CA",
-"p:	c #2178C7",
-"q:	c #1164B7",
-"r:	c #17568E",
-"s:	c #1A3D58",
-"t:	c #4A89A6",
-"u:	c #3097D1",
-"v:	c #2B8DD0",
-"w:	c #3D94D3",
-"x:	c #3D92D2",
-"y:	c #2F85CD",
-"z:	c #277FCA",
-"A:	c #1165BE",
-"B:	c #135CA1",
-"C:	c #1B4C75",
-"D:	c #3892C2",
-"E:	c #1F88CE",
-"F:	c #318DD0",
-"G:	c #368ED1",
-"H:	c #3289CF",
-"I:	c #2B83CC",
-"J:	c #237DC9",
-"K:	c #1C76C6",
-"L:	c #1266BE",
-"M:	c #165896",
-"N:	c #1B3F59",
-"O:	c #438AAC",
-"P:	c #218CCF",
-"Q:	c #2184CD",
-"R:	c #2E89CF",
-"S:	c #2E87CE",
-"T:	c #2881CB",
-"U:	c #217BC8",
-"V:	c #1B75C6",
-"W:	c #1165BD",
-"X:	c #175994",
-"Y:	c #1C384C",
-"Z:	c #3490C4",
-"`:	c #1981CB",
-" <	c #2282CC",
-".<	c #2884CC",
-"+<	c #2680CB",
-"@<	c #1C3F59",
-"#<	c #44819E",
-"$<	c #238CCE",
-"%<	c #187DCA",
-"&<	c #1F7FCA",
-"*<	c #227ECA",
-"=<	c #207BC8",
-"-<	c #1771C4",
-";<	c #1C4F7B",
-"><	c #3A88B4",
-",<	c #1980CB",
-"'<	c #177AC8",
-")<	c #1B7AC8",
-"!<	c #1D79C8",
-"~<	c #156DC2",
-"{<	c #1469C1",
-"]<	c #1060BB",
-"^<	c #135CA6",
-"/<	c #1F3749",
-"(<	c #318AC0",
-"_<	c #177BC9",
-":<	c #1677C7",
-"<<	c #1876C6",
-"[<	c #1A74C6",
-"}<	c #166DC3",
-"|<	c #105FBB",
-"1<	c #105FBA",
-"2<	c #175593",
-"3<	c #2787C5",
-"4<	c #1574C6",
-"5<	c #1572C4",
-"6<	c #166EC3",
-"7<	c #156AC1",
-"8<	c #105DB9",
-"9<	c #105EB9",
-"0<	c #195085",
-"a<	c #2282C6",
-"b<	c #1575C6",
-"c<	c #1571C4",
-"d<	c #105BB8",
-"e<	c #0F5BB7",
-"f<	c #1B4E7F",
-"g<	c #39637B",
-"h<	c #207EC5",
-"i<	c #0F5AB7",
-"j<	c #0F5AB6",
-"k<	c #1B4D7F",
-"l<	c #366279",
-"m<	c #1F7BC4",
-"n<	c #0F58B6",
-"o<	c #0E58B4",
-"p<	c #1B4C7E",
-"q<	c #1E79C3",
-"r<	c #0E56B5",
-"s<	c #0D56B3",
-"t<	c #1B4B7E",
-"u<	c #386178",
-"v<	c #1E77C2",
-"w<	c #0D54B3",
-"x<	c #0D54B2",
-"y<	c #1B497E",
-"z<	c #365F78",
-"A<	c #1D74C1",
-"B<	c #0D52B2",
-"C<	c #0C52B1",
-"D<	c #1A487D",
-"E<	c #365E79",
-"F<	c #1D72C0",
-"G<	c #0C50B1",
-"H<	c #0C50B0",
-"I<	c #1A477D",
-"J<	c #365C78",
-"K<	c #1C70BE",
-"L<	c #0F5DB8",
-"M<	c #0E58B6",
-"N<	c #0D57B5",
-"O<	c #0D55B3",
-"P<	c #0C53B2",
-"Q<	c #0C51B1",
-"R<	c #1A487E",
-"S<	c #1E5786",
-"T<	c #19517F",
-"U<	c #194F7E",
-"V<	c #184E7D",
-"W<	c #184D7C",
-"X<	c #174B7C",
-"Y<	c #174A7B",
-"Z<	c #17497B",
-"`<	c #16477A",
-" [	c #164578",
-".[	c #164478",
-"+[	c #154379",
-"@[	c #154378",
-"#[	c #14447A",
-"$[	c #1A3B5D",
-"%[	c #4372A6",
-"&[	c #4276B5",
-"*[	c #3F75BB",
-"=[	c #3B71B9",
-"-[	c #366BB4",
-";[	c #3161A4",
-">[	c #375D8F",
-",[	c #45709F",
-"'[	c #346FB6",
-")[	c #336EBF",
-"![	c #4979C2",
-"~[	c #527EC4",
-"{[	c #527DC3",
-"][	c #4B77C1",
-"^[	c #3366B9",
-"/[	c #1F57B0",
-"([	c #204E99",
-"_[	c #426E9E",
-":[	c #2969B9",
-"<[	c #2863B9",
-"[[	c #4A79C2",
-"}[	c #547FC4",
-"|[	c #547EC4",
-"1[	c #537DC3",
-"2[	c #537CC3",
-"3[	c #4D76BF",
-"4[	c #2E5EB4",
-"5[	c #0F47AB",
-"6[	c #174697",
-"7[	c #2A67B4",
-"8[	c #1554B2",
-"9[	c #3469BA",
-"0[	c #4473BF",
-"a[	c #4774BF",
-"b[	c #4673BE",
-"c[	c #4571BD",
-"d[	c #4671BD",
-"e[	c #436EBB",
-"f[	c #3763B6",
-"g[	c #1749AA",
-"h[	c #083EA6",
-"i[	c #173E88",
-"j[	c #3468A2",
-"k[	c #0E51B2",
-"l[	c #1652B0",
-"m[	c #2C61B6",
-"n[	c #3265B8",
-"o[	c #3364B8",
-"p[	c #3262B7",
-"q[	c #3161B5",
-"r[	c #3260B5",
-"s[	c #315EB4",
-"t[	c #2C5AB1",
-"u[	c #1849A9",
-"v[	c #073AA3",
-"w[	c #0C3C98",
-"x[	c #2562AF",
-"y[	c #0A4AAD",
-"z[	c #0F4BAD",
-"A[	c #1B53B0",
-"B[	c #2056B1",
-"C[	c #2055B0",
-"D[	c #1F53AF",
-"E[	c #1F52AE",
-"F[	c #1F51AD",
-"G[	c #1E4FAC",
-"H[	c #1B4BAA",
-"I[	c #0E40A5",
-"J[	c #0538A1",
-"K[	c #0639A0",
-"L[	c #1B386D",
-"M[	c #1858B1",
-"N[	c #0A48AB",
-"O[	c #0946AA",
-"P[	c #0C47AA",
-"Q[	c #0E47AA",
-"R[	c #0F46A9",
-"S[	c #0E45A8",
-"T[	c #0E43A7",
-"U[	c #0E42A6",
-"V[	c #0D40A5",
-"W[	c #0A3DA3",
-"X[	c #0639A2",
-"Y[	c #0537A1",
-"Z[	c #0437A1",
-"`[	c #183775",
-" }	c #1454AF",
-".}	c #0944A9",
-"+}	c #0843A8",
-"@}	c #0841A7",
-"#}	c #0740A6",
-"$}	c #073EA5",
-"%}	c #073DA4",
-"&}	c #073BA3",
-"*}	c #0435A0",
-"=}	c #153674",
-"-}	c #1351AB",
-";}	c #073FA6",
-">}	c #073CA4",
-",}	c #063BA3",
-"'}	c #04359F",
-")}	c #04349E",
-"!}	c #17336A",
-"~}	c #164D9F",
-"{}	c #0843A9",
-"]}	c #03339E",
-"^}	c #053396",
-"/}	c #1B2F56",
-"(}	c #194587",
-"_}	c #0333A0",
-":}	c #0D337F",
-"<}	c #114193",
-"[}	c #03329F",
-"}}	c #06318D",
-"|}	c #152B57",
-"1}	c #193462",
-"2}	c #0F3D91",
-"3}	c #063CA4",
-"4}	c #05308C",
-"5}	c #122E64",
-"6}	c #1B3053",
-"7}	c #123A81",
-"8}	c #083997",
-"9}	c #0437A2",
-"0}	c #0436A1",
-"a}	c #053397",
-"b}	c #0C317E",
-"c}	c #152B58",
-"d}	c #1A2E4D",
-"e}	c #153266",
-"f}	c #11326F",
-"g}	c #0F306E",
-"h}	c #132E64",
-"i}	c #172A50",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                . + @ # $                                                                               ",
-"                                                                                                            % & * = - ; > - ,                                                                           ",
-"                                                                                                        ' ) ! ~ { ] ^ / ( _ : < [                                                                       ",
-"                                                                                                    } | 1 2 3 4 5 6 7 8 9 0 a b c d e                                                                   ",
-"                                                                                                    f g h i j k l m n o 8 0 a p q r s t u                                                               ",
-"                                                                                                v w x y z A B C D E F G m m ^ H I J K L M N O                                                           ",
-"                                                                                        P Q $ R S T U V W X Y Z `  ...n +.@.#.$.%.&.*.=.-.;.>.,.'.                                                      ",
-"                                                                                    ).!.~.{.P ].^./.(._.:.<.[.}.|.1. .2.3.4.5.6.7.8.9.0.a.4.b.c.d.e.                                                    ",
-"                                                                            f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.A.4.B.C.D.I 7.E.F.G.H.I.J.K.L.M.                                                  ",
-"                                                                        N.O.P.Q.R.S.T.l.U.V.R.W.X.Y.Z.`. +.+++@+#+` $+%+7 &+*+=+-+;+I 7.>+>+,+'+)+!+~+{+                                                ",
-"                                                                  ]+^+/+(+_+:+<+[+}+|+1+2+3+4+5+6+7+2+8+9+0+a+b+c+d+,.G +.3.e+f+g+h+i+j+k+l+m+n+o+o+p+q+                                                ",
-"                                                          r+s+t+u+v+w+x+y+z+A+B+C+D+E+F+G+H+I+J+K+L+M+N+O+P+Q+R+S+T+U+V+G B.W+X+Y+Z+`+ @.@+@@@#@$@%@&@                                                  ",
-"                                                    *@| =@-@;@>@,@'@)@!@~@{@]@^@/@(@_@:@<@[@}@|@1@1 2@3@4@5@6@7@8@9@0@^.+.B.b.g+a@G o+^.b@c@d@e@f@g@h@                                                  ",
-"                                                i@j@k@l@m@n@o@p@q@r@s@w+t@u@v@w@x@y@z@A@B@C@y@D@E@F@G@H@I@J@K@L@M@N@O@P@Q@B.A.R@S@T@a.U@V@W@X@Y@Z@`@ #                                                  ",
-"                                      .#    +#@###$#%#&#*#=#-#;#>#,#'#)#!#~#{#]@]#<@^#/#(#_#:#<#[#}#|#1#2#2#K@3#4#5#F.6#7#8#8#9#0#a#b#c#d#e#f#g#h#i#                                                    ",
-"                                j#k#l#m#n#o#p#,+q#r#s#t#u#v#=#w#x#y#`+z#A#B#C#~#D#E#F#G#w@H#I#J#K#L#M#H@N#O#P#Q#R#S#d T#U#V#@#W#X#Y#Z#`# $.$+$@$#$$$                                                    ",
-"                          %$&$A.; *$=$-$>#;$>$,$'$)$!$~${$]$^$/$($_$d+:$<$[$}$!#|$1$2$2$3$4$5$6$7$L#M#8$9$0$a$b$n#c$d$e$f$g$h$$.i$j$k$l$m$n$o$p$q$r$                                                    ",
-"                  s$t$u$F.v$w$x$y$z$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$G@W$D#X$Y$Z$v@`$ %.%+%@%~@#%$%%%- f+&%*%=%-%;%>%,%'%)%!%~%{%]%^%/%(%                                                    ",
-"      _%}     :%<%,+[%}%|%1%2%3%=%4%5%6%7%8%9%0%,$a%$.b%b%c%d%e%f%g%h%i%j%k%l%9#m%J#n%o%p%q%r%s%t%7$u%v%w%x%3.C.7 F 7 L.q y%z%A%B%C%C%D%E%F%G%H%I%J%                                                    ",
-"      K%- L%M%N%O%P%Q%R%S%T%U%V%5%x$W%X%Y%Z%`% &.&q#+&;@@&#&d%$&^$%&&&Q#*&=&-&T$;&>&,&q%Z$'&P+)&!&~&$##./ F 4.g$g$@.{&l%]&8.;%^&/&(&_&:&<&[&}&|&1&2&                                                    ",
-"      3&4&5&6&7&8&9&0&a&b&c&d&e&f&g&h&B$d&i&j&G$k& &s#l&m&@@n&o&p&q&r&s&t&u&v&w&x&y&z&A&B&C&D&E&%+F&G&H&I&J&@.@.@.4./ E$K&3.L&M&N&O&P&Q&R&S&T&U&V&W&                                                    ",
-"      X&Y&Z&`& *.*+*@*#*$*%*&***=*-*;*`&>*,*,+'*)*.&!*K$l&~*{*]*^*/*(*_*:*<*_*[*.%4#}*=.A&|*#.D$1*2*3*4*5*6*U@4.8 g$@.3*7*B.8*9*0*a*b*c*d*e*f*g*h*                                                      ",
-"      i*l#j*k*l*m*n*o*p*q*r*s*t*u*v*w*w*x*i&x*E.d.4 y*z*A*%$B*C*D*E*i%F*G*H*I*J*~&K*L*M*N*O*P*Q*R*S*T*U*V*W*7 D @.7 X*Y*Z*`* =.=+=@=#=$=%=&=*===-=                                                      ",
-"      ;=>=,='=)=Q%P%9%!=~={=]=^=/=(=_=:=i+<=F$[=}=o#|=J$1=2=3=4=5=6=7=6=c+8=9=0=a=b=p c=d=Q*Q*R*3*T*e=f=g=h=i=4.3.a.o j=k=l=m=n=o=p=q=r=s=t=u=v=w=                                                      ",
-"      x=Y+y=z=A=Q%B=C=D=E=F=G=H=v*I=J=J=K=L=<=A=M=N=m+O=P=Q=R=S=T=U=V=h%W=X=a.E$Y=Z=`=Z% -R*U#S*S*; Q*.-+-+-1*@-3.{&F&U@#-k=$-%-&-*-=---;->-,-'-                                                        ",
-"      , )-!-~-{-]-^-O%Q%/-(-_-:-<-[-}-|-1-1-2-F$3-4-4#5-6-7-8-9-C 0-a-b-c-d-e-@-f-g-h-i-j-e-S*R*e-j-k-l- -m-Z%3*; n-o-l=p-q-r-s-t-u-v-w-x-y-z-A-                                                        ",
-"      B-X*C-D-E-F$>+F-G-H-1-I-q#J-K-L->*M-F-N-O-P-|=Q-R-S-T-+&U-V-W-X-Y-=%Z-`- ;z=.;+;@;R*S*S*; d-l-k-k-l- -l-m-#;$;%;&;$#*;=;-;;;>;,;';);!;                                                            ",
-"      ~;{;];^;/;(;_;,+:;J=J=<;[;};|%_=|;1;2;3;4;P-5;8.6;@&T-I$7;+;8;C-9;0;a;b;c;d;e;f;g;T*; ; R*d=k-k-*$k-l-l-h;Y*T-8.i;j;k;l;m;n;o;p;q;r;                                                              ",
-"      s;I&t;u;v;w;x;y;z;A;B;C;)&D;E;}-F;G;H;I;;@7.J;m+K;L;M;S*N;O;P;Q;R;S;T;U;V;I&W;X;m-m#; 3*m-l-k-*$k-*$k-l- -6#Y;Z;<%`; >.>+>@>#>$>                                                                  ",
-"      %>V;&>t;*>=>->;>>>,>'>)>~-D;!>~>*>{-{>H ;+P-Q-]>^>/>m#(>`._>:><>[>}>|>1>2>3>4>5>Z%i=f$Z%d-d=k-k-k-*$*$l-l-l-m-S*6>7>8>];9>0>a>b>          c>d>e>f>g>h>                                            ",
-"      i>j>k>l>m>n>o>p>q>j;r>s>t>{-u>!>5%v>u>w>y;x>y>z>A>B>8 m C>D>E>F>}>G>H>I>J>K>L>M>S*N>(  -j-l-k-l-k-*$k-l- -d=Z%O>P>>#Q>R>-*S>T>U>V>W>X>Y>Z>`> ,., ,+,@,#,$,%,&,*,=,                                ",
-"      %>-,;,>,s O%n>:;,,',B;),x*F;!,~,{,],U*P*g;g;^,/,8 (,_,:,<,[,},|,1,2,3,4,5,g$/ {;( 6,7,1*e-d=k-k-l-k-l- - -m-; @-8,9,d-l#0,a,b,c,d,e,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,                          ",
-"        w,x,y,z,A,K=|;B,C,D,E,J=F,G,H,I,J,K,L,M,N,O,o>P,Q,R,S,T,U,V,W,X,Y,Z,`, 'C.B.F&@-^ ^ m >,l-*$k-l- -l-l-l-e-m# -k-j-.'+'@'#'$'%'&'*'='-';'>',''')'!'~'{']'^'/'('_':'<'['}'|'                      ",
-"          1'2'3'4'G-:=,*5'6'7'8'9'0'a'b'c'P*d'0.e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'C.D >,X-u'm v'w'x'Q**$d= - - - ->,g;Z%y'z'A'B'$'$'C'D'E'F'G'H'I'J'K'L'M'N'O'P'Q'R'S'T'U'V'W'X'Y'Z'`' )                  ",
-"            L%.)+)d&@)#)$)%)&)x**)=)-);)i=>),)')))!)~){)])^)/)()_):)<)[)})|)1)2)7 3.S*3)5>4)5)6)3>g$F&*$d=Z%h;; m#7)8)9)0)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)y)z)A)B)C)D)E)                ",
-"            F)G)H):=I)G;J)K)L)=>*)=)*)M)_ ; d-N)O)P)Q)R)S)T)U)V)n'W)X)Y)Z)`) !7 C.&+.!X;I&4)W*I&X*4.@.{;Q*k-j-j-~,+!@!#!B'$!%!&!*!=!-!;!>!,!'!)!!!~!{!]!^!/!(!_!:!<![!}!|!1!2!3!4!5!6!7!8!              ",
-"            E 9!F;0!_;a!b!c!c!d!9'e!|%f!g!h!Q*i!j!k!l!m!n!o!p!q!:)r!s!t!u!v!w!@.4.^ x!6&5>y!z!A!B!(>]   C!C- -D!E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X!Y!Z!`! ~.~+~@~#~$~%~&~*~=~-~;~>~,~'~            ",
-"          )~*+M*!~O@v;<=~~L){~]~^~j;J=[%G;/~(~_~:~<~[~}~|~1~m'2~3~4~5~6~7~8~9~0~F x,-*a~X;b~c~d~e~          1*f~g~h~i~i~j~k~l~m~n~o~p~q~r~s~t~u~v~w~x~y~z~A~B~C~D~E~F~G~H~I~J~K~L~M~N~O~P~Q~R~          ",
-"              S~#;T~U~V~<=_;W~X~Y~Z~K=^-*)z,`~ {.{<~+{@{#{U,${%{&{*{={-{;{>{,{'{F X-){A!z=!{                ~{{{]{^{/{({_{:{<{[{}{|{1{2{3{4{5{6{              7{8{9{0{a{b{c{d{e{f{g{h{i{j{k{l{m{        ",
-"                n{`%>* *o{p{q{r{s{K=:=:=C$t{y,u{v{w{x{y{z{A{n'B{C{D{E{F{G{H{I{J{K{L{M{N{                    O{P{Q{R{S{:{T{U{V{W{X{Y{Z{`{ ].]                    +]@]#]$]%]&]*]=]-];]>],]'])]!]~]        ",
-"                  {]]]^]/](]L=L=1-(;(;K=(;_]:]<][]}]|]1]l'2]3]4]5]5~6]7]8]9]0]a]b]c]d]                      e]f]g]h]i]j]k]l]m]n]o]p]q]r]s]                        t]u]v]w]x]y]z]A]B]C]D]E]F]G]H]I]      ",
-"                    J]m#p _;|;J=J=J=^-K=_;K]t;L][]M]N]O]P]Q]R]S]T]U]V]W]X]Y]Z]`] ^                        .^+^@^#^$^%^&^*^=^-^;^>^,^'^)^!^                        ~^{^]^^^/^(^_^:^<^[^}^|^1^2^3^4^      ",
-"                      5^x'n>[%}-`&(;K=:=_;B$`%6^7^8^9^0^a^Q]b^c^d^e^f^g^h^i^j^                            k^l^m^n^o^p^q^r^s^t^u^v^w^x^y^z^                          A^B^C^D^E^F^G^H^I^J^K^L^M^N^O^      ",
-"                        P^Q^R^9'p S^(;:=T^U^V^W^X^Y^Z^`^ /./+/@/#/$/<>%/&/                                */=/-/;/>/,/'/)/!/~/{/]/^///(/                            _/:/</[/}/|/1/2/3/4/5/6/7/8/9/      ",
-"                          e+Y;u>D$|%B,0/B=a/b/c/d/e/Z^f/g/h/i/j/k/l/m/                                    n/o/p/q/r/s/t/u/v/w/x/y/z/A/B/                            C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/    ",
-"                            S/T/U/`&V/W/2-X/Y/Z/`/ (.(+(@(#($(%(&(                                        *(=(-(;(>(,('()(!(~({(](^(/(((                            _(:(<([(}(|(1(2(3(4(5(6(7(8(9(      ",
-"                              0(a(*)9'H A=b(c(d(e(f(g(h(i(j(k(                                            l(m(n(o(p(q(r(s(t(u(v(w(x(y(z(                            A(B(C(D(I/E(F(G(H(I(J(K(L(M(N(      ",
-"                                O(h&*)H V/N*6%P(Q(R(S(T(U(V(                                              W(X(Y(Z(`( _._+_@_#_$_%_&_*_=_                          -_;_>_I^,_'_)_!_~_{_]_K(L(^_/_(_      ",
-"                                  4)__V/:_=$<_[_}_|_1_2_                                                  3_4_5_6_7_8_9_0_a_b_b_c_d_e_f_                          g_h_i_j_k_l_m_n_{_]_K(L(^_o_p_q_      ",
-"                                    r_o-s_t_o>X+u_                                                                                                              v_w_x_y_z_A_B_C_{_]_K(L(^_o_D_E_        ",
-"                                        F_;$G_                                                                                                                H_I_J_K_L_M_I(N_{_]_K(L(^_o_O_P_Q_        ",
-"                                                                                                                                                            R_S_T_U_V_W_X_Y_{_]_K(L(^_o_O_Z_`_          ",
-"                                                                                                                                                         :.:+:@:#:$:%:&:*:{_]_K(L(^_o_O_=:-:            ",
-"                                                                                                                                                    ;:>:,:':):!:~:{:]:^:{_]_K(L(^_o_O_/:(:              ",
-"                                                                                                                                                  _:::<:[:}:|:1:2:3:^:{_]_K(L(^_o_4:5:6:                ",
-"                                                                                                                                                7:8:9:0:a:b:c:d:]:^:{_]_K(L(^_o_e:f:g:                  ",
-"                                                                                                                                              h:i:j:k:l:m:n:o:p:^:{_]_K(L(^_e:q:r:s:                    ",
-"                                                                                                                                            t:u:v:w:x:K_y:z:X_*:{_]_K(L(^_A:B:C:                        ",
-"                                                                                                                                            D:E:F:G:H:I:J:K:Y_{_]_K(L(^_L:M:N:                          ",
-"                                                                                                                                          O:P:Q:R:S:T:U:V:Y_{_]_K(L(^_W:X:Y:                            ",
-"                                                                                                                                          Z:`: <.<+<U:V:*:{_]_K(L(^_D_B:@<                              ",
-"                                                                                                                                        #<$<%<&<*<=<K:-<{_]_K(L(^_o_/:;<                                ",
-"                                                                                                                                        ><,<'<)<!<K:^:~<{<K(L(^_o_]<^</<                                ",
-"                                                                                                                                        (<_<:<<<[<^:}<{<K(L(^_o_|<1<2<                                  ",
-"                                                                                                                                        3<:<4<5<Y_6<7<K(L(^_o_|<8<9<0<                                  ",
-"                                                                                                                                        a<b<c<n_{_7<K(L(^_o_|<8<d<e<f<                                  ",
-"                                                                                                                                      g<h<c<n_{_{<K(L(^_o_|<8<d<i<j<k<                                  ",
-"                                                                                                                                      l<m<C_{_]_K(L(^_o_|<8<d<i<n<o<p<                                  ",
-"                                                                                                                                      l<q<{_]_K(L(^_o_|<8<d<i<n<r<s<t<                                  ",
-"                                                                                                                                      u<v<{<K(L(^_o_|<8<d<i<n<r<w<x<y<                                  ",
-"                                                                                                                                      z<A<K(L(^_o_|<8<d<i<n<r<w<B<C<D<                                  ",
-"                                                                                                                                      E<F<L(^_o_|<8<d<i<n<r<w<B<G<H<I<                                  ",
-"                                                                                                                                      J<K<L:/_D_]<9<L<e<M<N<O<P<Q<C<R<                                  ",
-"                                                                                                                                        S<T<U<V<W<X<Y<Z<`< [.[+[@[#[$[                                  ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                                                                        ",
-"                                                                                                                                                %[&[*[=[-[;[>[                                          ",
-"                                                                                                                                            ,['[)[![~[{[][^[/[([                                        ",
-"                                                                                                                                          _[:[<[[[}[|[1[2[3[4[5[6[                                      ",
-"                                                                                                                                          7[8[9[0[a[b[c[d[e[f[g[h[i[                                    ",
-"                                                                                                                                        j[k[l[m[n[o[p[q[r[s[t[u[v[w[                                    ",
-"                                                                                                                                        x[y[z[A[B[C[D[E[F[G[H[I[J[K[L[                                  ",
-"                                                                                                                                        M[N[O[P[Q[R[S[T[U[V[W[X[Y[Z[`[                                  ",
-"                                                                                                                                         }O[.}+}@}#}$}%}&}X[J[Y[*}*}=}                                  ",
-"                                                                                                                                        -}.}+}@};}$}>},}X[J[Y['})})}!}                                  ",
-"                                                                                                                                        ~}{}@};}$}>},}X[J[Y['})}]}^}/}                                  ",
-"                                                                                                                                        (}+};}$}>},}X[J[Y['})}]}_}:}                                    ",
-"                                                                                                                                          <};}>},}X[J[Y['})}]}[}}}|}                                    ",
-"                                                                                                                                          1}2}3}X[J[Y[*})}]}_}4}5}                                      ",
-"                                                                                                                                            6}7}8}J[9}0}*}a}b}c}                                        ",
-"                                                                                                                                                d}e}f}g}h}i}                                            ",
-"                                                                                                                                                                                                        "};
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/QmitkUltrasound.dox b/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/QmitkUltrasound.dox
index 4abc2ba488..647b299416 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/QmitkUltrasound.dox
+++ b/Plugins/org.mitk.gui.qt.ultrasound/documentation/UserManual/QmitkUltrasound.dox
@@ -1,95 +1,95 @@
 /**
 \page org_mitk_gui_qt_ultrasound The Ultrasound Plugin
 
 \imageMacro{QmitkUltrasound_Icon.png,"Icon of the Ultrasound Plugin",2.12}
 
 \tableofcontents
 
 \section org_mitk_gui_qt_ultrasoundOverview Overview
 
 This plugin offers a simple interface to create and manage ultrasound devices.
 Devices, once configured, will be stored and loaded on the next start of MITK.
 One can configure several aspects of the images acquired.
 Last but not least, this plugin makes the configured devices available as a
 microservice, exposing them for further usage in other plugins.
 
 \section org_mitk_gui_qt_ultrasoundPrerequisites Prerequisites
 
 To make use of this plugin, you obviously require an ultrasound device.
 The device must have a video output or must be one of the supported API devices
 (at the moment only Telemed LogicScan 128 is supported as an API device.
 Typical video outputs are: HDMI, DVI, VGA and S-Video.
 You also need a Video-Grabber that can acquire the image data from the
 ultrasound device. In principal, this plugin is compatible with any grabber
 that allows the operating system to access it's functionality.
 
 However, not all grabbers are created equal. Make sure your grabber supports
 the video-out offered by your ultrasound device and that it can achieve a
 satisfying framerate. We have made good experiences with epiphan Grabbers and
 currently recommend the <a
 href="http://www.epiphan.com/products/dvi-frame-grabbers/dvi2usb-3-0/">Epiphan
 DVI2USB 3.0 device</a> which supports HDMI, DVI and VGA, but less costly
 grabbers certainly are an option.
 
 \section org_mitk_gui_qt_ultrasoundCreateDevice Creating an Device
 
 To configure an ultrasound device as a video device, connect it to the grabber
 and the grabber to the computer. Start the ultrasound device and open the
 ultrasound plugin. The devicemanager will open.
 
 \imageMacro{QmitkUltrasound_DeviceManagement.png,"MITK Screenshot With the Device Manager Activated",7.54}
 
 Any currently configured devices are listed in the box, which accordingly is
 empty now.
 
 The creation of API devices depends on the device. A Telemed device would be
 listed in the box if this version of MITK was compiled with support for Telemed
-devices (see \link USHardwareTelemedPage\endlink). Such a device requires no
+devices (see \link USHardwareTelemedPage \endlink). Such a device requires no
 configuration.
 
 Click "New Video Device" if you want to create a new video device.
 
 \imageMacro{QmitkUltrasound_NewVideoDevice.png,"The 'New Device' form",7.62}
 
 In the appearing form, enter descriptive data on your device in the
 corresponding fields. Manufacturer and model will be used to display the device
 in MITK.
 
 You may choose the video source ID if more than one is available (as is the
 case on laptops with built-in webcams). Try 0 and 1. If the wrong camera is
 addressed, simply try the next ID.
 
 Most ultrasound images are grey scale, so using a grey scale conversion doesn't
 take information away from the image, but makes processing images significantly
 faster. Only uncheck this box if you require color.
 
 Click "Add Video Device" to save your changes.
 
 \imageMacro{QmitkUltrasound_DeviceManagement2.png,"Devicemanager With a Configured Device",7.64}
 
 An ultrasound device in MITK can be activated or removed. Removing may not be
 available for some API devices. The device you just created is available to all
 other plugins in MITK, but does not yet generate image data. Activating the
 device will start image generating.
 
 \section org_mitk_gui_qt_ultrasoundUseDevice Using an Ultrasound Device
 
 Click the device, then click "Activate Device". The device is now activated and
 generates image data continuously. The device is listed in the box on the
 bottom of the view now. Viewing of the image data can be started by selecting
 the device in this list and click the "Start Viewing" button.
 
 \imageMacro{QmitkUltrasound_Imaging.png,"US Imaging Tab for a Video Device",7.60}
 
 You can adjust the cropping parameters to reduce the acquired image size which
 will further increase speed and remove unnecessary information.
 
 All changes are saved and restored whenever MITK is started.
 
 If an API device was selected, buttons for controlling the b mode imaging may
 be available. This depends on the implementation of a control interface for
 this specific device in MITK.
 
 \imageMacro{QmikUltrasound_BModeControls.png,"B Mode Controls for an API Device",7}
 
 */
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualization.dox b/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualization.dox
index c1c47212a6..267ea020c8 100644
--- a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualization.dox
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualization.dox
@@ -1,140 +1,140 @@
 /**
 \page org_mitk_views_volumevisualization The Volume Visualization Plugin
 
-\imageMacro{volume_visualization.svg,"Icon of the Volume Visualization Plugin",2.00}
+\imageMacro{volume_visualization-dox.svg,"Icon of the Volume Visualization Plugin",2.00}
 
 \tableofcontents
 
 \section QVV_Overview Overview
 
 The <b> Volume Visualization Plugin </b> is a basic tool for volume rendering of three dimensional medical images. 
 MITK provides generic transfer function presets for medical CT and MRT data.
 These functions that map the gray-value to color and opacity can be interactively edited.
 Additionally, there are controls to quickly generate commonly used transfer function shapes like the threshold and bell curve to help identify a range of grey-values.
 
 \imageMacro{QmitkVolumeVisualization_Overview.png,"",16.00}
 
 \section QVV_EnableVRPage Volume Rendering
 
 \subsection QVV_LoadingImage Select an image and enable volume rendering
 
 \imageMacro{QmitkVolumeVisualization_Checkboxen.png,"",8.21}
 
 Select an image on top of the view and click on the checkbox left of 'Volumerendering'. Please be patient, while the image is prepared for rendering, which can take up to a half minute.
 
 \note 
 Volume Visualization imposes following restrictions on images:
 <ul>
 <li> It has to be a 3D scalar image, that means e.g. a CT or MRT image.
 <li> 3D+t images are supported for rendering, but the histograms are not computed.
 <li> Also be aware that volume visualization requires a huge amount of memory. Very large images may not work unless you use the 64bit version.
 </ul>
 
 
 \subsection QVV_LODGPU Dropdown menus for the rendering and blend modes
 
 Two dropdown menus are located right next to the 'Volumerendering' checkbox. They allow you to select a rendering mode (Default, RayCast, GPU) and the blend mode (Composite, Max, Min, Avg, Add).
 
 Any rendering mode requires a lot of computing resources including processor, memory and often also graphics card.
 The 'Default' selection usually finds the best 'rendering' mode for the available hardware.
 Alternatively, it is possible to manually specify the selections 'RayCast' and 'GPU'.
 The 'RayCast' selection is based on CPU computation and therefore typically slow, but allows to render without hardware acceleration.
 The 'GPU' selection uses computing resources on the graphics card to accelerate volume rendering.
 It requires a powerful graphics card and OpenGL hardware support for shaders but achieves much higher frame rates than software-rendering.
 
 Blend modes define how the volume voxels, intersected by the rendering rays, are pooled. The 'Composite' mode specifies standard volume rendering, 
 for which each voxel contributes equally with opacity and color. Other 'blend' modes simply visualize the voxel of the maximum / 
 minimum intensity and average / add the intensities along the rendering ray.
 
 \section QVV_PresetPage Applying premade presets
 
 \subsection QVV_Preset Internal presets
 
 There are some internal presets given that can be used with normal CT data (given in Houndsfield units).
 A large set of medical data has been tested with those presets, but they may not suit some special cases.
 
 Click on the 'Preset' tab for using internal or custom presets.
 
 \imageMacro{QmitkVolumeVisualization_InternalPresets.png,"",8.30}
 
 <ul>
 <li> 'CT Generic' is the default transfer function that is first applied.
 <li> 'CT Black&White' does not use any colors for the volume visualization as it may be distracting on some data.
 <li> 'CT Cardiac' is well-suited for CT images containing the heart.
 <li> 'CT Bone' emphasizes bones and shows other areas more transparent.
 <li> 'CT Bone (Gradient)' is like 'CT Bone' but shows only the surface from other organs by using the gradient.
 <li> 'MR Generic' is the default transfer function that can be used on MRT data (which is not normalized like CT data).
 <li> 'CT Thorax small' is useful if only a proportion of the thorax is selected to emphasize details.
 <li> 'CT Thorax large' is useful if a large proportion or the entire thorax is selected to emphasize details.
 </ul>
 
 \subsection QVV_CustomPreset Saving and loading custom presets
 
 After creating or editing a transfer function (see \ref QVV_Editing or \ref QVV_ThresholdBell),
 the custom transfer function can be stored and later retrieved on the filesystem.
 Click 'Save' (respectively 'Load') button below the preset selection to save (load) the threshold-, color- and gradient function combined in a single .xml file.
 
 \section QVV_ThresholdBell Interactively create transfer functions
 
 Besides the possibility to directly edit the transfer functions (\ref QVV_Editing), the plugin provides two commonly known shapes to quickly generate transfer functions with a few clicks. Both generators have two parameters that can be modified by first clicking on the cross and then moving the mouse up/down and left/right. 
 
 The first parameter 'center' (controlled by horizontal movement of the mouse) specifies the gray value where the center of the shape will be located.
 
 The second parameter 'width' (controlled by vertical movement of the mouse) specifies the width (or steepness) of the shape.
 
 \subsection Threshold
 
 Click on the 'Threshold' tab to activate the threshold function generator.
 
 \imageMacro{QmitkVolumeVisualization_Threshold.png,"",8.21}
 
 A threshold shape begins with zero and raises to one across the 'center' parameter. Lower widths result in steeper threshold functions.
 
 \subsection Bell
 
 Click on the 'Bell' tab to activate the bell-shaped threshold function generator.
 
 \imageMacro{QmitkVolumeVisualization_Bell.png,"",8.23}
 
 A threshold shape begins with zero and raises to one at the 'center' parameter and then lowers again to zero. The 'width' parameter corresponds to the width of the bell.
 
 \section QVV_Editing Customize transfer functions in detail
 
 \subsection QVV_Navigate Choosing gray value interval to edit
 
 \imageMacro{QmitkVolumeVisualization_Slider.png,"",8.23}
 
 To navigate across the gray value range or to zoom in some ranges use the 'range'-slider.
 
 All three function editors have in common following:
 
 <ul>
 <li> By left-clicking a new point is added.
 <li> By right-clicking a point is deleted.
 <li> By left-clicking and holding, an exisiting point can be dragged.
 <li> By pressing arrow keys, the currently selected point is moved.
 <li> By pressing the 'DELETE' key, the currently selected point is deleted.
 <li> Between points the transferfunctions are linear interpolated.
 </ul>
 
 There are three transfer functions to customize:
 
 \subsection QVV_GO Grayvalue -> Opacity
 
 \imageMacro{QmitkVolumeVisualization_Opacity.png,"Gray values will be mapped to opacity.",8.04}
 
 An opacity of 0 means total transparent, an opacity of 1 means total opaque. The opacity editor allows changing the opacity for all gray values independently. You can alter the position of control points using your mouse. You can add control points by left-clicking on the graph. To remove a control point again you can right-click on the respective point. 
 
 
 \subsection QVV_GC Grayvalue -> Color
 
 \imageMacro{QmitkVolumeVisualization_Color.png,"Gray values will be mapped to color.",8.81}
 
 The color transfer function editor also allows you to change its color by double-clicking a point. You can add color control points by left-clicking on the color bar. To remove a control point again right-click on the respective point. 
 
 \subsection QVV_GGO Grayvalue and Gradient -> Opacity
 
 \imageMacro{QmitkVolumeVisualization_Gradient.png,"",8.85}
 
 The gradient editor allows you to change the gradient influence for all gray values independently. You can move the existing control points using your mouse. Additionally, you can add control points by left-clicking on the graph. To remove a control point again, right-click on the respective point.
 */
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualization_Icon.png b/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualization_Icon.png
deleted file mode 100644
index 3813d0a639..0000000000
Binary files a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/QmitkVolumeVisualization_Icon.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/volume_visualization.svg b/Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/volume_visualization-dox.svg
similarity index 100%
rename from Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/volume_visualization.svg
rename to Plugins/org.mitk.gui.qt.volumevisualization/documentation/UserManual/volume_visualization-dox.svg
diff --git a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/QmitkXnatPluginManual.dox b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/QmitkXnatPluginManual.dox
index c83dcee11d..d25bb1c70d 100644
--- a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/QmitkXnatPluginManual.dox
+++ b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/QmitkXnatPluginManual.dox
@@ -1,113 +1,113 @@
 /**
 \page org_mitk_gui_qt_xnat The XNAT Plugin
 
 \imageMacro{xnat-docu-icon.png,"Icon of XNAT Plugin",1.00}
 
 \tableofcontents
 
 \section org_mitk_gui_qt_xnatOverview Overview
 This plug-in is allows the communication with a XNAT server from within MITK.
 
 The benefits of this plug-in are:
 <ul>
 <li>Browsing through the XNAT data hierarchy
 <li>Downloading data and visualize/process it in the MITK Workbench
 <li>Uploading data from within the MITK Workbench
 </ul>
 
 \imageMacro{QmitkXnat_IMGTreeBrowser.png,"The XNAT tree-browser plugin", 6.00}
 
 \section org_mitk_gui_qt_xnatConnection Connect to XNAT
 For communicating with XNAT you have to connect to your XNAT instance.
 
 \subsection org_mitk_gui_qt_xnatPreferences XNAT preferences
 In order to establish the connection to XNAT you have to specify the XNAT server address, username and password in the XNAT preference page.
 It is also possible to specify a network proxy if you are behind one (this could lead to connection errors).
 Via the download path you can tell MITK where to save the data that is uploaded or downloaded.
 A screenshot of the preference page can be seen below.
 
 \imageMacro{QmitkXnat_IMGPreferences.png,"The XNAT preference page", 10.00}
 
 \subsection org_mitk_gui_qt_xnatSessionHandling Session time-out handling
 Once you are connected to XNAT, MITK takes care about the session handling. A existing XNAT session times out after a certain period of inactivity, usually after 15 minutes.
 One minute before session time-out MITK asks you to renew the session:
 
 \imageMacro{QmitkXnat_IMGSessionAboutToTimeOut.png,"Notification that the session will time-out in a minute", 6.00}
 
 If you do not renew the session MITK notifies you if the session has expired:
 
 \imageMacro{QmitkXnat_IMGSessionExpired.png,"Notification that the session has expired", 6.00}
 
 \section org_mitk_gui_qt_xnatBrowsing Browse data
 Once you are connected to XNAT, MITK displays the XNAT data hierachy as a tree within the XNAT tree browser.
 You can browse through the data by expanding the tree items ( which ist also possible via double click).
 If you hover the mouse cursor over an item you will see a tool tip with detailed information.
 The following table gives an overview about the icons of the treeview and the related XNAT objects
 
 <table>
 <caption id="multi_row">XNAT Icon Overview</caption>
 <tr><th>Icon                     <th>XNAT object
-<tr><td>\imageMacro{xnat-server.png, "" ,0.50} <td>XNAT Server
-<tr><td>\imageMacro{xnat-project.png, "" ,0.50} <td>XNAT Project
-<tr><td>\imageMacro{xnat-subject.png, "" ,0.50} <td>XNAT Subject
-<tr><td>\imageMacro{xnat-experiment.png, "" ,0.50} <td>XNAT Experiment
-<tr><td>\imageMacro{xnat-folder-icon.png, "" ,0.50} <td>XNAT Scan top-level folder
-<tr><td>\imageMacro{xnat-scan.png, "" ,0.50} <td>XNAT Scan
-<tr><td>\imageMacro{xnat-folder-icon.png, "" ,0.50} <td>XNAT Resource top-level folder
-<tr><td>\imageMacro{xnat-resource.png, "" ,0.50} <td>XNAT Resource folder
-<tr><td>\imageMacro{xnat-file.png, "" ,0.50} <td>XNAT File
+<tr><td>\image html xnat-server.png <td>XNAT Server
+<tr><td>\image html xnat-project.png <td>XNAT Project
+<tr><td>\image html xnat-subject.png <td>XNAT Subject
+<tr><td>\image html xnat-experiment.png <td>XNAT Experiment
+<tr><td>\image html xnat-folder-icon.png <td>XNAT Scan top-level folder
+<tr><td>\image html xnat-scan.png <td>XNAT Scan
+<tr><td>\image html xnat-folder-icon.png <td>XNAT Resource top-level folder
+<tr><td>\image html xnat-resource.png <td>XNAT Resource folder
+<tr><td>\image html xnat-file.png <td>XNAT File
 </table>
 
 If you have selected a XNAT project, subject or experiment, MITK displays detailed information in a separate info area below the tree browser
 
 \section org_mitk_gui_qt_xnatDownload Download data
 MITK allows you to download your data from XNAT. You can either simply download the data to your file system or your can download it and open it immediately in the workbench.
 \subsection org_mitk_gui_qt_xnatDownload_file_system Download data to file system
 If you just want to download data, simply right-click on a XNAT file or scan on the tree brower and select "Download". The data will be stored in the specified download location.
 \subsection org_mitk_gui_qt_xnatDownload_in_MITK Download data and open it in MITK
 You can download and open data in three ways:
 <ul>
 <li>One is via right-click on a file or scan and selecting "Download and open".
 <li>You can also double-click on a file or scan. MITK will then ask you if you want to download and open the data.
 <li>The other one is via selecting a file or scan with left-click and then click on the download button above the tree view
 </ul>
 
 \imageMacro{QmitkXnat_IMGDownloadButton.png,"The XNAT dowload button", 16.00}
 
 \section org_mitk_gui_qt_xnatUpload Upload data
 You can also upload data to XNAT from within the workbench. Please note that it is currently only possible to upload files as resources. Uploading DICOMs is not yet available.
 
 \subsection org_mitk_gui_qt_xnatUpload1 Upload from file system
 If you just want to upload a local file, right-click on a resource and select "Upload". A file dialog will open, which allows you to select a file for upload.
 
 \subsection org_mitk_gui_qt_xnatUpload2 Upload via data manager
 If you want to upload data from within the MITK Workbench you can simply right-click on the data node in the data manager and select "Upload to XNAT".
 An "XNAT Upload dialog" will appear:
 
 \imageMacro{QmitkXnat_IMGUploadDialog.png,"The XNAT upload dialog", 16.00}
 
 You can then either select a existing resource folder if MITK is able to find ones or you can select the upload destination in a tree view.
 
 \subsection org_mitk_gui_qt_xnatUpload3 Upload via drag and drop
 Another way to upload the data is to drag the data node on the XNAT resource where you want to upload it to.
 
 \subsection org_mitk_gui_qt_xnatUpload4 Upload via XNAT Plugin
 Finally, if you select a data node and you select a XNAT resource, the upload button of the XNAT plugin will be enabled. If you click on that, the data will be uploaded.
 
 \imageMacro{QmitkXnat_IMGUploadButton.png,"The XNAT upload button", 16.00}
 
 \section org_mitk_gui_qt_xnatAddResourceFolder Create a resource folder
 You can also create new resources (i.e. folders to group your files in XNAT). Therefor you can either right-click on a project, subject, experiment or scan and enter the name
 of the folder in the appearing dialog. Or you simply select one of these items and click on the "Add folder button" above the tree browser.
 
 \imageMacro{QmitkXnat_IMGAddFolderButton.png,"The XNAT add folder button", 16.00}
 
 \subsection org_mitk_gui_qt_xnatCreateSubject Create a subject
 You can create subjects by right-clicking on a project and selecting "Create new subject".
 A dialog will appear where you have to enter the subject information.
 
 \subsection org_mitk_gui_qt_xnatCreateExperiment Create a experiment
 You can create experiments by right-clicking on a subject and selecting "Create new experiment".
 A dialog will appear where you have to enter the experiment information.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-experiment.png b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-experiment.png
deleted file mode 100644
index 41ba791449..0000000000
Binary files a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-experiment.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-file.png b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-file.png
deleted file mode 100644
index 17c7ad04e1..0000000000
Binary files a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-file.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-project.png b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-project.png
deleted file mode 100644
index 2fc1684f99..0000000000
Binary files a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-project.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-resource.png b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-resource.png
deleted file mode 100644
index 0b13723fb1..0000000000
Binary files a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-resource.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-scan.png b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-scan.png
deleted file mode 100644
index 778521828e..0000000000
Binary files a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-scan.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-server.png b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-server.png
deleted file mode 100644
index 911a7d7acc..0000000000
Binary files a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-server.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-subject.png b/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-subject.png
deleted file mode 100644
index 042140d37b..0000000000
Binary files a/Plugins/org.mitk.gui.qt.xnat/documentation/UserManual/xnat-subject.png and /dev/null differ
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index 21f3164257..9ca98ed3e1 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,509 +1,503 @@
 #-----------------------------------------------------------------------------
 # Convenient macro allowing to download a file
 #-----------------------------------------------------------------------------
 
 if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL)
   set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty)
 endif()
 
 macro(downloadFile url dest)
   file(DOWNLOAD ${url} ${dest} STATUS status)
   list(GET status 0 error_code)
   list(GET status 1 error_msg)
   if(error_code)
     message(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}")
   endif()
 endmacro()
 
 #-----------------------------------------------------------------------------
 # MITK Prerequisites
 #-----------------------------------------------------------------------------
 
 if(UNIX AND NOT APPLE)
 
   include(mitkFunctionCheckPackageHeader)
 
   # Check for libxt-dev
   mitkFunctionCheckPackageHeader(StringDefs.h libxt-dev /usr/include/X11/)
 
   # Check for libtiff4-dev
   mitkFunctionCheckPackageHeader(tiff.h libtiff4-dev)
 
 endif()
 
 # We need a proper patch program. On Linux and MacOS, we assume
 # that "patch" is available. On Windows, we download patch.exe
 # if not patch program is found.
 find_program(PATCH_COMMAND patch)
 if((NOT PATCH_COMMAND OR NOT EXISTS ${PATCH_COMMAND}) AND WIN32)
   downloadFile(${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/patch.exe
                ${CMAKE_CURRENT_BINARY_DIR}/patch.exe)
   find_program(PATCH_COMMAND patch ${CMAKE_CURRENT_BINARY_DIR})
 endif()
 if(NOT PATCH_COMMAND)
   message(FATAL_ERROR "No patch program found.")
 endif()
 
 #-----------------------------------------------------------------------------
 # ExternalProjects
 #-----------------------------------------------------------------------------
 
 get_property(external_projects GLOBAL PROPERTY MITK_EXTERNAL_PROJECTS)
 
 if(MITK_CTEST_SCRIPT_MODE)
   # Write a file containing the list of enabled external project targets.
   # This file can be read by a ctest script to separately build projects.
   set(SUPERBUILD_TARGETS )
   foreach(proj ${external_projects})
     if(MITK_USE_${proj})
       list(APPEND SUPERBUILD_TARGETS ${proj})
     endif()
   endforeach()
   file(WRITE "${CMAKE_BINARY_DIR}/SuperBuildTargets.cmake" "set(SUPERBUILD_TARGETS ${SUPERBUILD_TARGETS})")
 endif()
 
 # A list of "nice" external projects, playing well together with CMake
 set(nice_external_projects ${external_projects})
 list(REMOVE_ITEM nice_external_projects Boost)
 foreach(proj ${nice_external_projects})
   if(MITK_USE_${proj})
     set(EXTERNAL_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory")
     mark_as_advanced(EXTERNAL_${proj}_DIR)
     if(EXTERNAL_${proj}_DIR)
       set(${proj}_DIR ${EXTERNAL_${proj}_DIR})
     endif()
   endif()
 endforeach()
 
 set(EXTERNAL_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory")
 mark_as_advanced(EXTERNAL_BOOST_ROOT)
 if(EXTERNAL_BOOST_ROOT)
   set(BOOST_ROOT ${EXTERNAL_BOOST_ROOT})
 endif()
 
 if(BUILD_TESTING)
   set(EXTERNAL_MITK_DATA_DIR "${MITK_DATA_DIR}" CACHE PATH "Path to the MITK data directory")
   mark_as_advanced(EXTERNAL_MITK_DATA_DIR)
   if(EXTERNAL_MITK_DATA_DIR)
     set(MITK_DATA_DIR ${EXTERNAL_MITK_DATA_DIR})
   endif()
 endif()
 
 #-----------------------------------------------------------------------------
 # External project settings
 #-----------------------------------------------------------------------------
 
 include(ExternalProject)
 include(mitkMacroQueryCustomEPVars)
 include(mitkFunctionInstallExternalCMakeProject)
 include(mitkFunctionCleanExternalProject)
 
 option(MITK_AUTOCLEAN_EXTERNAL_PROJECTS "Experimental: Clean external project builds if updated" OFF)
 mark_as_advanced(MITK_AUTOCLEAN_EXTERNAL_PROJECTS)
 
 set(ep_prefix "${CMAKE_BINARY_DIR}/ep")
 set_property(DIRECTORY PROPERTY EP_PREFIX ${ep_prefix})
 
 # Compute -G arg for configuring external projects with the same CMake generator:
 if(CMAKE_EXTRA_GENERATOR)
   set(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
 else()
   set(gen "${CMAKE_GENERATOR}")
 endif()
 
 set(gen_platform ${CMAKE_GENERATOR_PLATFORM})
 
 # Use this value where semi-colons are needed in ep_add args:
 set(sep "^^")
 
 ##
 
 if(MSVC_VERSION)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
 endif()
 
 if(MITK_USE_Boost_LIBRARIES)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBOOST_ALL_DYN_LINK")
 endif()
 
 # This is a workaround for passing linker flags
 # actually down to the linker invocation
 set(_cmake_required_flags_orig ${CMAKE_REQUIRED_FLAGS})
 set(CMAKE_REQUIRED_FLAGS "-Wl,-rpath")
 mitkFunctionCheckCompilerFlags(${CMAKE_REQUIRED_FLAGS} _has_rpath_flag)
 set(CMAKE_REQUIRED_FLAGS ${_cmake_required_flags_orig})
 
 set(_install_rpath_linkflag )
 if(_has_rpath_flag)
   if(APPLE)
     set(_install_rpath_linkflag "-Wl,-rpath,@loader_path/../lib")
   else()
     set(_install_rpath_linkflag "-Wl,-rpath='$ORIGIN/../lib'")
   endif()
 endif()
 
 set(_install_rpath)
 if(APPLE)
   set(_install_rpath "@loader_path/../lib")
 elseif(UNIX)
   # this work for libraries as well as executables
   set(_install_rpath "\$ORIGIN/../lib")
 endif()
 
 set(ep_common_args
   -DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
   -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
   -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
   -DCMAKE_MACOSX_RPATH:BOOL=TRUE
   "-DCMAKE_INSTALL_RPATH:STRING=${_install_rpath}"
   -DBUILD_TESTING:BOOL=OFF
   -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
   -DBUILD_SHARED_LIBS:BOOL=ON
   -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
   -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
   -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
   -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
   "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_CXX14_FLAG}"
   #debug flags
   -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG}
   -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG}
   #release flags
   -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE}
   -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}
   #relwithdebinfo
   -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
   -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
   #link flags
   -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
   -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
   -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS}
 )
 
 if(MSVC_VERSION)
   list(APPEND ep_common_args
     -DCMAKE_DEBUG_POSTFIX:STRING=d
   )
 
   set(DCMTK_CMAKE_DEBUG_POSTFIX d)
 endif()
 
 set(ep_common_cache_args
 )
 
 set(ep_common_cache_default_args
   "-DCMAKE_PREFIX_PATH:PATH=<INSTALL_DIR>;${CMAKE_PREFIX_PATH}"
   "-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
   "-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
 )
 
 # Pass the CMAKE_OSX variables to external projects
 if(APPLE)
   set(MAC_OSX_ARCHITECTURE_ARGS
         -DCMAKE_OSX_ARCHITECTURES:PATH=${CMAKE_OSX_ARCHITECTURES}
         -DCMAKE_OSX_DEPLOYMENT_TARGET:PATH=${CMAKE_OSX_DEPLOYMENT_TARGET}
         -DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
   )
   set(ep_common_args
         ${MAC_OSX_ARCHITECTURE_ARGS}
         ${ep_common_args}
   )
 endif()
 
 set(mitk_superbuild_ep_args)
 set(mitk_depends )
 
 # Include external projects
 include(CMakeExternals/MITKData.cmake)
 foreach(p ${external_projects})
   set(p_hash "")
 
   set(p_file "${CMAKE_SOURCE_DIR}/CMakeExternals/${p}.cmake")
   if(EXISTS ${p_file})
     file(MD5 ${p_file} p_hash)
   else()
     foreach(MITK_EXTENSION_DIR ${MITK_ABSOLUTE_EXTENSION_DIRS})
       set(MITK_CMAKE_EXTERNALS_EXTENSION_DIR "${MITK_EXTENSION_DIR}/CMakeExternals")
       set(p_file "${MITK_CMAKE_EXTERNALS_EXTENSION_DIR}/${p}.cmake")
       if(EXISTS "${p_file}")
         file(MD5 "${p_file}" p_hash)
         break()
       endif()
     endforeach()
   endif()
 
   if(p_hash)
     set(p_hash_file "${ep_prefix}/tmp/${p}-hash.txt")
     if(MITK_AUTOCLEAN_EXTERNAL_PROJECTS)
       if(EXISTS "${p_hash_file}")
         file(READ "${p_hash_file}" p_prev_hash)
         if(NOT p_hash STREQUAL p_prev_hash)
           mitkCleanExternalProject(${p})
         endif()
       endif()
     endif()
     file(WRITE "${p_hash_file}" ${p_hash})
   endif()
 
   include("${p_file}" OPTIONAL)
 
   list(APPEND mitk_superbuild_ep_args
        -DMITK_USE_${p}:BOOL=${MITK_USE_${p}}
       )
   get_property(_package GLOBAL PROPERTY MITK_${p}_PACKAGE)
   if(_package)
     list(APPEND mitk_superbuild_ep_args -D${p}_DIR:PATH=${${p}_DIR})
   endif()
 
   list(APPEND mitk_depends ${${p}_DEPENDS})
 endforeach()
 if (SWIG_EXECUTABLE)
   list(APPEND mitk_superbuild_ep_args -DSWIG_EXECUTABLE=${SWIG_EXECUTABLE})
 endif()
 
 #-----------------------------------------------------------------------------
 # Set superbuild boolean args
 #-----------------------------------------------------------------------------
 
 set(mitk_cmake_boolean_args
   BUILD_SHARED_LIBS
   WITH_COVERAGE
   BUILD_TESTING
   MITK_BUILD_ALL_PLUGINS
   MITK_BUILD_ALL_APPS
   MITK_BUILD_EXAMPLES
   MITK_USE_Qt5
   MITK_USE_SYSTEM_Boost
   MITK_USE_BLUEBERRY
   MITK_USE_OpenCL
   MITK_USE_OpenMP
   MITK_ENABLE_PIC_READER
   )
 
 #-----------------------------------------------------------------------------
 # Create the final variable containing superbuild boolean args
 #-----------------------------------------------------------------------------
 
 set(mitk_superbuild_boolean_args)
 foreach(mitk_cmake_arg ${mitk_cmake_boolean_args})
   list(APPEND mitk_superbuild_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
 endforeach()
 
 if(MITK_BUILD_ALL_PLUGINS)
   list(APPEND mitk_superbuild_boolean_args -DBLUEBERRY_BUILD_ALL_PLUGINS:BOOL=ON)
 endif()
 
 #-----------------------------------------------------------------------------
 # MITK Utilities
 #-----------------------------------------------------------------------------
 
 set(proj MITK-Utilities)
 ExternalProject_Add(${proj}
   DOWNLOAD_COMMAND ""
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     ${mitk_depends}
 )
 #-----------------------------------------------------------------------------
 # Additional MITK CXX/C Flags
 #-----------------------------------------------------------------------------
 
 set(MITK_ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags for MITK")
 set(MITK_ADDITIONAL_C_FLAGS_RELEASE "" CACHE STRING "Additional Release C Flags for MITK")
 set(MITK_ADDITIONAL_C_FLAGS_DEBUG "" CACHE STRING "Additional Debug C Flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_C_FLAGS MITK_ADDITIONAL_C_FLAGS_DEBUG MITK_ADDITIONAL_C_FLAGS_RELEASE)
 
 set(MITK_ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags for MITK")
 set(MITK_ADDITIONAL_CXX_FLAGS_RELEASE "" CACHE STRING "Additional Release CXX Flags for MITK")
 set(MITK_ADDITIONAL_CXX_FLAGS_DEBUG "" CACHE STRING "Additional Debug CXX Flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_CXX_FLAGS MITK_ADDITIONAL_CXX_FLAGS_DEBUG MITK_ADDITIONAL_CXX_FLAGS_RELEASE)
 
 set(MITK_ADDITIONAL_EXE_LINKER_FLAGS "" CACHE STRING "Additional exe linker flags for MITK")
 set(MITK_ADDITIONAL_SHARED_LINKER_FLAGS "" CACHE STRING "Additional shared linker flags for MITK")
 set(MITK_ADDITIONAL_MODULE_LINKER_FLAGS "" CACHE STRING "Additional module linker flags for MITK")
 mark_as_advanced(MITK_ADDITIONAL_EXE_LINKER_FLAGS MITK_ADDITIONAL_SHARED_LINKER_FLAGS MITK_ADDITIONAL_MODULE_LINKER_FLAGS)
 
 #-----------------------------------------------------------------------------
 # MITK Configure
 #-----------------------------------------------------------------------------
 
 if(MITK_INITIAL_CACHE_FILE)
   set(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}")
 endif()
 
 set(mitk_optional_cache_args )
 foreach(type RUNTIME ARCHIVE LIBRARY)
   if(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY)
     list(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY})
   endif()
 endforeach()
 
 # Optional python variables
 if(MITK_USE_Python3)
   list(APPEND mitk_optional_cache_args
        -DMITK_USE_Python3:BOOL=${MITK_USE_Python3}
        "-DPython3_EXECUTABLE:FILEPATH=${Python3_EXECUTABLE}"
        "-DPython3_INCLUDE_DIR:PATH=${Python3_INCLUDE_DIRS}"
        "-DPython3_LIBRARY:FILEPATH=${Python3_LIBRARY}"
        "-DPython3_STDLIB:FILEPATH=${Python3_STDLIB}"
        "-DPython3_SITELIB:FILEPATH=${Python3_SITELIB}"
       )
 endif()
 
 if(OPENSSL_ROOT_DIR)
   list(APPEND mitk_optional_cache_args
     "-DOPENSSL_ROOT_DIR:PATH=${OPENSSL_ROOT_DIR}"
   )
 endif()
 
 if(CMAKE_FRAMEWORK_PATH)
   list(APPEND mitk_optional_cache_args
     "-DCMAKE_FRAMEWORK_PATH:PATH=${CMAKE_FRAMEWORK_PATH}"
   )
 endif()
 
 if(Eigen_INCLUDE_DIR)
     list(APPEND mitk_optional_cache_args
       -DEigen_INCLUDE_DIR:PATH=${Eigen_INCLUDE_DIR}
     )
 endif()
 
 # Optional pass through of Doxygen
 if(DOXYGEN_EXECUTABLE)
   list(APPEND mitk_optional_cache_args
        -DDOXYGEN_EXECUTABLE:FILEPATH=${DOXYGEN_EXECUTABLE}
   )
 endif()
 
 if(MITK_DOXYGEN_BUILD_ALWAYS)
   list(APPEND mitk_optional_cache_args
     -DMITK_DOXYGEN_BUILD_ALWAYS:BOOL=${MITK_DOXYGEN_BUILD_ALWAYS}
   )
 endif()
 
-if(BLUEBERRY_DOC_TOOLS_DIR)
-  list(APPEND mitk_optional_cache_args
-    "-DBLUEBERRY_DOC_TOOLS_DIR:PATH=${BLUEBERRY_DOC_TOOLS_DIR}"
-  )
-endif()
-
 set(proj MITK-Configure)
 
 ExternalProject_Add(${proj}
   LIST_SEPARATOR ${sep}
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
   CMAKE_GENERATOR_PLATFORM ${gen_platform}
   CMAKE_CACHE_ARGS
     # --------------- Build options ----------------
     -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
     "-DCMAKE_PREFIX_PATH:PATH=${ep_prefix};${CMAKE_PREFIX_PATH}"
     "-DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}"
     "-DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}"
     # --------------- Compile options ----------------
     -DCMAKE_CXX_EXTENSIONS:STRING=${CMAKE_CXX_EXTENSIONS}
     -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
     -DCMAKE_CXX_STANDARD_REQUIRED:BOOL=${CMAKE_CXX_STANDARD_REQUIRED}
     -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
     -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
     "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}"
     "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}"
     # debug flags
     "-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}"
     "-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}"
     # release flags
     "-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}"
     "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}"
     # relwithdebinfo
     -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
     -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO}
     # link flags
     "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}"
     "-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}"
     "-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}"
     # Output directories
     -DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
     -DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
     # ------------- Boolean build options --------------
     ${mitk_superbuild_boolean_args}
     ${mitk_optional_cache_args}
     -DMITK_USE_SUPERBUILD:BOOL=OFF
     -DMITK_BUILD_CONFIGURATION:STRING=${MITK_BUILD_CONFIGURATION}
     -DMITK_FAST_TESTING:BOOL=${MITK_FAST_TESTING}
     -DMITK_XVFB_TESTING:BOOL=${MITK_XVFB_TESTING}
     -DMITK_XVFB_TESTING_COMMAND:STRING=${MITK_XVFB_TESTING_COMMAND}
     -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
     # ----------------- Miscellaneous ---------------
     -DCMAKE_LIBRARY_PATH:PATH=${CMAKE_LIBRARY_PATH}
     -DCMAKE_INCLUDE_PATH:PATH=${CMAKE_INCLUDE_PATH}
     -DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE}
     -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR}
     -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD}
     -DMITK_WHITELIST:STRING=${MITK_WHITELIST}
     -DMITK_WHITELISTS_EXTERNAL_PATH:STRING=${MITK_WHITELISTS_EXTERNAL_PATH}
     -DMITK_WHITELISTS_INTERNAL_PATH:STRING=${MITK_WHITELISTS_INTERNAL_PATH}
     -DMITK_EXTENSION_DIRS:STRING=${MITK_EXTENSION_DIRS}
     -DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_VECTOR_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES}
     -DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS}
     -DMITK_CUSTOM_REVISION_DESC:STRING=${MITK_CUSTOM_REVISION_DESC}
     # --------------- External project options ---------------
     -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
     -DMITK_EXTERNAL_PROJECT_PREFIX:PATH=${ep_prefix}
     -DCppMicroServices_DIR:PATH=${CppMicroServices_DIR}
     -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=${DCMTK_CMAKE_DEBUG_POSTFIX}
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
     -DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR}
     -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
     -DQt5_DIR:PATH=${Qt5_DIR}
   CMAKE_ARGS
     ${mitk_initial_cache_arg}
     ${MAC_OSX_ARCHITECTURE_ARGS}
     ${mitk_superbuild_ep_args}
   SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
   BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     MITK-Utilities
   )
 
 mitkFunctionInstallExternalCMakeProject(${proj})
 
 #-----------------------------------------------------------------------------
 # MITK
 #-----------------------------------------------------------------------------
 
 if(CMAKE_GENERATOR MATCHES ".*Makefiles.*")
   set(mitk_build_cmd "$(MAKE)")
 else()
   set(mitk_build_cmd ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build --config ${CMAKE_CFG_INTDIR})
 endif()
 
 if(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET)
   set(MITKBUILD_TARGET_ALL_OPTION "ALL")
 else()
   set(MITKBUILD_TARGET_ALL_OPTION "")
 endif()
 
 add_custom_target(MITK-build ${MITKBUILD_TARGET_ALL_OPTION}
   COMMAND ${mitk_build_cmd}
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
   DEPENDS MITK-Configure
   )
 
 #-----------------------------------------------------------------------------
 # Custom target allowing to drive the build of the MITK project itself
 #-----------------------------------------------------------------------------
 
 add_custom_target(MITK
   COMMAND ${mitk_build_cmd}
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build
 )
 
diff --git a/Utilities/IpPic/mitkIpPicTypeMultiplex.h b/Utilities/IpPic/mitkIpPicTypeMultiplex.h
index 9cff7435ec..7c515e335a 100644
--- a/Utilities/IpPic/mitkIpPicTypeMultiplex.h
+++ b/Utilities/IpPic/mitkIpPicTypeMultiplex.h
@@ -1,730 +1,730 @@
 /*============================================================================
 
  Copyright (c) German Cancer Research Center (DKFZ)
  All rights reserved.
 
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
 
  - Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
 
  - Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.
 
  - All advertising materials mentioning features or use of this software must
    display the following acknowledgement:
 
      "This product includes software developed by the German Cancer Research
       Center (DKFZ)."
 
  - Neither the name of the German Cancer Research Center (DKFZ) nor the names
    of its contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.
 
    THIS SOFTWARE IS PROVIDED BY THE GERMAN CANCER RESEARCH CENTER (DKFZ) AND
    CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
    BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GERMAN
    CANCER RESEARCH CENTER (DKFZ) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
    DAMAGE.
 
 ============================================================================*/
 
 /** @file
 *
 *Module Name:mitkIpPicTypeMultiplex
 *
 *Module Klasse: ADT
 *
 *Beschreibung:Multiplexing a method with the image datatyp.
 *The image is the first parameter.
 *The method must be about a template method.
 *The number of parameter is constricted by 16
 *
 *Method with two parameter and without a return value:
 *mitkIpPicTypeMultiplex2( funktionsname, parameter1, Parameter2 );
 *
 *Method with one parameter and a return value:
 *mitkIpPicTypeMultiplexR1( funktionsname, rückgabewert, parameter );
 *
 *If R is set the method return a value
 *The number set the count of parameter
 *
 *exported classes and methods:
 *no one
 *
 *imported classes and methods:
 *std::complex
 *
-*@warningThese module is not finished
+*@warning These module is not finished
 *
 *
-*@version1.0
+*@version 1.0
 *
-* @date07.09.2000
+* @date 07.09.2000
 *
-* @authorMarcus Vetter
+* @author Marcus Vetter
 *
 */
 
 #ifndef IP_PIC_TYPE_MULTIPLEX_H
 #define IP_PIC_TYPE_MULTIPLEX_H
 
 #include "mitkIpPic.h"
 //#include <complex>
 
 #define mitkIpPicTypeMultiplex0( function, pic ) \
 { \
 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ){ \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
 function<char>( pic ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplex1( function, pic, param1 ) \
 { \
 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ){ \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
 function<char>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1 ); \
 } \
 }
 /*
 else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1 );
 }
 */
 
 #define mitkIpPicTypeMultiplex2( function, pic, param1, param2 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2 ); \
 } \
 }
 /*
 else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2 );
 }
 */
 #define mitkIpPicTypeMultiplex3( function, pic, param1, param2, param3 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3 ); \
 } \
 }
 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3 );
 }*/
 
 #define mitkIpPicTypeMultiplex4( function, pic, param1, param2, param3, param4 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4 ); \
 } \
 }
 /*
 else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4 );
 }*/
 
 #define mitkIpPicTypeMultiplex5( function, pic, param1, param2, param3, param4, param5 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4, param5 ); \
 } \
 }
 /* else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4, param5 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4, param5 );
 }
 */
 #define mitkIpPicTypeMultiplex6( function, pic, param1, param2, param3, param4, param5, param6 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4, param5, param6 ); \
 } \
 }
 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
 }*/
 
 #define mitkIpPicTypeMultiplex7( function, pic, param1, param2, param3, param4, param5, param6, param7 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } \
 }
 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
 }*/
 
 #define mitkIpPicTypeMultiplex7( function, pic, param1, param2, param3, param4, param5, param6, param7 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } \
 }
 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
 }*/
 
 #define mitkIpPicTypeMultiplex8( function, pic, param1, param2, param3, param4, param5, param6, param7, param8) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8); \
 } \
 }
 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
 }*/
 
 #define mitkIpPicTypeMultiplex9( function, pic, param1, param2, param3, param4, param5, param6, param7, param8, param9) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9); \
 } \
 }
 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
 }*/
 
 #define mitkIpPicTypeMultiplex10( function, pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10); \
 } \
 }
 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
 }*/
 
 #define mitkIpPicTypeMultiplex16( function, pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16 ); \
 } \
 }
 /*else if ( pic->type == mitkIpPicComplex && pic->bpe == 64 ){
 function<std::complex<float> >( pic, param1, param2, param3, param4, param5, param6 );
 } else if ( pic->type == mitkIpPicComplex && pic->bpe == 128 ){
 function<std::complex<double> >( pic, param1, param2, param3, param4, param5, param6 );
 }*/
 /**
 * with return value
 */
 
 #define mitkIpPicTypeMultiplexR0( function, pic, returnValue ) \
 { \
 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ){ \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
 returnValue = function<char>( pic ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR1( function, pic, returnValue, param1 ) \
 { \
 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ){ \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
 returnValue = function<char>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1 ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR2( function, pic, returnValue, param1, param2 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   returnValue = function<char>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1, param2 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1, param2 ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR3( function, pic, returnValue, param1, param2, param3 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   returnValue = function<char>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1, param2, param3 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1, param2, param3 ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR4( function, pic, returnValue, param1, param2, param3, param4 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   returnValue = function<char>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1, param2, param3, param4 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1, param2, param3, param4 ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR5( function, pic, returnValue, param1, param2, param3, param4, param5 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   returnValue = function<char>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1, param2, param3, param4, param5 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1, param2, param3, param4, param5 ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR6( function, pic, returnValue, param1, param2, param3, param4, param5, param6 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   returnValue = function<char>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1, param2, param3, param4, param5, param6 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1, param2, param3, param4, param5, param6 ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR7( function, pic, returnValue, param1, param2, param3, param4, param5, param6, param7 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   returnValue = function<char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1, param2, param3, param4, param5, param6, param7 ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR8( function, pic, returnValue, param1, param2, param3, param4, param5, param6, param7, param8 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   returnValue = function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8 ); \
 } \
 }
 
 #define mitkIpPicTypeMultiplexR9( function, pic, returnValue, param1, param2, param3, param4, param5, param6, param7, param8, param9 ) \
 { \
 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ){ \
   returnValue = function<char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ){ \
 returnValue = function<unsigned char>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ){ \
 returnValue = function<short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ){ \
 returnValue = function<unsigned short>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ){ \
 returnValue = function<int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ){ \
 returnValue = function<unsigned int>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ){ \
 returnValue = function<long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ){ \
 returnValue = function<unsigned long>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ){ \
 returnValue = function<float>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ){ \
 returnValue = function<double>( pic, param1, param2, param3, param4, param5, param6, param7, param8, param9 ); \
 } \
 }
 
 #endif // IP_PIC_TYPE_MULTIPLEX_H
diff --git a/Utilities/mbilog/mbilogBackendBase.h b/Utilities/mbilog/mbilogBackendBase.h
index f13a992b70..c82696b5e6 100644
--- a/Utilities/mbilog/mbilogBackendBase.h
+++ b/Utilities/mbilog/mbilogBackendBase.h
@@ -1,59 +1,58 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef _mbilogBackendBase_H
 #define _mbilogBackendBase_H
 
 #include "mbilogExports.h"
 #include "mbilogLogMessage.h"
 
 namespace mbilog
 {
-  /**
-   * This enum defines the type of the output of a backend.
+  /** This enum defines the type of the output of a backend.
    * Console: output generated to the console
    * File: output generated to a file
    * Other: all other kinds of output
    */
-  enum MBILOG_EXPORT OutputType
+  enum OutputType
   {
     Console = 0,
     File,
     Other = 100
   };
   /**
    *  \brief This class is an interface for logging backends that can be registered in the mbi logging mechanism.
    *
    *  \ingroup mbilog
    */
   class MBILOG_EXPORT BackendBase
   {
   public:
     virtual ~BackendBase();
 
     /**
      * \brief This method is called by the mbi logging mechanism if the object is registered in
      *         the mbi logging mechanism and a logging message is emitted.
      *
      * \param logMessage Logging message which was emitted.
      *
      */
     virtual void ProcessMessage(const mbilog::LogMessage &logMessage) = 0;
 
     /**
      * @return The type of this backend.
      */
     virtual OutputType GetOutputType() const = 0;
   };
 }
 
 #endif