diff --git a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
index b0b0d49bca..5f8fbf1aa1 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
@@ -1,575 +1,573 @@
 /*===================================================================
 
 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 "QmitkIGTPlayerWidget.h"
 
 //mitk headers
 #include "mitkTrackingTypes.h"
 #include <mitkSurface.h>
 #include <mitkNavigationToolReader.h>
 #include <mitkNavigationToolWriter.h>
 #include <mitkNavigationToolStorage.h>
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkNavigationToolStorageSerializer.h>
 #include <mitkIGTException.h>
-#include "mitkNavigationDataReaderXML.h"
+#include <mitkIOUtil.h>
 
 //qt headers
 #include <qfiledialog.h>
 #include <qmessagebox.h>
 #include <qtimer.h>
 
 QmitkIGTPlayerWidget::QmitkIGTPlayerWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f),
   m_RealTimePlayer(mitk::NavigationDataPlayer::New()),
   m_SequentialPlayer(mitk::NavigationDataSequentialPlayer::New()),
   m_StartTime(-1.0),
   m_CurrentSequentialPointNumber(0),
   m_Controls(new Ui::QmitkIGTPlayerWidgetControls)
 {
   m_Controls->setupUi(this);
   m_PlayingTimer = new QTimer(this); // initialize update timer
 
   CreateConnections();
 
   m_Controls->samplePositionHorizontalSlider->setVisible(false);
 
   this->ResetLCDNumbers(); // reset lcd numbers at start
 }
 
 QmitkIGTPlayerWidget::~QmitkIGTPlayerWidget()
 {
   m_PlayingTimer->stop();
 
   delete m_Controls;
 }
 
 void QmitkIGTPlayerWidget::CreateConnections()
 {
   connect( (QObject*)(m_Controls->playPushButton), SIGNAL(clicked(bool)), this, SLOT(OnPlayButtonClicked(bool)) ); // play button
   connect( (QObject*)(m_PlayingTimer), SIGNAL(timeout()), this, SLOT(OnPlaying()) ); // update timer
   connect( (QObject*) (m_Controls->beginPushButton), SIGNAL(clicked()), this, SLOT(OnGoToBegin()) ); // reset player and go to begin
   connect( (QObject*) (m_Controls->stopPushButton), SIGNAL(clicked()), this, SLOT(OnGoToEnd()) ); // reset player
   // pass this widgets protected combobox signal to public signal
   connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
   // pass this widgets protected checkbox signal to public signal
   connect( m_Controls->splineModeCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(SignalSplineModeToggled(bool)) );
   //connect( m_Controls->sequencialModeCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnSequencialModeToggled(bool)) );
 
   connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderPressed()), this, SLOT(OnSliderPressed()) );
   connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderReleased()), this, SLOT(OnSliderReleased()) );
 
   connect( m_Controls->m_OpenFileButton, SIGNAL(clicked()), this, SLOT(OnOpenFileButtonPressed()) );
 }
 
 bool QmitkIGTPlayerWidget::IsTrajectoryInSplineMode()
 {
   return m_Controls->splineModeCheckBox->isChecked();
 }
 
 bool QmitkIGTPlayerWidget::CheckInputFileValid()
 {
   QFile file(m_CmpFilename);
 
   // check if file exists
   if(!file.exists())
   {
     QMessageBox::warning(NULL, "IGTPlayer: Error", "No valid input file was loaded. Please load input file first!");
     return false;
   }
 
   return true;
 }
 
 unsigned int QmitkIGTPlayerWidget::GetNumberOfTools()
 {
   unsigned int result = 0;
 
   if(this->GetCurrentPlaybackMode() == RealTimeMode)
   {
     if(m_RealTimePlayer.IsNotNull())
       result = m_RealTimePlayer->GetNumberOfOutputs();
   }
 
   else if(this->GetCurrentPlaybackMode() == SequentialMode)
   {
     if(m_SequentialPlayer.IsNotNull())
       result = m_SequentialPlayer->GetNumberOfOutputs();
   }
 
   // at the moment this works only if player is initialized
   return result;
 }
 
 void QmitkIGTPlayerWidget::SetUpdateRate(unsigned int msecs)
 {
   m_PlayingTimer->setInterval((int) msecs); // set update timer update rate
 }
 
 void QmitkIGTPlayerWidget::OnPlayButtonClicked(bool checked)
 {
   if ( ! checked )
   {
     if ( this->GetCurrentPlaybackMode() == RealTimeMode )
     {
       m_RealTimePlayer->StopPlaying();
     }
     else if ( this->GetCurrentPlaybackMode() == SequentialMode )
     {
       //      m_SequentialPlayer->
     }
   }
 
   if(CheckInputFileValid())  // no playing possible without valid input file
   {
     switch ( this->GetCurrentPlaybackMode() )
     {
     case RealTimeMode:
       {
         break;
       }
     case SequentialMode:
       {
         break;
       }
     }
 
     PlaybackMode currentMode = this->GetCurrentPlaybackMode();
     bool isRealTimeMode = currentMode == RealTimeMode;
     bool isSequentialMode = currentMode == SequentialMode;
 
     if(checked) // play
     {
       if( (isRealTimeMode && m_RealTimePlayer.IsNull()) || (isSequentialMode && m_SequentialPlayer.IsNull()))  // start play
       {
         mitk::NavigationDataSet::Pointer navigationDataSet;
         try
         {
-          mitk::NavigationDataReaderXML::Pointer reader = mitk::NavigationDataReaderXML::New();
-          navigationDataSet = reader->Read(m_CmpFilename.toStdString());
+          navigationDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(m_CmpFilename.toStdString()).GetPointer());
         }
         catch(mitk::IGTException)
         {
           std::string errormessage = "Error during start playing. Invalid or wrong file?";
           QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
           m_Controls->playPushButton->setChecked(false);
           m_RealTimePlayer = NULL;
           return;
         }
 
         if(isRealTimeMode)
         {
           m_RealTimePlayer = mitk::NavigationDataPlayer::New();
           m_RealTimePlayer->SetNavigationDataSet(navigationDataSet);
           try
           {
             m_RealTimePlayer->StartPlaying();
           }
           catch(mitk::IGTException)
           {
             std::string errormessage = "Error during start playing. Invalid or wrong file?";
             QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
             m_Controls->playPushButton->setChecked(false);
             m_RealTimePlayer = NULL;
             return;
           }
         }
         else if(isSequentialMode)
         {
           m_SequentialPlayer = mitk::NavigationDataSequentialPlayer::New();
           try
           {
             m_SequentialPlayer->SetNavigationDataSet(navigationDataSet);
           }
           catch(mitk::IGTException)
           {
             std::string errormessage = "Error during start playing. Invalid or wrong file type?";
             QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
             m_Controls->playPushButton->setChecked(false);
             m_RealTimePlayer = NULL;
             return;
           }
 
           m_Controls->samplePositionHorizontalSlider->setMinimum(0);
 
           m_Controls->samplePositionHorizontalSlider->setMaximum(m_SequentialPlayer->GetNumberOfSnapshots());
 
           m_Controls->samplePositionHorizontalSlider->setEnabled(true);
         }
 
         m_PlayingTimer->start(100);
 
         emit SignalPlayingStarted();
       }
       else // resume play
       {
         if(isRealTimeMode)
           m_RealTimePlayer->Resume();
 
         m_PlayingTimer->start(100);
         emit SignalPlayingResumed();
       }
     }
 
     else // pause
     {
       if(isRealTimeMode)
         m_RealTimePlayer->Pause();
 
       m_PlayingTimer->stop();
       emit SignalPlayingPaused();
     }
   }
 
   else
   {
     m_Controls->playPushButton->setChecked(false); // uncheck play button if file unvalid
   }
 }
 
 QmitkIGTPlayerWidget::PlaybackMode QmitkIGTPlayerWidget::GetCurrentPlaybackMode()
 {
   /*if(m_Controls->sequencialModeCheckBox->isChecked())
   return SequentialMode;
   else*/
   return RealTimeMode;
 }
 
 QTimer*  QmitkIGTPlayerWidget::GetPlayingTimer()
 {
   return m_PlayingTimer;
 }
 
 void QmitkIGTPlayerWidget::OnStopPlaying()
 {
   this->StopPlaying();
 }
 
 void QmitkIGTPlayerWidget::StopPlaying()
 {
   m_PlayingTimer->stop();
   emit SignalPlayingStopped();
 
   if(m_RealTimePlayer.IsNotNull())
     m_RealTimePlayer->StopPlaying();
 
   m_StartTime = -1;  // set starttime back
   m_CurrentSequentialPointNumber = 0;
   m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber);
   m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
 
   this->ResetLCDNumbers();
   m_Controls->playPushButton->setChecked(false); // set play button unchecked
 }
 
 void QmitkIGTPlayerWidget::OnPlaying()
 {
   switch ( this->GetCurrentPlaybackMode() )
   {
   case RealTimeMode:
     {
       if ( m_RealTimePlayer.IsNull() ) { return; }
 
       if ( m_StartTime < 0 )
       {
         // get playback start time
         m_StartTime = m_RealTimePlayer->GetOutput()->GetTimeStamp();
       }
 
       if( ! m_RealTimePlayer->IsAtEnd() )
       {
         m_RealTimePlayer->Update(); // update player
 
         int msc = (int) (m_RealTimePlayer->GetOutput()->GetTimeStamp() - m_StartTime);
 
         // calculation for playing time display
         int ms = msc % 1000;
         msc = (msc - ms) / 1000;
         int s = msc % 60;
         int min = (msc-s) / 60;
 
         // set lcd numbers
         m_Controls->msecLCDNumber->display(ms);
         m_Controls->secLCDNumber->display(s);
         m_Controls->minLCDNumber->display(min);
 
         emit SignalPlayerUpdated(); // player successfully updated
       }
       else
       {
         this->StopPlaying(); // if player is at EOF
       }
 
       break;
     }
   case SequentialMode:
     {
       if ( m_SequentialPlayer.IsNull() ) { return; }
 
       if ( m_CurrentSequentialPointNumber < m_SequentialPlayer->GetNumberOfSnapshots() )
       {
         m_SequentialPlayer->Update(); // update sequential player
 
         m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber++); // refresh slider position
         m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
 
         //for debugging purposes
         //std::cout << "Sample: " << m_CurrentSequentialPointNumber << " X: " << m_SequentialPlayer->GetOutput()->GetPosition()[0] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[1] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[2] << std::endl;
 
         emit SignalPlayerUpdated(); // player successfully updated
       }
       else
       {
         this->StopPlaying(); // if player is at EOF
       }
 
       break;
     }
   }
 }
 
 const std::vector<mitk::NavigationData::Pointer> QmitkIGTPlayerWidget::GetNavigationDatas()
 {
   std::vector<mitk::NavigationData::Pointer> navDatas;
 
   if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
   {
     for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
     {
       navDatas.push_back(m_RealTimePlayer->GetOutput(i)); // push back current navigation data for each tool
     }
   }
 
   else if(this->GetCurrentPlaybackMode() == SequentialMode && m_SequentialPlayer.IsNotNull())
   {
     for(unsigned int i=0; i < m_SequentialPlayer->GetNumberOfOutputs(); ++i)
     {
       navDatas.push_back(m_SequentialPlayer->GetOutput(i)); // push back current navigation data for each tool
     }
   }
 
   return navDatas;
 }
 
 const mitk::PointSet::Pointer QmitkIGTPlayerWidget::GetNavigationDatasPointSet()
 {
   mitk::PointSet::Pointer result = mitk::PointSet::New();
 
   mitk::PointSet::PointType pointType;
 
   PlaybackMode currentMode = this->GetCurrentPlaybackMode();
   bool isRealTimeMode = currentMode == RealTimeMode;
   bool isSequentialMode = currentMode == SequentialMode;
 
   if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
   {
     int numberOfOutputs = 0;
 
     if(isRealTimeMode)
       numberOfOutputs = m_RealTimePlayer->GetNumberOfOutputs();
     else if(isSequentialMode)
       numberOfOutputs = m_SequentialPlayer->GetNumberOfOutputs();
 
     for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
     {
       mitk::NavigationData::PositionType position;
 
       if(isRealTimeMode)
         position = m_RealTimePlayer->GetOutput(i)->GetPosition();
       else if(isSequentialMode)
         position = m_SequentialPlayer->GetOutput(i)->GetPosition();
 
       pointType[0] = position[0];
       pointType[1] = position[1];
       pointType[2] = position[2];
 
       result->InsertPoint(i,pointType);  // insert current ND as Pointtype in PointSet for return
     }
   }
 
   return result;
 }
 
 const mitk::PointSet::PointType QmitkIGTPlayerWidget::GetNavigationDataPoint(unsigned int index)
 {
   if( index > this->GetNumberOfTools() || index < 0 )
     throw std::out_of_range("Tool Index out of range!");
 
   PlaybackMode currentMode = this->GetCurrentPlaybackMode();
   bool isRealTimeMode = currentMode == RealTimeMode;
   bool isSequentialMode = currentMode == SequentialMode;
 
   // create return PointType from current ND for tool index
   mitk::PointSet::PointType result;
 
   if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
   {
     mitk::NavigationData::PositionType position;
 
     if(isRealTimeMode)
       position = m_RealTimePlayer->GetOutput(index)->GetPosition();
     else if(isSequentialMode)
       position = m_SequentialPlayer->GetOutput(index)->GetPosition();
 
     result[0] = position[0];
     result[1] = position[1];
     result[2] = position[2];
   }
 
   return result;
 }
 
 /*void QmitkIGTPlayerWidget::SetRealTimePlayer( mitk::NavigationDataPlayer::Pointer player )
 {
 if(player.IsNotNull())
 m_RealTimePlayer = player;
 }
 
 void QmitkIGTPlayerWidget::SetSequentialPlayer( mitk::NavigationDataSequentialPlayer::Pointer player )
 {
 if(player.IsNotNull())
 m_SequentialPlayer = player;
 }*/
 
 void QmitkIGTPlayerWidget::OnOpenFileButtonPressed()
 {
   QString filename = QFileDialog::getOpenFileName(this, "Load tracking data", QDir::currentPath(),"XML files (*.xml)");
   QFile file(filename);
 
   // if something went wrong or user pressed cancel in the save dialog
   if ( filename.isEmpty()  || ! file.exists() )
   {
     QMessageBox::warning(NULL, "Warning", QString("Please enter valid path. Using previous path again."));
     return;
   }
 
   m_CmpFilename = filename;
 
   this->OnGoToEnd(); /// stops playing and resets lcd numbers
 
   m_Controls->m_ActiveFileLabel->setText(m_CmpFilename);
 
   emit SignalInputFileChanged();
 
-  mitk::NavigationDataReaderInterface::Pointer navigationDataReader = mitk::NavigationDataReaderXML::New().GetPointer();
-  mitk::NavigationDataSet::Pointer navigationDataSet = navigationDataReader->Read(m_CmpFilename.toStdString());
+  mitk::NavigationDataSet::Pointer navigationDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(m_CmpFilename.toStdString()).GetPointer());
   m_RealTimePlayer->SetNavigationDataSet(navigationDataSet);
   m_SequentialPlayer->SetNavigationDataSet(navigationDataSet);
 
   m_Controls->m_PlayerControlsGroupBox->setEnabled(true);
 }
 
 void QmitkIGTPlayerWidget::OnGoToEnd()
 {
   this->StopPlaying();
 
   // reset lcd numbers
   this->ResetLCDNumbers();
 }
 
 void QmitkIGTPlayerWidget::OnGoToBegin()
 {
   // stop player manual so no PlayingStopped()
   m_PlayingTimer->stop();
 
   if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
   {
     m_RealTimePlayer->StopPlaying();
     m_RealTimePlayer = NULL;  // set player to NULL so it can be initialized again if playback is called afterwards
   }
 
   m_StartTime = -1;  // set starttime back
 
   //reset view elements
   m_Controls->playPushButton->setChecked(false);
   this->ResetLCDNumbers();
 }
 
 void QmitkIGTPlayerWidget::ResetLCDNumbers()
 {
   m_Controls->minLCDNumber->display(QString("00"));
   m_Controls->secLCDNumber->display(QString("00"));
   m_Controls->msecLCDNumber->display(QString("000"));
 }
 
 void QmitkIGTPlayerWidget::SetTrajectoryNames(const QStringList toolNames)
 {
   QComboBox* cBox = m_Controls->trajectorySelectComboBox;
 
   if(cBox->count() > 0)
     this->ClearTrajectorySelectCombobox();
 
   // before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
   disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
 
   if(!toolNames.isEmpty())
     m_Controls->trajectorySelectComboBox->insertItems(0, toolNames); // adding current tool names to combobox
 
   // reconnect after performed changes
   connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
 }
 
 int QmitkIGTPlayerWidget::GetResolution()
 {
   return m_Controls->resolutionSpinBox->value();  // return currently selected trajectory resolution
 }
 
 void QmitkIGTPlayerWidget::ClearTrajectorySelectCombobox()
 {
   // before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
   disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
 
   m_Controls->trajectorySelectComboBox->clear();
 
   // reconnect after performed changes
   connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
 }
 
 void QmitkIGTPlayerWidget::OnSequencialModeToggled(bool toggled)
 {
   this->StopPlaying(); // stop playing when mode is changed
 
   if(toggled)
   {
     m_Controls->samplePositionHorizontalSlider->setEnabled(true); // enable slider if sequential mode
   }
   else if(!toggled)
   {
     m_Controls->samplePositionHorizontalSlider->setSliderPosition(0); // set back and disable slider
     m_Controls->samplePositionHorizontalSlider->setDisabled(true);
   }
 }
 
 void QmitkIGTPlayerWidget::OnSliderReleased()
 {
   int currentSliderValue = m_Controls->samplePositionHorizontalSlider->value(); // current slider value selected through user movement
 
   if(currentSliderValue > m_CurrentSequentialPointNumber) // at the moment only forward scrolling is possible
   {
     unsigned int snapshotNumber = currentSliderValue;
     m_SequentialPlayer->GoToSnapshot(snapshotNumber); // move player to selected snapshot
     m_CurrentSequentialPointNumber = currentSliderValue;
     m_Controls->sampleLCDNumber->display(currentSliderValue); // update lcdnumber in widget
   }
   else
     m_Controls->samplePositionHorizontalSlider->setValue(m_CurrentSequentialPointNumber);
 }
 
 void QmitkIGTPlayerWidget::OnSliderPressed()
 {
   if(m_Controls->playPushButton->isChecked())  // check if widget is playing
     m_Controls->playPushButton->click(); // perform click to pause the play
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
index 3c06c30f0f..3767f5598c 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
@@ -1,248 +1,237 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkNavigationDataPlayerView.h"
 
 // QT
 #include <QFileDialog>
 #include <QMessageBox>
 
 //mitk
 #include <mitkNavigationDataSet.h>
 #include <mitkNavigationDataReaderInterface.h>
-#include <mitkNavigationDataReaderXML.h>
-#include <mitkNavigationDataReaderCSV.h>
 #include <mitkNavigationDataSequentialPlayer.h>
 #include <mitkNavigationDataPlayer.h>
 #include <mitkVirtualTrackingTool.h>
+#include <mitkIOUtil.h>
 
 // VTK
 #include <vtkSphereSource.h>
 
 const std::string QmitkNavigationDataPlayerView::VIEW_ID = "org.mitk.views.navigationdataplayer";
 
 QmitkNavigationDataPlayerView::QmitkNavigationDataPlayerView()
   : m_Controls( 0 )
 {
 }
 
 QmitkNavigationDataPlayerView::~QmitkNavigationDataPlayerView()
 {
 }
 
 void QmitkNavigationDataPlayerView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkNavigationDataPlayerViewControls;
     m_Controls->setupUi( parent );
 
     this->CreateConnections();
 
     // make deselected Player invisible
     m_Controls->m_TimedWidget->setVisible(false);
   }
 }
 
 void QmitkNavigationDataPlayerView::SetFocus()
 {
   if ( m_Controls )
   {
     m_Controls->m_grpbxControls->setFocus();
   }
 }
 
 void QmitkNavigationDataPlayerView::CreateConnections()
 {
   connect( m_Controls->m_RdbSequential, SIGNAL(released()), this, SLOT(OnSelectPlayer()) );
   connect( m_Controls->m_RdbTimeBased, SIGNAL(released()), this, SLOT(OnSelectPlayer()) );
   connect( m_Controls->m_BtnOpenFile, SIGNAL(released()), this, SLOT(OnOpenFile()) );
   connect( m_Controls->m_ChkDisplay, SIGNAL(released()), this, SLOT(OnSetDisplay()) );
   connect( m_Controls->m_chkRepeat, SIGNAL(stateChanged(int)), this, SLOT(OnSetRepeat(int)) );
   connect( m_Controls->m_ChkMicroservice, SIGNAL(released()), this, SLOT(OnSetMicroservice()) );
 
   connect( m_Controls->m_SequentialWidget, SIGNAL(SignalUpdate()), this, SLOT(OnUpdate()) );
   connect( m_Controls->m_TimedWidget, SIGNAL(SignalUpdate()), this, SLOT(OnUpdate()) );
 
   this->SetInteractionComponentsEnabledState(false);
 }
 
 void QmitkNavigationDataPlayerView::OnOpenFile()
 {
   mitk::NavigationDataReaderInterface::Pointer reader = NULL;
 
   QString filter = tr("NavigationData File (*.csv *.xml)");
 
   QString fileName = QFileDialog::getOpenFileName(NULL, tr("Open NavigationData Set"), "", filter);
 
   if ( fileName.isNull() ) { return; } // user pressed cancel
 
   try
   {
-    QString suffix = QFileInfo(fileName).suffix().toLower();
-    if(suffix == "xml")
-    {
-      reader = mitk::NavigationDataReaderXML::New();
-    }
-    else if(suffix == "csv")
-    {
-      reader = mitk::NavigationDataReaderCSV::New();
-    }
-
-    m_Data = reader->Read(fileName.toStdString());
+    m_Data = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(fileName.toStdString()).GetPointer());
   }
   catch ( const mitk::Exception &e )
   {
     MITK_WARN("NavigationDataPlayerView") << "could not open file " << fileName.toStdString();
     QMessageBox::critical(0, "Error Reading File", "The file '" + fileName
                           +"' could not be read.\n" + e.GetDescription() );
     return;
   }
 
   // Update Labels
   m_Controls->m_LblFilePath->setText(fileName);
   m_Controls->m_LblFrames->setText(QString::number(m_Data->Size()));
   m_Controls->m_LblTools->setText(QString::number(m_Data->GetNumberOfTools()));
 
   // Initialize Widgets and create Player
   this->OnSelectPlayer();
   this->SetInteractionComponentsEnabledState(true);
 }
 
 void QmitkNavigationDataPlayerView::OnSelectPlayer()
 {
   if (m_Controls->m_RdbSequential->isChecked())
   {
     m_Controls->m_SequentialWidget->setVisible(true);
     m_Controls->m_TimedWidget->setVisible(false);
     mitk::NavigationDataSequentialPlayer::Pointer seqPlayer = mitk::NavigationDataSequentialPlayer::New();
     seqPlayer->SetNavigationDataSet(m_Data);
     m_Controls->m_SequentialWidget->SetPlayer(seqPlayer);
     m_Player = seqPlayer;
   } else {
     m_Controls->m_SequentialWidget->setVisible(false);
     m_Controls->m_TimedWidget->setVisible(true);
     mitk::NavigationDataPlayer::Pointer timedPlayer = mitk::NavigationDataPlayer::New();
     timedPlayer->SetNavigationDataSet(m_Data);
     m_Controls->m_TimedWidget->SetPlayer(timedPlayer);
     m_Player = timedPlayer;
   }
 
   this->ConfigurePlayer();
 
   // SetupRenderingPipeline
   this->OnSetDisplay();
 }
 
 void QmitkNavigationDataPlayerView::ConfigurePlayer()
 {
   // set repeat mode according to the checkbox
   m_Player->SetRepeat( m_Controls->m_chkRepeat->isChecked() );
 }
 
 void QmitkNavigationDataPlayerView::OnSetRepeat(int checkState)
 {
   m_Player->SetRepeat(checkState != 0);
 }
 
 void QmitkNavigationDataPlayerView::OnSetMicroservice(){
   if(m_Controls->m_ChkMicroservice->isChecked())
   {
     m_ToolStorage = mitk::NavigationToolStorage::New();
     for (itk::ProcessObject::DataObjectPointerArraySizeType i = 0;
          i < m_Player->GetNumberOfIndexedOutputs(); i++)
     {
       mitk::NavigationTool::Pointer currentDummyTool = mitk::NavigationTool::New();
       mitk::VirtualTrackingTool::Pointer dummyTool = mitk::VirtualTrackingTool::New();
       std::stringstream name;
       name << "Virtual Tool " << i;
       dummyTool->SetToolName(name.str());
       currentDummyTool->SetTrackingTool(dummyTool.GetPointer());
       currentDummyTool->SetDataNode(m_RenderingNodes.at(i));
       currentDummyTool->SetIdentifier(name.str());
       m_ToolStorage->AddTool(currentDummyTool);
     }
     m_Player->RegisterAsMicroservice();
     m_ToolStorage->SetName("NavigationDataPlayer Tool Storage");
     m_ToolStorage->RegisterAsMicroservice(m_Player->GetMicroserviceID());
   } else {
     if (m_ToolStorage.IsNotNull()) m_ToolStorage->UnRegisterMicroservice();
     m_ToolStorage = NULL;
     m_Player->UnRegisterMicroservice();
   }
 }
 
 void QmitkNavigationDataPlayerView::OnUpdate(){
   if (m_VisFilter.IsNotNull())
   {
     m_VisFilter->Update();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkNavigationDataPlayerView::OnSetDisplay(){
   DestroyPipeline();
   if ( (m_Controls->m_ChkDisplay->isChecked()) && ( m_Player.IsNotNull() ))
   {
     CreatePipeline();
   }
 }
 
 void QmitkNavigationDataPlayerView::CreatePipeline(){
   m_VisFilter = mitk::NavigationDataObjectVisualizationFilter::New();
   m_VisFilter->ConnectTo(m_Player);
 
   for (unsigned int i = 0 ; i < m_Player->GetNumberOfIndexedOutputs(); i++ ) {
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     QString name = "Recorded Tool " + QString::number(i + 1);
     node->SetName(name.toStdString());
 
     //create small sphere and use it as surface
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkSphereSource *vtkData = vtkSphereSource::New();
     vtkData->SetRadius(5.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     vtkData->Delete();
     node->SetData(mySphere);
     m_VisFilter->SetRepresentationObject(i, mySphere);
 
     // Add Node to DataStorageand to local list of Nodes
     GetDataStorage()->Add(node);
     m_RenderingNodes.push_back(node);
   }
   m_VisFilter->Update();
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(GetDataStorage());
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationDataPlayerView::DestroyPipeline(){
   m_VisFilter = NULL;
   for (unsigned int i = 0; i < m_RenderingNodes.size(); i++){
     this->GetDataStorage()->Remove(m_RenderingNodes[i]);
   }
   m_RenderingNodes.clear();
 }
 
 void QmitkNavigationDataPlayerView::SetInteractionComponentsEnabledState(bool isActive){
   m_Controls->m_grpbxSettings->setEnabled(isActive);
   m_Controls->m_grpbxControls->setEnabled(isActive);
 }
\ No newline at end of file