diff --git a/Examples/Tutorial/Step3/Step3.cpp b/Examples/Tutorial/Step3/Step3.cpp
index 8e8fc8c4b9..33cf669ec4 100644
--- a/Examples/Tutorial/Step3/Step3.cpp
+++ b/Examples/Tutorial/Step3/Step3.cpp
@@ -1,160 +1,161 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 
 #include <mitkStandaloneDataStorage.h>
 #include <mitkProperties.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkRenderingManager.h>
 #include <mitkIOUtil.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <QApplication>
 
 
 //##Documentation
 //## @brief Change the type of display to 3D
 //##
 //## As in Step2, load one or more data sets (many image, surface
 //## and other formats), but display it in a 3D view.
 //## The QmitkRenderWindow is now used for displaying a 3D view, by
 //## setting the used mapper-slot to Standard3D.
 //## Since volume-rendering is a (rather) slow procedure, the default
 //## is that images are not displayed in the 3D view. For this example,
 //## we want volume-rendering, thus we switch it on by setting
 //## the Boolean-property "volumerendering" to "true".
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
   if(argc<2)
   {
     fprintf( stderr, "Usage:   %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for(i=1; i<argc; ++i)
   {
     // For testing
     if(strcmp(argv[i], "-testing")==0) continue;
 
       //*********************************************************************
       // Part III: Put the data into the datastorage
       //*********************************************************************
     // Load datanode (eg. many image formats, surface formats, etc.)
-    mitk::StandaloneDataStorage::SetOfObjects* dataNodes = mitk::IOUtil::Load(argv[i],*ds);
+    mitk::StandaloneDataStorage::SetOfObjects::Pointer dataNodes = mitk::IOUtil::Load(argv[i],*ds);
+
 
     if(dataNodes->empty())
     {
       fprintf( stderr, "Could not open file %s \n\n", argv[i] );
       exit(2);
     }
     mitk::DataNode::Pointer node = dataNodes->at(0);
 
       // *********************************************************
       // ****************** START OF NEW PART 1 ******************
       // *********************************************************
 
       //*********************************************************************
       // Part IV: We want all images to be volume-rendered
       //*********************************************************************
 
       // Check if the data is an image by dynamic_cast-ing the data
       // contained in the node. Warning: dynamic_cast's are rather slow,
       // do not use it too often!
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
       if(image.IsNotNull())
       {
         // Set the property "volumerendering" to the Boolean value "true"
         node->SetProperty("volumerendering", mitk::BoolProperty::New(true));
 
         // Create a transfer function to assign optical properties (color and opacity) to grey-values of the data
         mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
         tf->InitializeByMitkImage ( image );
 
         // Set the color transfer function AddRGBPoint(double x, double r, double g, double b)
         tf->GetColorTransferFunction()->AddRGBPoint ( tf->GetColorTransferFunction()->GetRange() [0], 1.0, 0.0, 0.0 );
         tf->GetColorTransferFunction()->AddRGBPoint ( tf->GetColorTransferFunction()->GetRange() [1], 1.0, 1.0, 0.0 );
 
         // Set the piecewise opacity transfer function AddPoint(double x, double y)
         tf->GetScalarOpacityFunction()->AddPoint ( 0, 0 );
         tf->GetScalarOpacityFunction()->AddPoint ( tf->GetColorTransferFunction()->GetRange() [1], 1 );
 
         node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
       }
 
 
       // *********************************************************
       // ******************* END OF NEW PART 1 *******************
       // *********************************************************
   }
 
   //*************************************************************************
   // Part V: Create window and pass the tree to it
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow;
 
   // Tell the renderwindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // *********************************************************
   // ****************** START OF NEW PART 2 ******************
   // *********************************************************
   // Use it as a 3D view!
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   // *********************************************************
   // ******************* END OF NEW PART 2 *******************
   // *********************************************************
 
   //*************************************************************************
   // Part VI: Qt-specific initialization
   //*************************************************************************
   renderWindow.show();
   renderWindow.resize( 256, 256 );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   // for testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 
 /**
 \example Step3.cpp
 */
diff --git a/Examples/Tutorial/Step5/Step5.cpp b/Examples/Tutorial/Step5/Step5.cpp
index d873d7672a..81b4fcc41c 100644
--- a/Examples/Tutorial/Step5/Step5.cpp
+++ b/Examples/Tutorial/Step5/Step5.cpp
@@ -1,209 +1,209 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceWidget.h"
 
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
 
 #include "mitkPointSet.h"
 // NEW INCLUDE
 #include "mitkPointSetDataInteractor.h"
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 #include <QHBoxLayout>
 #include <mitkIOUtil.h>
 
 //##Documentation
 //## @brief Interactively add points
 //##
 //## As in Step4, load one or more data sets (many image,
 //## surface and other formats) and create 3 views on the data.
 //## Additionally, we want to interactively add points. A node containing
 //## a PointSet as data is added to the data tree and a PointSetDataInteractor
 //## is associated with the node, which handles the interaction. The
 //## @em interaction @em pattern is defined in a state-machine, stored in an
 //## external XML file. Thus, we need to load a state-machine
 //## The interaction patterns defines the @em events,
 //## on which the interactor reacts (e.g., which mouse buttons are used to
 //## set a point), the @em transition to the next state (e.g., the initial
 //## may be "empty point set") and associated @a actions (e.g., add a point
 //## at the position where the mouse-click occured).
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
 
   if(argc<2)
   {
     fprintf( stderr, "Usage:   %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for(i=1; i<argc; ++i)
   {
     // For testing
     if(strcmp(argv[i], "-testing")==0) continue;
 
     // Load datanode (eg. many image formats, surface formats, etc.)
-    mitk::StandaloneDataStorage::SetOfObjects* dataNodes = mitk::IOUtil::Load(argv[i],*ds);
+    mitk::StandaloneDataStorage::SetOfObjects::Pointer dataNodes = mitk::IOUtil::Load(argv[i],*ds);
 
     //*********************************************************************
     // Part III: Put the data into the datastorage
     //*********************************************************************
     // Add the node to the DataStorage
     if(dataNodes->empty())
     {
       fprintf( stderr, "Could not open file %s \n\n", argv[i] );
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part V: Create windows and pass the tree to it
   //*************************************************************************
 
   // Create toplevel widget with horizontal layout
   QWidget toplevelWidget;
   QHBoxLayout layout;
   layout.setSpacing(2);
   layout.setMargin(0);
   toplevelWidget.setLayout(&layout);
 
   //*************************************************************************
   // Part Va: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow(&toplevelWidget);
   layout.addWidget(&renderWindow);
 
   // Tell the renderwindow which (part of) the tree to render
 
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Use it as a 3D view
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   //*************************************************************************
   // Part Vb: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view2(&toplevelWidget);
   layout.addWidget(&view2);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2.SetDataStorage(ds);
   mitk::DataStorage::SetOfObjects::ConstPointer rs = ds->GetAll();
   view2.SetData(rs->Begin(), mitk::SliceNavigationController::Axial);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   ds->Add(view2.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part Vc: 2D view for slicing sagitally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view3(&toplevelWidget);
   layout.addWidget(&view3);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render
   // and to slice sagitall
   view3.SetDataStorage(ds);
   view3.SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   ds->Add(view3.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   // *******************************************************
   // ****************** START OF NEW PART ******************
   // *******************************************************
 
   //*************************************************************************
   // Part VI: For allowing to interactively add points ...
   //*************************************************************************
 
 
   // ATTENTION: It is very important that the renderer already know their DataStorage,
   // because registerig DataInteractors with the render windows is done automatically
   // and only works if the BaseRenderer and the DataStorage know each other.
 
   // Create PointSet and a node for it
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   // Store the point set in the DataNode
   pointSetNode->SetData(pointSet);
 
   // Add the node to the tree
   ds->Add(pointSetNode);
 
   // Create PointSetDataInteractor
   mitk::PointSetDataInteractor::Pointer interactor = mitk::PointSetDataInteractor::New();
   // Set the StateMachine pattern that describes the flow of the interactions
   interactor->LoadStateMachine("PointSet.xml");
   // Set the configuration file, which describes the user interactions that trigger actions
   // in this file SHIFT + LeftClick triggers add Point, but by modifying this file,
   // it could as well be changes to any other user interaction.
   interactor->SetEventConfig("PointSetConfig.xml");
 
   // Assign the pointSetNode to the interactor,
   // alternatively one could also add the DataInteractor to the pointSetNode using the SetDataInteractor() method.
   interactor->SetDataNode(pointSetNode);
 
   // *******************************************************
   // ******************* END OF NEW PART *******************
   // *******************************************************
 
 
 
   //*************************************************************************
   //Part VII: Qt-specific initialization
   //*************************************************************************
   toplevelWidget.show();
 
   // For testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 /**
 \example Step5.cpp
 */
diff --git a/Examples/Tutorial/Step6/Step6.cpp b/Examples/Tutorial/Step6/Step6.cpp
index a89d418c73..acff49c596 100644
--- a/Examples/Tutorial/Step6/Step6.cpp
+++ b/Examples/Tutorial/Step6/Step6.cpp
@@ -1,236 +1,236 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "Step6.h"
 
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceWidget.h"
 
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkPointSet.h"
 #include "mitkPointSetDataInteractor.h"
 
 #include "mitkImageAccessByItk.h"
 
 #include "mitkRenderingManager.h"
 #include <mitkIOUtil.h>
 
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QPushButton>
 #include <QLabel>
 #include <QLineEdit>
 #include <QPushButton>
 
 //##Documentation
 //## @brief Start region-grower at interactively added points
 Step6::Step6(int argc, char* argv[], QWidget *parent)
 : QWidget(parent)
 {
   // load data as in the previous steps; a reference to the first loaded
   // image is kept in the member m_FirstImage and used as input for the
   // region growing
   Load(argc, argv);
 }
 
 void Step6::Initialize()
 {
   // setup the widgets as in the previous steps, but with an additional
   // QVBox for a button to start the segmentation
   this->SetupWidgets();
 
   // Create controlsParent widget with horizontal layout
   QWidget *controlsParent = new QWidget(this);
   this->layout()->addWidget(controlsParent);
 
   QHBoxLayout* hlayout = new QHBoxLayout(controlsParent);
   hlayout->setSpacing(2);
 
   QLabel *labelThresholdMin = new QLabel("Lower Threshold:", controlsParent);
   hlayout->addWidget(labelThresholdMin);
 
   m_LineEditThresholdMin = new QLineEdit("-1000", controlsParent);
   hlayout->addWidget(m_LineEditThresholdMin);
 
   QLabel *labelThresholdMax = new QLabel("Upper Threshold:", controlsParent);
   hlayout->addWidget(labelThresholdMax);
 
   m_LineEditThresholdMax = new QLineEdit("-400", controlsParent);
   hlayout->addWidget(m_LineEditThresholdMax);
 
   // create button to start the segmentation and connect its clicked()
   // signal to method StartRegionGrowing
   QPushButton* startButton = new QPushButton("start region growing",
       controlsParent);
   hlayout->addWidget(startButton);
 
   connect(startButton, SIGNAL(clicked()), this, SLOT(StartRegionGrowing()));
   if (m_FirstImage.IsNull())
     startButton->setEnabled(false);
 
   // as in Step5, create PointSet (now as a member m_Seeds) and
   // associate a interactor to it
 
   m_Seeds = mitk::PointSet::New();
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   pointSetNode->SetData(m_Seeds);
   pointSetNode->SetProperty("layer", mitk::IntProperty::New(2));
   m_DataStorage->Add(pointSetNode);
 
   // Create PointSetDataInteractor
   mitk::PointSetDataInteractor::Pointer interactor = mitk::PointSetDataInteractor::New();
   interactor->LoadStateMachine("PointSet.xml");
   interactor->SetEventConfig("PointSetConfig.xml");
   interactor->SetDataNode(pointSetNode);
 }
 
 int Step6::GetThresholdMin()
 {
   return m_LineEditThresholdMin->text().toInt();
 }
 
 int Step6::GetThresholdMax()
 {
   return m_LineEditThresholdMax->text().toInt();
 }
 
 void Step6::StartRegionGrowing()
 {
   AccessByItk_1(m_FirstImage, RegionGrowing, this);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void Step6::Load(int argc, char* argv[])
 {
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   m_DataStorage = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for (i = 1; i < argc; ++i)
   {
     // For testing
     if (strcmp(argv[i], "-testing") == 0)
       continue;
 
     // Load datanode (eg. many image formats, surface formats, etc.)
-    mitk::StandaloneDataStorage::SetOfObjects* dataNodes = mitk::IOUtil::Load(argv[i],*m_DataStorage);
+    mitk::StandaloneDataStorage::SetOfObjects::Pointer dataNodes = mitk::IOUtil::Load(argv[i],*m_DataStorage);
 
     if(dataNodes->empty())
     {
       fprintf( stderr, "Could not open file %s \n\n", argv[i] );
       exit(2);
     }
 
     mitk::Image::Pointer image =  dynamic_cast<mitk::Image*> (dataNodes->at(0)->GetData());
     if ((m_FirstImage.IsNull()) && (image.IsNotNull()))
       m_FirstImage = image;
   }
 }
 
 void Step6::SetupWidgets()
 {
   //*************************************************************************
   // Part I: Create windows and pass the datastorage to it
   //*************************************************************************
 
   // Create toplevel widget with vertical layout
   QVBoxLayout* vlayout = new QVBoxLayout(this);
   vlayout->setMargin(0);
   vlayout->setSpacing(2);
 
   // Create viewParent widget with horizontal layout
   QWidget* viewParent = new QWidget(this);
   vlayout->addWidget(viewParent);
 
   QHBoxLayout* hlayout = new QHBoxLayout(viewParent);
   hlayout->setMargin(0);
   hlayout->setSpacing(2);
 
   //*************************************************************************
   // Part Ia: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow* renderWindow = new QmitkRenderWindow(viewParent);
   hlayout->addWidget(renderWindow);
 
   // Tell the renderwindow which (part of) the tree to render
   renderWindow->GetRenderer()->SetDataStorage(m_DataStorage);
 
   // Use it as a 3D view
   renderWindow->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   //*************************************************************************
   // Part Ib: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget *view2 = new QmitkSliceWidget(viewParent);
   hlayout->addWidget(view2);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2->SetDataStorage(m_DataStorage);
   mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
   view2->SetData(rs->Begin(), mitk::SliceNavigationController::Axial);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   m_DataStorage->Add(view2->GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part Ic: 2D view for slicing sagitally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget *view3 = new QmitkSliceWidget(viewParent);
   hlayout->addWidget(view3);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render
   // and to slice sagitally
   view3->SetDataStorage(m_DataStorage);
   view3->SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   m_DataStorage->Add(view3->GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part II: handle updates: To avoid unnecessary updates, we have to
   //*************************************************************************
   // define when to update. The RenderingManager serves this purpose, and
   // each RenderWindow has to be registered to it.
   /*mitk::RenderingManager *renderingManager =
    mitk::RenderingManager::GetInstance();
    renderingManager->AddRenderWindow( renderWindow );
    renderingManager->AddRenderWindow( view2->GetRenderWindow() );
    renderingManager->AddRenderWindow( view3->GetRenderWindow() );*/
 }
 
 /**
  \example Step6.cpp
  */
diff --git a/SuperBuild.cmake b/SuperBuild.cmake
index 9e63a46a0f..7fd30eb07d 100644
--- a/SuperBuild.cmake
+++ b/SuperBuild.cmake
@@ -1,445 +1,444 @@
 include(mitkFunctionInstallExternalCMakeProject)
 
 #-----------------------------------------------------------------------------
 # 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)
 
   # Check for libwrap0-dev
   mitkFunctionCheckPackageHeader(tcpd.h libwrap0-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()
 
 #-----------------------------------------------------------------------------
 # Qt options for external projects and MITK
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_QT)
   set(qt_project_args -DDESIRED_QT_VERSION:STRING=${DESIRED_QT_VERSION})
 else()
   set(qt_project_args )
 endif()
 
 if(MITK_USE_Qt4)
   list(APPEND qt_project_args
        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} )
 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 Python)
 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()
 
 if(MITK_USE_Boost)
   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()
 endif()
 
 # Setup file for setting custom ctest vars
 configure_file(
   CMake/SuperbuildCTestCustom.cmake.in
   ${MITK_BINARY_DIR}/CTestCustom.cmake
   @ONLY
 )
 
 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)
 
 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()
 
 # 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()
 
 # 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_DEBUG_POSTFIX:STRING=d
   -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_CXX11_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}
 )
 
 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})
   include(CMakeExternals/${p}.cmake)
 
   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()
 
 #-----------------------------------------------------------------------------
 # 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_TUTORIAL # Deprecated. Use MITK_BUILD_EXAMPLES instead
   MITK_BUILD_EXAMPLES
 
   MITK_USE_QT
   MITK_USE_SYSTEM_Boost
   MITK_USE_BLUEBERRY
   MITK_USE_OpenCL
 
   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_Python)
   list(APPEND mitk_optional_cache_args
        -DMITK_USE_Python:BOOL=${MITK_USE_Python}
        -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
        -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
        -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
        -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2}
        -DMITK_USE_SYSTEM_PYTHON:BOOL=${MITK_USE_SYSTEM_PYTHON}
       )
 endif()
 
 set(proj MITK-Configure)
 
 ExternalProject_Add(${proj}
   LIST_SEPARATOR ${sep}
   DOWNLOAD_COMMAND ""
   CMAKE_GENERATOR ${gen}
   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_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}
     -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}
     ${qt_project_args}
     -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}
     # --------------- External project options ---------------
     -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR}
     -DMITK_EXTERNAL_PROJECT_PREFIX:PATH=${ep_prefix}
     -DCppMicroServices_DIR:PATH=${CppMicroServices_DIR}
     -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE}
     -DDCMTK_CMAKE_DEBUG_POSTFIX:STRING=d
     -DBOOST_ROOT:PATH=${BOOST_ROOT}
     -DBOOST_LIBRARYDIR:PATH=${BOOST_LIBRARYDIR}
     -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES}
   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
 )