diff --git a/Examples/Tutorial/Step1/Step1.cpp b/Examples/Tutorial/Step1/Step1.cpp
index 140bd8a6f5..bbc976789b 100644
--- a/Examples/Tutorial/Step1/Step1.cpp
+++ b/Examples/Tutorial/Step1/Step1.cpp
@@ -1,115 +1,117 @@
 /*===================================================================
 
 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 <mitkDataNodeFactory.h>
 #include <mitkStandaloneDataStorage.h>
+#include <mitkIOUtil.h>
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 
 //##Documentation
 //## @brief Load image (nrrd format) and display it in a 2D view
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
 
   if (argc < 2)
   {
     fprintf( stderr, "Usage:   %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   // The DataStorage manages all data objects. It is used by the
   // rendering mechanism to render all data objects
   // We use the standard implementation mitk::StandaloneDataStorage.
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
 
   //*************************************************************************
   // Part II: Create some data by reading a file
   //*************************************************************************
 
-  // Create a DataNodeFactory to read a data format supported
-  // by the DataNodeFactory (many image formats, surface formats, etc.)
-  mitk::DataNodeFactory::Pointer reader=mitk::DataNodeFactory::New();
+  // Read supported data formats by using the IOUtil helper class.
   const char * filename = argv[1];
   try
   {
-    reader->SetFileName(filename);
-    reader->Update();
-    //*************************************************************************
+    std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(filename);
+
+    //*********************************************************************
     // Part III: Put the data into the datastorage
-    //*************************************************************************
+    //*********************************************************************
+
+    // First, put the data into a data node
+    mitk::DataNode::Pointer node = mitk::DataNode::New();
+    node->SetData(baseData.at(0));
 
-    // Add the node to the DataStorage
-    ds->Add(reader->GetOutput());
+    // Then, add the newly created data node into the datastorage
+    ds->Add(node);
   }
   catch(...)
   {
     fprintf( stderr, "Could not open file %s \n\n", filename );
     exit(2);
   }
 
   //*************************************************************************
   // Part IV: Create window and pass the datastorage to it
   //*************************************************************************
 
   // Create a RenderWindow
   QmitkRenderWindow renderWindow;
 
   // Tell the RenderWindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Initialize the RenderWindow
   mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews( geo );
   //mitk::RenderingManager::GetInstance()->InitializeViews();
 
   // Select a slice
   mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
   if (sliceNaviController)
     sliceNaviController->GetSlice()->SetPos( 0 );
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   renderWindow.show();
   renderWindow.resize( 256, 256 );
 
   // for testing
   #include "QtTesting.h"
   if (strcmp(argv[argc-1], "-testing") != 0)
     return qtapplication.exec();
   else
     return QtTesting();
 
   // cleanup: Remove References to DataStorage. This will delete the object
   ds = NULL;
 }
 /**
 \example Step1.cpp
 */
diff --git a/Examples/Tutorial/Step2/Step2.cpp b/Examples/Tutorial/Step2/Step2.cpp
index 94dc282bb5..7dc030bffe 100644
--- a/Examples/Tutorial/Step2/Step2.cpp
+++ b/Examples/Tutorial/Step2/Step2.cpp
@@ -1,118 +1,120 @@
 /*===================================================================
 
 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 <mitkDataNodeFactory.h>
+
 #include <mitkStandaloneDataStorage.h>
+#include <mitkIOUtil.h>
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 
 //##Documentation
 //## @brief Load one or more data sets (many image, surface
 //## and other formats) and display it in a 2D view
 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 data storage object. We will use it as a singleton
   mitk::StandaloneDataStorage::Pointer storage = 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;
 
-    // Create a DataNodeFactory to read a data format supported
-    // by the DataNodeFactory (many image formats, surface formats, etc.)
-    mitk::DataNodeFactory::Pointer nodeReader=mitk::DataNodeFactory::New();
+    // Read supported data formats by using the IOUtil helper class.
     const char * filename = argv[i];
     try
     {
-      nodeReader->SetFileName(filename);
-      nodeReader->Update();
+      std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(filename);
+
       //*********************************************************************
       // Part III: Put the data into the datastorage
       //*********************************************************************
 
-      // Since the DataNodeFactory directly creates a node,
-      // use the datastorage to add the read node
-      storage->Add(nodeReader->GetOutput());
+      // First, put the data into a data node
+      mitk::DataNode::Pointer node = mitk::DataNode::New();
+      node->SetData(baseData.at(0));
+
+      // Then, add the newly created data node into the datastorage
+      storage->Add(node);
     }
     catch(...)
     {
       fprintf( stderr, "Could not open file %s \n\n", filename );
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part IV: Create window and pass the datastorage to it
   //*************************************************************************
 
   // Create a RenderWindow
   QmitkRenderWindow renderWindow;
 
   // Tell the RenderWindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(storage);
 
   // Initialize the RenderWindow
   mitk::TimeGeometry::Pointer geo = storage->ComputeBoundingGeometry3D(storage->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews( geo );
 
   // Select a slice
   mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
   if (sliceNaviController)
     sliceNaviController->GetSlice()->SetPos( 2 );
 
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   renderWindow.show();
   renderWindow.resize( 256, 256 );
 
   // for testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 
 /**
 \example Step2.cpp
 */
diff --git a/Examples/Tutorial/Step3/Step3.cpp b/Examples/Tutorial/Step3/Step3.cpp
index 98aedaa4d1..8ebd588158 100644
--- a/Examples/Tutorial/Step3/Step3.cpp
+++ b/Examples/Tutorial/Step3/Step3.cpp
@@ -1,171 +1,170 @@
 /*===================================================================
 
 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 <mitkDataNodeFactory.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;
 
-    // Create a DataNodeFactory to read a data format supported
-    // by the DataNodeFactory (many image formats, surface formats, etc.)
-    mitk::DataNodeFactory::Pointer nodeReader=mitk::DataNodeFactory::New();
+    // Read supported data formats by using the IOUtil helper class.
     const char * filename = argv[i];
     try
     {
-      nodeReader->SetFileName(filename);
-      nodeReader->Update();
+      std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(filename);
 
       //*********************************************************************
       // Part III: Put the data into the datastorage
       //*********************************************************************
 
-      // Since the DataNodeFactory directly creates a node,
-      // use the datastorage to add the read node
-      mitk::DataNode::Pointer node = nodeReader->GetOutput();
+      // First, put the data into a data node
+      mitk::DataNode::Pointer node = mitk::DataNode::New();
+      node->SetData(baseData.at(0));
+
+      // Then, add the newly created data node into the datastorage
       ds->Add(node);
 
       // *********************************************************
       // ****************** 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 *******************
       // *********************************************************
     }
     catch(...)
     {
       fprintf( stderr, "Could not open file %s \n\n", filename );
       exit(2);
     }
   }
 
   //*************************************************************************
   // 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/Step4/Step4.cpp b/Examples/Tutorial/Step4/Step4.cpp
index 8460245239..d8b1f224c0 100644
--- a/Examples/Tutorial/Step4/Step4.cpp
+++ b/Examples/Tutorial/Step4/Step4.cpp
@@ -1,187 +1,187 @@
 /*===================================================================
 
 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 "mitkDataNodeFactory.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkNodePredicateDataType.h"
+#include "mitkIOUtil.h"
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 #include <QHBoxLayout>
 #include <mitkImage.h>
 
 //##Documentation
 //## @brief Use several views to explore data
 //##
 //## As in Step2 and Step3, load one or more data sets (many image,
 //## surface and other formats), but create 3 views on the data.
 //## The QmitkRenderWindow is used for displaying a 3D view as in Step3,
 //## but without volume-rendering.
 //## Furthermore, we create two 2D views for slicing through the data.
 //## We use the class QmitkSliceWidget, which is based on the class
 //## QmitkRenderWindow, but additionally provides sliders
 //## to slice through the data. We create two instances of
 //## QmitkSliceWidget, one for axial and one for sagittal slicing.
 //## The two slices are also shown at their correct position in 3D as
 //## well as intersection-line, each in the other 2D view.
 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;
 
-    // Create a DataNodeFactory to read a data format supported
-    // by the DataNodeFactory (many image formats, surface formats, etc.)
-    mitk::DataNodeFactory::Pointer nodeReader=mitk::DataNodeFactory::New();
+    // Read supported data formats by using the IOUtil helper class.
     const char * filename = argv[i];
     try
     {
-      nodeReader->SetFileName(filename);
-      nodeReader->Update();
+      std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(filename);
+
       //*********************************************************************
-      //Part III: Put the data into the datastorage
+      // Part III: Put the data into the datastorage
       //*********************************************************************
 
-      // Since the DataNodeFactory directly creates a node,
-      // use the datastorage to add the read node
-      mitk::DataNode::Pointer node = nodeReader->GetOutput();
+      // First, put the data into a data node
+      mitk::DataNode::Pointer node = mitk::DataNode::New();
+      node->SetData(baseData.at(0));
+
+      // Then, add the newly created data node into the datastorage
       ds->Add(node);
     }
     catch(...)
     {
       fprintf( stderr, "Could not open file %s \n\n", filename );
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part IV: 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 IVa: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow(&toplevelWidget);
   layout.addWidget(&renderWindow);
 
   // Tell the renderwindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Use it as a 3D view
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   // *******************************************************
   // ****************** START OF NEW PART ******************
   // *******************************************************
 
   //*************************************************************************
   // Part IVb: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view2(&toplevelWidget);
   layout.addWidget(&view2);
   view2.SetLevelWindowEnabled(true);
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2.SetDataStorage(ds);
 
   // Get the image from the data storage. A predicate (mitk::NodePredicateBase)
   // is used to get only nodes of the type mitk::Image.
   mitk::DataStorage::SetOfObjects::ConstPointer rs =
       ds->GetSubset(mitk::TNodePredicateDataType<mitk::Image>::New());
 
   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 datastorage!
   ds->Add(view2.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part IVc: 2D view for slicing sagitally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view3(&toplevelWidget);
   layout.addWidget(&view3);
   view3.SetDataStorage(ds);
   // Tell the QmitkSliceWidget which (part of) the datastorage to render
   // and to slice sagitally
   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 datastorage!
   ds->Add(view3.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   // *******************************************************
   // ******************* END OF NEW PART *******************
   // *******************************************************
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   toplevelWidget.show();
 
   // for testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 
 /**
 \example Step4.cpp
 */
diff --git a/Examples/Tutorial/Step5/Step5.cpp b/Examples/Tutorial/Step5/Step5.cpp
index 9d0fd14e36..7122194e01 100644
--- a/Examples/Tutorial/Step5/Step5.cpp
+++ b/Examples/Tutorial/Step5/Step5.cpp
@@ -1,219 +1,219 @@
 /*===================================================================
 
 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 "mitkDataNodeFactory.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
+#include "mitkIOUtil.h"
 
 #include "mitkPointSet.h"
 // NEW INCLUDE
 #include "mitkPointSetDataInteractor.h"
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 #include <QHBoxLayout>
 
 //##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;
 
-    // Create a DataNodeFactory to read a data format supported
-    // by the DataNodeFactory (many image formats, surface formats, etc.)
-    mitk::DataNodeFactory::Pointer nodeReader=mitk::DataNodeFactory::New();
+    // Read supported data formats by using the IOUtil helper class.
     const char * filename = argv[i];
     try
     {
-      nodeReader->SetFileName(filename);
-      nodeReader->Update();
+      std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(filename);
+
       //*********************************************************************
       // Part III: Put the data into the datastorage
       //*********************************************************************
 
-      // Since the DataNodeFactory directly creates a node,
-      // use the iterator to add the read node to the tree
-      mitk::DataNode::Pointer node = nodeReader->GetOutput();
+      // First, put the data into a data node
+      mitk::DataNode::Pointer node = mitk::DataNode::New();
+      node->SetData(baseData.at(0));
+
+      // Then, add the newly created data node into the datastorage
       ds->Add(node);
     }
     catch(...)
     {
       fprintf( stderr, "Could not open file %s \n\n", filename );
       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 0e8c17ea86..7120308372 100644
--- a/Examples/Tutorial/Step6/Step6.cpp
+++ b/Examples/Tutorial/Step6/Step6.cpp
@@ -1,251 +1,251 @@
 /*===================================================================
 
 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 "mitkDataNodeFactory.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;
 
-    // Create a DataNodeFactory to read a data format supported
-    // by the DataNodeFactory (many image formats, surface formats, etc.)
-    mitk::DataNodeFactory::Pointer nodeReader =
-        mitk::DataNodeFactory::New();
+    // Read supported data formats by using the IOUtil helper class.
     const char * filename = argv[i];
     try
     {
-      nodeReader->SetFileName(filename);
-      nodeReader->Update();
+      std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(filename);
+
       //*********************************************************************
       // Part III: Put the data into the datastorage
       //*********************************************************************
 
-      // Since the DataNodeFactory directly creates a node,
-      // use the iterator to add the read node to the tree
-      mitk::DataNode::Pointer node = nodeReader->GetOutput();
+      // First, put the data into a data node
+      mitk::DataNode::Pointer node = mitk::DataNode::New();
+      node->SetData(baseData.at(0));
+
+      // Then, add the newly created data node into the datastorage
       m_DataStorage->Add(node);
 
       mitk::Image::Pointer image =
           dynamic_cast<mitk::Image*> (node->GetData());
       if ((m_FirstImage.IsNull()) && (image.IsNotNull()))
         m_FirstImage = image;
     } catch (...)
     {
       fprintf(stderr, "Could not open file %s \n\n", filename);
       exit(2);
     }
   }
 }
 
 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/Plugins/org.mitk.gui.qt.aicpregistration/src/internal/org_mitk_gui_qt_aicpregistration_Activator.cpp b/Plugins/org.mitk.gui.qt.aicpregistration/src/internal/org_mitk_gui_qt_aicpregistration_Activator.cpp
index 2b02c4d3b7..8c44139ca9 100644
--- a/Plugins/org.mitk.gui.qt.aicpregistration/src/internal/org_mitk_gui_qt_aicpregistration_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.aicpregistration/src/internal/org_mitk_gui_qt_aicpregistration_Activator.cpp
@@ -1,38 +1,40 @@
 /*===================================================================
 
 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 "org_mitk_gui_qt_aicpregistration_Activator.h"
 
 #include <QtPlugin>
 
 #include "QmitkAICPRegistrationView.h"
 
 namespace mitk {
 
 void org_mitk_gui_qt_aicpregistration_Activator::start(ctkPluginContext* context)
 {
   BERRY_REGISTER_EXTENSION_CLASS(QmitkAICPRegistrationView, context)
 }
 
 void org_mitk_gui_qt_aicpregistration_Activator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 }
 
 }
 
-Q_EXPORT_PLUGIN2(org_mitk_gui_qt_aicpregistration, mitk::org_mitk_gui_qt_aicpregistration_Activator)
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
+  Q_EXPORT_PLUGIN2(org_mitk_gui_qt_aicpregistration, mitk::org_mitk_gui_qt_aicpregistration_Activator)
+#endif
diff --git a/Plugins/org.mitk.gui.qt.aicpregistration/src/internal/org_mitk_gui_qt_aicpregistration_Activator.h b/Plugins/org.mitk.gui.qt.aicpregistration/src/internal/org_mitk_gui_qt_aicpregistration_Activator.h
index c2d13fe144..7488795e83 100644
--- a/Plugins/org.mitk.gui.qt.aicpregistration/src/internal/org_mitk_gui_qt_aicpregistration_Activator.h
+++ b/Plugins/org.mitk.gui.qt.aicpregistration/src/internal/org_mitk_gui_qt_aicpregistration_Activator.h
@@ -1,40 +1,43 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #ifndef org_mitk_gui_qt_aicpregistration_Activator_h
 #define org_mitk_gui_qt_aicpregistration_Activator_h
 
 #include <ctkPluginActivator.h>
 
 namespace mitk {
 
 class org_mitk_gui_qt_aicpregistration_Activator :
   public QObject, public ctkPluginActivator
 {
   Q_OBJECT
+#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
+  Q_PLUGIN_METADATA(IID "org_mitk_gui_qt_aicpregistration")
+#endif
   Q_INTERFACES(ctkPluginActivator)
 
 public:
 
   void start(ctkPluginContext* context);
   void stop(ctkPluginContext* context);
 
 }; // org_mitk_gui_qt_surfaceregistration_Activator
 
 }
 
 #endif // org_mitk_gui_qt_surfaceregistration_Activator_h
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
index d26aaaa56a..2cf12815c3 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
@@ -1,302 +1,302 @@
 /*===================================================================
 
 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 "QmitkDTIAtlasAppIntroPart.h"
 
 #include "mitkNodePredicateDataType.h"
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbench.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPerspectiveRegistry.h>
 #include <berryWorkbenchPreferenceConstants.h>
 #include <berryIPreferences.h>
 #include <berryIEditorReference.h>
 
 #include <mitkLogMacros.h>
 
 #include <QLabel>
 #include <QMessageBox>
 #include <QtCore/qconfig.h>
 #ifdef QT_WEBKIT
 #  include <QWebView>
 #  include <QWebPage>
 #  if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
 #    include <QUrlQuery>
 #  endif
 #endif
 #include <QString>
 #include <QStringList>
 #include <QRegExp>
 #include <QChar>
 #include <QByteArray>
 #include <QDesktopServices>
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkStdMultiWidgetEditor.h"
 #include "QmitkDTIAtlasAppApplicationPlugin.h"
 #include "mitkDataStorageEditorInput.h"
 
 #include "mitkSceneIO.h"
 #include "mitkProgressBar.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateProperty.h"
 #include <mitkIOUtil.h>
 
 QmitkDTIAtlasAppIntroPart::QmitkDTIAtlasAppIntroPart()
   : m_Controls(NULL)
 {
   berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
   workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
   workbenchPrefs->Flush();
 }
 
 QmitkDTIAtlasAppIntroPart::~QmitkDTIAtlasAppIntroPart()
 {
   // if the workbench is not closing (that means, welcome screen was closed explicitly), set "Show_intro" false
   if (!this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
   {
     berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
     workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, false);
     workbenchPrefs->Flush();
   }
   else
   {
     berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
     workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
     workbenchPrefs->Flush();
   }
 
   // if workbench is not closing (Just welcome screen closing), open last used perspective
   if (this->GetIntroSite()->GetPage()->GetPerspective()->GetId()
     == "org.mitk.dtiatlasapp.perspectives.welcome" && !this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
     {
     berry::IPerspectiveDescriptor::Pointer perspective = this->GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->GetPerspectiveRegistry()->FindPerspectiveWithId("org.mitk.dtiatlasapp.perspectives.dtiatlasapp");
     if (perspective)
     {
       this->GetIntroSite()->GetPage()->SetPerspective(perspective);
     }
   }
 
 }
 
 
 void QmitkDTIAtlasAppIntroPart::CreateQtPartControl(QWidget* parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkWelcomeScreenViewControls;
     m_Controls->setupUi(parent);
 #ifdef QT_WEBKIT
 
     // create a QWebView as well as a QWebPage and QWebFrame within the QWebview
     m_view = new QWebView(parent);
     m_view->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
 
     QUrl urlQtResource(QString("qrc:/org.mitk.gui.qt.welcomescreen/mitkdtiatlasappwelcomeview.html"),  QUrl::TolerantMode );
     m_view->load( urlQtResource );
 
     // adds the webview as a widget
     parent->layout()->addWidget(m_view);
     this->CreateConnections();
 #else
     parent->layout()->addWidget(new QLabel("<h1><center>Please install Qt with the WebKit option to see cool pictures!</center></h1>"));
 #endif
   }
 }
 
 #ifdef QT_WEBKIT
 void QmitkDTIAtlasAppIntroPart::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_view->page()), SIGNAL(linkClicked(const QUrl& )), this, SLOT(DelegateMeTo(const QUrl& )) );
   }
 }
 
 
 void QmitkDTIAtlasAppIntroPart::DelegateMeTo(const QUrl& showMeNext)
 {
   QString scheme          = showMeNext.scheme();
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
   QByteArray urlHostname  = showMeNext.encodedHost();
   QByteArray urlPath      = showMeNext.encodedPath();
   QByteArray dataset      = showMeNext.encodedQueryItemValue("dataset");
   QByteArray clear        = showMeNext.encodedQueryItemValue("clear");
 #else
   QByteArray urlHostname  = QUrl::toAce(showMeNext.host());
   QByteArray urlPath      = showMeNext.path().toLatin1();
   QUrlQuery query(showMeNext);
   QByteArray dataset      = query.queryItemValue("dataset").toLatin1();
   QByteArray clear        = query.queryItemValue("clear").toLatin1();//showMeNext.encodedQueryItemValue("clear");
 #endif
 
   if (scheme.isEmpty()) MITK_INFO << " empty scheme of the to be delegated link" ;
 
   // if the scheme is set to mitk, it is to be tested which action should be applied
   if (scheme.contains(QString("mitk")) )
   {
     if(urlPath.isEmpty() ) MITK_INFO << " mitk path is empty " ;
 
     // searching for the perspective keyword within the host name
     if(urlHostname.contains(QByteArray("perspectives")) )
     {
       // the simplified method removes every whitespace
       // ( whitespace means any character for which the standard C++ isspace() method returns true)
       urlPath = urlPath.simplified();
       QString tmpPerspectiveId(urlPath.data());
       tmpPerspectiveId.replace(QString("/"), QString("") );
       std::string perspectiveId  = tmpPerspectiveId.toStdString();
 
       // is working fine as long as the perspective id is valid, if not the application crashes
       GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->ShowPerspective(perspectiveId, GetIntroSite()->GetWorkbenchWindow() );
 
       mitk::DataStorageEditorInput::Pointer editorInput;
       editorInput = new mitk::DataStorageEditorInput();
       berry::IEditorPart::Pointer editor = GetIntroSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID);
 
 
       QmitkStdMultiWidgetEditor::Pointer multiWidgetEditor;
       mitk::DataStorage::Pointer dataStorage;
 
       if (editor.Cast<QmitkStdMultiWidgetEditor>().IsNull())
       {
         editorInput = new mitk::DataStorageEditorInput();
         dataStorage = editorInput->GetDataStorageReference()->GetDataStorage();
       }
       else
       {
         multiWidgetEditor = editor.Cast<QmitkStdMultiWidgetEditor>();
         multiWidgetEditor->GetStdMultiWidget()->RequestUpdate();
         dataStorage = multiWidgetEditor->GetEditorInput().Cast<mitk::DataStorageEditorInput>()->GetDataStorageReference()->GetDataStorage();
       }
 
       bool dsmodified = false;
 
       QString *fileName = new QString(dataset.data());
 
       if ( fileName->right(5) == ".mitk" )
       {
         mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
 
         bool clearDataStorageFirst(false);
         QString *sClear = new QString(clear.data());
         if ( sClear->right(4) == "true" )
         {
           clearDataStorageFirst = true;
         }
 
         mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
         dataStorage = sceneIO->LoadScene( fileName->toLocal8Bit().constData(), dataStorage, clearDataStorageFirst );
         dsmodified = true;
         mitk::ProgressBar::GetInstance()->Progress(2);
       }
       else
       {
         try
         {
-          std::vector<BaseData::Pointer> baseData = mitk::IOUtil::Load(fileName->toLocal8Bit().data());
+          std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(fileName->toLocal8Bit().data());
 
           for ( unsigned int i = 0 ; i < baseData.size(); ++i )
           {
             if (baseData[i].IsNotNull())
             {
               mitk::DataNode::Pointer node = mitk::DataNode::New();
               node->SetData(baseData[i]);
               dataStorage->Add(node);
               dsmodified = true;
             }
           }
         }
         catch(...)
         {
           MITK_INFO << "Could not open file!";
         }
       }
 
 
 
       if(dataStorage.IsNotNull() && dsmodified)
       {
         // get all nodes that have not set "includeInBoundingBox" to false
         mitk::NodePredicateNot::Pointer pred
             = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
                                                                            , mitk::BoolProperty::New(false)));
 
         mitk::DataStorage::SetOfObjects::ConstPointer rs = dataStorage->GetSubset(pred);
 
         if(rs->Size() > 0)
         {
           // calculate bounding geometry of these nodes
           mitk::TimeGeometry::Pointer bounds = dataStorage->ComputeBoundingGeometry3D(rs);
           // initialize the views to the bounding geometry
           mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
         }
       }
 
 
 
 
 
     }
     // searching for the load
     if(urlHostname.contains(QByteArray("perspectives")) )
     {
       // the simplified method removes every whitespace
       // ( whitespace means any character for which the standard C++ isspace() method returns true)
       urlPath = urlPath.simplified();
       QString tmpPerspectiveId(urlPath.data());
       tmpPerspectiveId.replace(QString("/"), QString("") );
       std::string perspectiveId  = tmpPerspectiveId.toStdString();
 
       // is working fine as long as the perspective id is valid, if not the application crashes
       GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->ShowPerspective(perspectiveId, GetIntroSite()->GetWorkbenchWindow() );
 
       mitk::DataStorageEditorInput::Pointer editorInput;
       editorInput = new mitk::DataStorageEditorInput();
       GetIntroSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID);
     }
     else
     {
       MITK_INFO << "Unkown mitk action keyword (see documentation for mitk links)" ;
     }
   }
   // if the scheme is set to http, by default no action is performed, if an external webpage needs to be
   // shown it should be implemented below
   else if (scheme.contains(QString("http")) )
   {
     QDesktopServices::openUrl(showMeNext);
 //    m_view->load( ) ;
   }
   else if(scheme.contains("qrc"))
   {
     m_view->load(showMeNext);
   }
 
 }
 
 #endif
 
 void QmitkDTIAtlasAppIntroPart::StandbyStateChanged(bool)
 {
 
 }
 
 
 void QmitkDTIAtlasAppIntroPart::SetFocus()
 {
 
 }