diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.cpp
index efc2b808e5..cc867a6ec1 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.cpp
@@ -1,534 +1,532 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-02-10 18:08:54 +0100 (Di, 10 Feb 2009) $
 Version:   $Revision: 16228 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNavigationDataPlayer.h"
 
 //for the pause 
 #include <itksys/SystemTools.hxx>
 
 #include <mitkTimeStamp.h>
 #include <fstream>
 
-mitk::NavigationDataPlayer::NavigationDataPlayer() 
+mitk::NavigationDataPlayer::NavigationDataPlayer() : mitk::NavigationDataPlayerBase() 
 {
   m_NumberOfOutputs = 0;
   m_Pause = false;
   m_Playing = false;
   m_Stream = NULL;
   m_PlayerMode = NormalFile;
   m_FileName = "";
   m_FileVersion = 1;
   m_Playing = false;
   m_Pause = false;
   m_NumberOfOutputs = 0;
   m_StartPlayingTimeStamp = 0.0;
   m_PauseTimeStamp = 0.0;
   m_parentElement = NULL;
   m_currentNode = NULL;
   m_StreamEnd = false;
-  m_StreamValid = true;
-  m_ErrorMessage = "";
 
   //To get a start time
   mitk::TimeStamp::GetInstance()->Start(this);
 }
 
 
 mitk::NavigationDataPlayer::~NavigationDataPlayer()
 {
   StopPlaying();
   delete m_parentElement;
 }
 
 
 void mitk::NavigationDataPlayer::GenerateData()
 {
   //Only produce new output if the player is started
   if (!m_Playing)
   {
     //The output is not valid anymore 
     for (unsigned int index = 0; index < m_NumberOfOutputs; index++)
     {
       mitk::NavigationData* output = this->GetOutput(index);
       assert(output);
 
       mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
       mitk::NavigationData::PositionType position;
       mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
       position.Fill(0.0);
 
       nd->SetPosition(position);
       nd->SetOrientation(orientation);
       nd->SetDataValid(false);
 
       output->Graft(nd);
     }
     return;
   }
 
   //first of all get current time
   TimeStampType now = mitk::TimeStamp::GetInstance()->GetElapsed();
 
   //now we make a little time arithmetic 
   //to get the elapsed time since the start of the player
   TimeStampType timeSinceStart = now - m_StartPlayingTimeStamp;
  
   //init the vectors
   std::vector< NavigationData::Pointer > nextCandidates; 
   std::vector< NavigationData::Pointer > lastCandidates; 
   std::vector< NavigationData::TimeStampType > currentTimeOfData;
 
   for (unsigned int index=0; index < m_NumberOfOutputs; index++)
   {
   
     nextCandidates.push_back(m_NextToPlayNavigationData.at(index));
     lastCandidates.push_back(m_NextToPlayNavigationData.at(index));
     
     currentTimeOfData.push_back(timeSinceStart + m_StartTimeOfData.at(index));
   }
 
   if (m_NextToPlayNavigationData.size() != m_NumberOfOutputs)
   {
     std::cout << "Mismatch in data" << std::endl;
     return;
   }
 
   // Now we try to find next NavigationData in the stream:
   // This means we step through the stream of NavigationDatas until we find 
   // a NavigationData which has a current timestamp (currentTimeOfData) greater 
   // then the current playing time. Then we store the data in 
   // m_NextToPlayNavigationData and take the last data (lastCandidates) for the 
   // output of this filter.
   //
   // The loop will stop when a suitable NavigationData is found or we reach EOF.
   // The timestamps of each recorded NavigationData should be equal 
   // therefore we take always the time from the first.
 
 
   
   while( nextCandidates[0]->GetTimeStamp() < currentTimeOfData[0])
   {
     for (unsigned int index=0; index < m_NumberOfOutputs; index++)
     {
       lastCandidates[index] = nextCandidates.at(index);
 
       switch(m_FileVersion)
       {
       case 1: 
         nextCandidates[index] = ReadVersion1();
         break;
       default: //this case should not happen! therefore the return at this point
         return;
         break;
       }
 
       //check if the input stream delivered a correct NavigationData object
       for (unsigned int i = 0; i < m_NumberOfOutputs; i++)
       {
         if (nextCandidates.at(index).IsNull())
         {
           m_StreamEnd = true;
           StopPlaying();
           return; //the case if no NavigationData is found, e.g. EOF, bad stream
         }
       }
     }
 
   }
 
   //Now lastCandidates stores the new output and nextCandidates is stored to the m_NextToPlay vector
   for (unsigned int index = 0; index < m_NumberOfOutputs; index++)
   {
     mitk::NavigationData* output = this->GetOutput(index);
     assert(output);
 
     output->Graft(lastCandidates.at(index));
     m_NextToPlayNavigationData[index] = nextCandidates.at(index);
   }
 }
 
 
 void mitk::NavigationDataPlayer::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }
 
 
 void mitk::NavigationDataPlayer::InitPlayer()
 {
   if (m_Stream == NULL)
   { 
     StreamInvalid("Playing not possible. Wrong file name or path?");
     return;
   }
 
   if (!m_Stream->good())
   {
     StreamInvalid("Playing not possible. Stream is not good!");
     return;
   }
   
   m_FileVersion = GetFileVersion(m_Stream); //first get the file version
 
   //check if we have a valid version
   if (m_FileVersion < 1)
   {
     StreamInvalid("Playing not possible. Stream is not good!");
     return;
   }
 
   //now read the number of Tracked Tools
   if(m_NumberOfOutputs == 0){m_NumberOfOutputs = GetNumberOfNavigationDatas(m_Stream);}
 
   //with the information about the tracked tool number we can generate the output
   if (m_NumberOfOutputs > 0)
   {
     //Generate the output only if there are changes to the amount of outputs
     //This happens when the player is stopped and start again with different file
     if (this->GetNumberOfOutputs() != m_NumberOfOutputs) {SetNumberOfOutputs(m_NumberOfOutputs);}
     //initialize the player with first data
     GetFirstData(); 
     //set stream valid
     m_ErrorMessage = "";
     m_StreamValid = true;
   }
   else
   {
     StreamInvalid("The input stream seems to have NavigationData incompatible format");
     return;
   }
 
 }
 
 unsigned int mitk::NavigationDataPlayer::GetFileVersion(std::istream* stream)
 {
   if (stream==NULL)
   {
     std::cout << "No input stream set!" << std::endl;
     return 0;
   }
   if (!stream->good())
   {
     std::cout << "Stream not good!" << std::endl;
     return 0;
   }
   int version = 1;
   
   TiXmlDeclaration* dec = new TiXmlDeclaration();
   *stream >> *dec;
   if(strcmp(dec->Version(),"") == 0){
     std::cout << "The input stream seems to have XML incompatible format" << std::endl;
     return 0;
   }
   
   m_parentElement = new TiXmlElement("");
   *stream >> *m_parentElement; //2nd line this is the file version
 
   std::string tempValue = m_parentElement->Value();
   if(tempValue != "Version")
   {
       if(tempValue == "Data"){
           m_parentElement->QueryIntAttribute("version",&version);
       }
   }
   else
   {
     m_parentElement->QueryIntAttribute("Ver",&version);
   }
   
   if (version > 0)
     return version;
   else
     return 0;
 
 }
 
 
 unsigned int mitk::NavigationDataPlayer::GetNumberOfNavigationDatas(std::istream* stream)
 {
   if (stream == NULL)
   {
     std::cout << "No input stream set!" << std::endl;
     return 0;
   }
   if (!stream->good())
   {
     std::cout << "Stream not good!" << std::endl;
     return 0;
   }
 
   //If something has changed in a future version of the XML definition e.g. navigationcount or addional parameters 
   //catch this here with a select case block (see GenerateData() method)
 
   int numberOfTools = 0;
   
   std::string tempValue = m_parentElement->Value();
   if(tempValue == "Version"){
     *stream >> *m_parentElement;
   }
   m_parentElement->QueryIntAttribute("ToolCount",&numberOfTools);
 
   if (numberOfTools > 0)
     return numberOfTools;
   
   return 0;
 
 }
 
 
 mitk::NavigationData::Pointer mitk::NavigationDataPlayer::ReadVersion1()
 {
   if (m_Stream == NULL)
   {
     m_Playing = false;
     std::cout << "Playing not possible. Wrong file name or path? " << std::endl;
     return NULL;
   }
   if (!m_Stream->good())
   {
     m_Playing = false;
     std::cout << "Playing not possible. Stream is not good!" << std::endl;
     return NULL;
   }
 
   /*TiXmlElement* elem = new TiXmlElement("");
   m_currentNode = m_parentElement->IterateChildren(m_currentNode);
   
   if(m_currentNode)
   {
       elem = m_currentNode->ToElement();
   }*/
 
   TiXmlElement* elem;
   m_currentNode = m_parentElement->IterateChildren(m_currentNode);
 
   bool delElem;
 
   if(m_currentNode)
   {
     elem = m_currentNode->ToElement();
     delElem = false;
   }
   
   else
   {
     elem = new TiXmlElement("");
     delElem = true;
   }
     
 
   mitk::NavigationData::Pointer nd = this->ReadNavigationData(elem);
 
   if(delElem)
     delete elem;
 
   return nd;
 }
 
 
 void mitk::NavigationDataPlayer::StartPlaying()
 {
   if (m_Stream == NULL)
   {   
     m_Playing = false;
 
     //Perhaps the SetStream method was not called so we do this when a FileName is set with SetStream(PlayerMode)
     if (m_FileName != "")
     {
       //The PlayerMode is initialized with LastSetStream 
       //SetStream also calls InitPlayer()
       SetStream(m_PlayerMode);
     }
 
     //now check again
     if (m_Stream == NULL)
     {       
       StopPlaying();
       std::cout << "Playing not possible. Wrong file name or path? " << std::endl;
       return;
     }
   }
 
   if (!m_Playing && m_Stream->good())
   {
     m_Playing = true; //starts the player
     m_StartPlayingTimeStamp = mitk::TimeStamp::GetInstance()->GetElapsed();
   }
   else
   {
     std::cout << "Player already started or stream is not good" << std::endl;
     StopPlaying();
   }
 
 }
 
 
 void mitk::NavigationDataPlayer::StopPlaying()
 {
   //re init all data!! for playing again with different data
   //only PlayerMode and FileName are not changed
   m_Pause = false;
   m_Playing = false;
   m_Stream = NULL;
   m_FileVersion = 1;
   m_Playing = false;
   m_Pause = false;
   m_StartPlayingTimeStamp = 0.0;
   m_PauseTimeStamp = 0.0;
   m_NextToPlayNavigationData.clear();
   m_StartTimeOfData.clear();
 }
 
 
 void mitk::NavigationDataPlayer::GetFirstData()
 { 
 
   //Here we read the first lines of input (dependend on the number of inputs)
   for (unsigned int index=0; index < m_NumberOfOutputs; index++)
   {
     //Here we init the vector for later use
     m_NextToPlayNavigationData.push_back(NULL);
     m_StartTimeOfData.push_back(0.0);
     mitk::NavigationData::Pointer nd = this->GetOutput(index);
 
     switch(m_FileVersion)
     {
       case 1: 
         m_NextToPlayNavigationData[index] = ReadVersion1();
         //check if there is valid data in it
 
         if (m_NextToPlayNavigationData[index].IsNull())
         {
           m_StreamEnd = true;
 
           StopPlaying();
           std::cout << "XML File is corrupt or has no NavigationData" << std::endl;
           return;
         }
 
         //Have a look it the output was set already without this check the pipline will disconnect after a start/stop cycle
         if (nd.IsNull())
           this->SetNthOutput(index, m_NextToPlayNavigationData[index]);
 
         m_StartTimeOfData[index] = m_NextToPlayNavigationData[index]->GetTimeStamp();
         break;
       default: //this case should not happen! therefore the return at this point
         return;
         break;
     }
   }
 }
 
 
 void mitk::NavigationDataPlayer::Pause()
 {
   //player runs and pause was called -> pause the player
   if(m_Playing && !m_Pause)
   {
     m_Playing = false;
     m_Pause = true;
     m_PauseTimeStamp = mitk::TimeStamp::GetInstance()->GetElapsed();
   }
   else
   {
     std::cout << "Player is either not started or already is paused" << std::endl;
   }
 
 }
 
 
 void mitk::NavigationDataPlayer::Resume()
 {
   //player is in pause mode -> play at the last position
   if(!m_Playing && m_Pause)
   { 
     m_Playing = true;
     m_Pause = false;
     mitk::NavigationData::TimeStampType now = mitk::TimeStamp::GetInstance()->GetElapsed();
     
     // in this case m_StartPlayingTimeStamp is set to the total elapsed time with NO playback
     m_StartPlayingTimeStamp = now - (m_PauseTimeStamp - m_StartPlayingTimeStamp);    
   }
   else
   {
     std::cout << "Player is not paused!" << std::endl;
   }
 }
 
 
 void mitk::NavigationDataPlayer::SetStream( PlayerMode  /*mode*/ )
 {
   m_Stream = NULL;
 
   if (!itksys::SystemTools::FileExists(m_FileName.c_str()))
   {
     std::cout << "File dont exist!" << std::endl;
     return;
   }
   switch(m_PlayerMode)
   {
   case NormalFile:
 
     m_Stream = new std::ifstream(m_FileName.c_str());
     
     break;
   case ZipFile:
 
     m_Stream = NULL;
     std::cout << "Sorry no ZipFile support yet";
 
     break;
   default:
     m_Stream = NULL;
     break;
   }
 
   this->Modified();
   InitPlayer();
 }
 
 
 void mitk::NavigationDataPlayer::SetStream( std::istream* stream )
 {
   if (!stream->good())
   {
     m_StreamEnd = true;
     std::cout << "The stream is not good" << std::endl;
     return;
   }
 
   m_Stream = stream;
 
   this->Modified();
   InitPlayer();
 }
 
 const bool mitk::NavigationDataPlayer::IsAtEnd()
 {
   return this->m_StreamEnd;
 }
 
 void mitk::NavigationDataPlayer::StreamInvalid(std::string message)
 {
   m_StreamEnd = true;
   StopPlaying();
   m_ErrorMessage = message;
   m_StreamValid = false;
   MITK_ERROR << m_ErrorMessage;
   return;
 }
\ No newline at end of file
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.h b/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.h
index ff108d7810..f08777e97b 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.h
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataPlayer.h
@@ -1,213 +1,204 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-02-10 18:08:54 +0100 (Di, 10 Feb 2009) $
 Version:   $Revision: 16228 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef MITKNavigationDataPlayer_H_HEADER_INCLUDED_
 #define MITKNavigationDataPlayer_H_HEADER_INCLUDED_
 
 #include <mitkNavigationDataPlayerBase.h>
 #include <mitkNavigationDataSource.h>
 #include <mitkNavigationDataRecorder.h> //for the Recording Mode enum
 #include "mitkTrackingDevice.h"
 
 #include <itkMultiThreader.h>
 
 #include "tinyxml.h"
 #include <istream>
 
 
 namespace mitk {
   /**Documentation
   * \brief This class is used to play recorded (see mitkNavigationDataRecorder class) files.
   *
   * If you want to play a file you have to set an input stream. This can be an own one (use StartPlaying(std::istream*)) 
   * or a preset (use StartPlaying()). The presets are NormalFile and ZipFile and can be set with the method 
   * SetPlayerMode(PlayerMode). The presets need a FileName. Therefore the FileName must be set before the preset. 
   * For pausing the player call Pause(). A call of Resume() will continue the playing.
   *
   *
   * \ingroup IGT
   */
   class MitkIGT_EXPORT NavigationDataPlayer : public NavigationDataPlayerBase
   {
   public:
     mitkClassMacro(NavigationDataPlayer, NavigationDataPlayerBase);
     itkNewMacro(Self);
 
     /**
     * \brief sets the file name and path for the PlayerMode NormalFile and ZipFile
     */
     itkSetStringMacro(FileName);
 
     /**
     * \brief returns the file name and path for the PlayerMode NormalFile and ZipFile
     */
     itkGetStringMacro(FileName);
 
-    /** @return Returns an error message if there was one (e.g. if the stream is invalid). 
-     *          Returns an empty string if there was no error in the current stream.
-     */
-    itkGetStringMacro(ErrorMessage);
-
-    /** @return Retruns if the current stream is valid or not. */
-    itkGetMacro(StreamValid,bool);
 
     /**
     * \brief Used for pipeline update just to tell the pipeline that we always have to update
     */
     virtual void UpdateOutputInformation();
 
     /**
     * \brief This method starts the player. 
     *
     * Before the stream has to be set. Either with a PlayingMode (SetStream(PlayerMode)) and FileName. Or
     * with an own inputstream (SetStream(istream*)).
     */
     void StartPlaying();
 
     /**
     * \brief Stops the player and closes the stream. After a call of StopPlaying()
     * StartPlaying() must be called to get new output data
     *
     * \warning the output is generated in this method because we know first about the number of output after
     * reading the first lines of the XML file. Therefore you should assign your output after the call of this method
     */
     void StopPlaying();
 
     /**
     * \brief This method pauses the player. If you want to play again call Resume()
     * 
     *\warning This method is not tested yet. It is not save to use!
     */
     void Pause();
 
     /**
     * \brief This method resumes the player when it was paused. 
     * 
     *\warning This method is not tested yet. It is not save to use!
     */
     void Resume();
 
 
     /**
     * \brief This method checks if player arrived at end of file.
     * 
     *\warning This method is not tested yet. It is not save to use!
     */
     const bool IsAtEnd();
 
     /**
     * \brief The PlayerMode is used for generating a presetted output stream. You do not need to
     * set it if you want to use your own stream.
     *
     * There are:
     * NormalFile: ifstream
     * ZipFile: not implemented yet
     *
     *\warning The ZipFile Mode is not implemented yet
     */
     enum PlayerMode
     {
       NormalFile,
       ZipFile
     };
 
     /**
     * \brief sets the recording mode which causes different types of output streams
     * This method is overloaded with SetStream( ostream* )
     */
     void SetStream(PlayerMode mode);
 
     /**
     * \brief sets the recording mode which causes different types of output streams
     * This method is overloaded with SetStream( PlayerMode )
     */
     void SetStream(std::istream* stream);
 
   protected:
     NavigationDataPlayer();
     virtual ~NavigationDataPlayer();
 
     typedef mitk::NavigationData::TimeStampType TimeStampType;
 
     /**
     * \brief filter execute method 
     */
     virtual void GenerateData();
 
     /**
     * \brief Returns the file version out of the XML document. 
     */
     unsigned int GetFileVersion(std::istream* stream);
 
     /**
     * \brief Returns the number of tracked tools out of the XML document.
     */
     unsigned int GetNumberOfNavigationDatas(std::istream* stream);
 
     /**
     * \brief Gets the first data for initializing the player
     */
     void GetFirstData();
 
     /**
     * \brief This method reads one line of the XML document and returns the data as a NavigationData object
     * If there is a new file version another method must be added which reads this data.
     */
     mitk::NavigationData::Pointer ReadVersion1();
 
     /**
     * \brief This method initializes the player with first data  
     */
     void InitPlayer();
 
     std::istream* m_Stream; ///< stores a pointer to the input stream
 
     PlayerMode m_PlayerMode; ///< stores the mode for the presetted PlayerMode sieh enum PlayerMode
 
     std::string m_FileName; ///< stores the filename
 
     unsigned int m_FileVersion; ///< indicates which XML encoding is used
 
     bool m_Playing; ///< indicates whether the generateoutput method generates new output or not
 
     bool m_Pause; ///< indicates if the player is paused
 
     unsigned int m_NumberOfOutputs; ///< stores the number of outputs known from the XML document
 
     TimeStampType m_StartPlayingTimeStamp; ///< the starttime of the playing set in the method StartPlaying()
 
     TimeStampType m_PauseTimeStamp; ///< stores the beginning of a pause
 
     std::vector<NavigationData::Pointer> m_NextToPlayNavigationData; ///< stores the next possible candidate for playing
 
     std::vector<TimeStampType> m_StartTimeOfData; ///< stores the start time of the different tools
 
     TiXmlElement * m_parentElement;
 
     TiXmlNode * m_currentNode;
 
     bool m_StreamEnd; ///< stores if the input stream arrived at end
 
-    bool m_StreamValid;                       ///< stores if the input stream is valid or not
-    std::string m_ErrorMessage;               ///< stores the error message if the stream is invalid
     void StreamInvalid(std::string message);  ///< help method which sets the stream invalid and displays an error
    
   };
 } // namespace mitk
 
 #endif /* MITKNavigationDataPlayer_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
index 543812eea9..fe531f2fe6 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.cpp
@@ -1,114 +1,119 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-02-10 18:08:54 +0100 (Di, 10 Feb 2009) $
 Version:   $Revision: 16228 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNavigationDataPlayerBase.h"
 
 
-
+mitk::NavigationDataPlayerBase::NavigationDataPlayerBase()
+{
+ m_StreamValid = true;
+ m_ErrorMessage = "";
+}
 
 mitk::NavigationDataPlayerBase::~NavigationDataPlayerBase()
 {
 }
 
+ 
 
 
 
 void mitk::NavigationDataPlayerBase::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }
 
 
 
 mitk::NavigationData::Pointer mitk::NavigationDataPlayerBase::ReadNavigationData(TiXmlElement* elem)
 {
   mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
 
   mitk::NavigationData::PositionType position;
   mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
   mitk::NavigationData::TimeStampType timestamp = -1; 
   mitk::NavigationData::CovarianceMatrixType matrix;
 
   bool hasPosition = true;    
   bool hasOrientation = true; 
   bool dataValid = false;
 
   position.Fill(0.0);
   matrix.SetIdentity();
 
 
   elem->QueryDoubleAttribute("Time",&timestamp);
   if (timestamp == -1)
   {
     return NULL;  //the calling method should check the return value if it is valid/not NULL
   }
 
   elem->QueryFloatAttribute("X", &position[0]);
   elem->QueryFloatAttribute("Y", &position[1]);
   elem->QueryFloatAttribute("Z", &position[2]);
 
   elem->QueryFloatAttribute("QX", &orientation[0]);
   elem->QueryFloatAttribute("QY", &orientation[1]);
   elem->QueryFloatAttribute("QZ", &orientation[2]);
   elem->QueryFloatAttribute("QR", &orientation[3]);
 
   elem->QueryFloatAttribute("C00", &matrix[0][0]);
   elem->QueryFloatAttribute("C01", &matrix[0][1]);
   elem->QueryFloatAttribute("C02", &matrix[0][2]);
   elem->QueryFloatAttribute("C03", &matrix[0][3]);
   elem->QueryFloatAttribute("C04", &matrix[0][4]);
   elem->QueryFloatAttribute("C05", &matrix[0][5]);
   elem->QueryFloatAttribute("C10", &matrix[1][0]);
   elem->QueryFloatAttribute("C11", &matrix[1][1]);
   elem->QueryFloatAttribute("C12", &matrix[1][2]);
   elem->QueryFloatAttribute("C13", &matrix[1][3]);
   elem->QueryFloatAttribute("C14", &matrix[1][4]);
   elem->QueryFloatAttribute("C15", &matrix[1][5]);
 
   int tmpval = 0;
   elem->QueryIntAttribute("Valid", &tmpval);
   if (tmpval == 0)
     dataValid = false;
   else
     dataValid = true;
 
   tmpval = 0;
   elem->QueryIntAttribute("hO", &tmpval);
   if (tmpval == 0)
     hasOrientation = false;
   else
     hasOrientation = true;
 
   tmpval = 0;
   elem->QueryIntAttribute("hP", &tmpval);
   if (tmpval == 0)
     hasPosition = false;
   else
     hasPosition = true;
 
   nd->SetTimeStamp(timestamp);
   nd->SetPosition(position);
   nd->SetOrientation(orientation);
   nd->SetCovErrorMatrix(matrix);
   nd->SetDataValid(dataValid);
   nd->SetHasOrientation(hasOrientation);
   nd->SetHasPosition(hasPosition);
 
 
   return nd;
 }
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.h b/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.h
index d18055e449..2a4fae5d53 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.h
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataPlayerBase.h
@@ -1,66 +1,78 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-02-10 18:08:54 +0100 (Di, 10 Feb 2009) $
 Version:   $Revision: 16228 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef MITKNavigationDataPlayerBase_H_HEADER_INCLUDED_
 #define MITKNavigationDataPlayerBase_H_HEADER_INCLUDED_
 
 #include <mitkNavigationDataSource.h>
 #include "tinyxml.h"
 
 
 namespace mitk{
 
   /**Documentation
   * \brief This class is a slightly changed reimplementation of the
   * NavigationDataPlayer which does not care about timestamps and just
   * outputs the navigationdatas in their sequential order
   *
   * \ingroup IGT
   */
   class MitkIGT_EXPORT NavigationDataPlayerBase
     : public NavigationDataSource
   {
   public:
     mitkClassMacro(NavigationDataPlayerBase, NavigationDataSource);
 
     /**
     * \brief Used for pipeline update just to tell the pipeline that we always have to update
     */
     virtual void UpdateOutputInformation();
 
+    /** @return Returns an error message if there was one (e.g. if the stream is invalid). 
+     *          Returns an empty string if there was no error in the current stream.
+     */
+    itkGetStringMacro(ErrorMessage);
+
+    /** @return Retruns if the current stream is valid or not. */
+    itkGetMacro(StreamValid,bool);
+
    /**
     * \brief This method checks if player arrived at end of file.
     * 
     *\warning This method is not tested yet. It is not save to use!
     */
     const bool IsAtEnd();
 
   protected:
+    NavigationDataPlayerBase();
     virtual ~NavigationDataPlayerBase();
     virtual void GenerateData() = 0;
 
 
     /**
     * \brief Creates NavigationData from XML element and returns it 
     */
     mitk::NavigationData::Pointer ReadNavigationData(TiXmlElement* elem);
+
+    bool m_StreamValid;                       ///< stores if the input stream is valid or not
+    std::string m_ErrorMessage;               ///< stores the error message if the stream is invalid
   
   };
 } // namespace mitk
 
 #endif /* MITKNavigationDataSequentialPlayer_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
index eb2b131467..81241543fa 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
@@ -1,190 +1,198 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-02-10 18:08:54 +0100 (Di, 10 Feb 2009) $
 Version:   $Revision: 16228 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNavigationDataSequentialPlayer.h"
 
 //for the pause
 #include <itksys/SystemTools.hxx>
 
 #include <mitkTimeStamp.h>
 #include <fstream>
 #include <sstream>
 
-mitk::NavigationDataSequentialPlayer::NavigationDataSequentialPlayer()
-  : m_Doc(new TiXmlDocument)
+mitk::NavigationDataSequentialPlayer::NavigationDataSequentialPlayer() 
+  : mitk::NavigationDataPlayerBase()
+  , m_Doc(new TiXmlDocument)
   , m_DataElem(0)
   , m_CurrentElem(0)
   , m_Repeat(false)
   , m_NumberOfSnapshots(0)
   , m_LastGoTo(0)
 {
 }
 
 
 mitk::NavigationDataSequentialPlayer::~NavigationDataSequentialPlayer()
 {
   delete m_Doc;
 }
 
 void mitk::NavigationDataSequentialPlayer::ReinitXML()
 {
   m_DataElem = m_Doc->FirstChildElement("Data");
   int toolcount;
   if(!m_DataElem)
     MITK_WARN << "Data element not found";
   else
   {
     m_DataElem->QueryIntAttribute("ToolCount", &toolcount);
     this->SetNumberOfOutputs(toolcount);
 
     mitk::NavigationData::Pointer emptyNd = mitk::NavigationData::New();
     mitk::NavigationData::PositionType position;
     mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
     position.Fill(0.0);
 
     emptyNd->SetPosition(position);
     emptyNd->SetOrientation(orientation);
     emptyNd->SetDataValid(false);
 
     mitk::NavigationData::Pointer tmp;
     for (unsigned int index = 0; index < this->GetNumberOfOutputs(); index++)
     {
       tmp = mitk::NavigationData::New();
       tmp->Graft(emptyNd);
       this->SetNthOutput(index, tmp);
     }
 
     // find out _NumberOfSnapshots
     m_NumberOfSnapshots = 0;
     TiXmlElement* nextND = m_DataElem->FirstChildElement("ND");
     while(nextND)
     {
       ++m_NumberOfSnapshots;
       nextND = nextND->NextSiblingElement("ND");
     }
     // e.g. 12 nd found and 2 tools used => number of snapshots is 12:2=6
     m_NumberOfSnapshots = m_NumberOfSnapshots/toolcount;
 
   }
 }
 
 void mitk::NavigationDataSequentialPlayer::GoToSnapshot(int i)
 {
   assert(m_DataElem);
 
   int numOfUpdateCalls = 0;
 
   // i.e. number of snapshots 10
   // goto(7), m_LastGoTo=3 => numOfUpdateCalls = 4
   if(m_LastGoTo <= i)
     numOfUpdateCalls = i - m_LastGoTo;
   // goto(4), m_LastGoTo=7 => numOfUpdateCalls = 7
   else
   {
     if(!m_Repeat)
     {
       MITK_WARN << "cannot go back to snapshot " << i << " because the "
           << this->GetNameOfClass() << " is configured to not repeat the"
           << " navigation data";
 
     }
     else
     {
       numOfUpdateCalls = (m_NumberOfSnapshots - m_LastGoTo) + i;
     }
   }
 
   for(int j=0; j<numOfUpdateCalls; ++j)
     this->Update();
 
   m_LastGoTo = i;
 }
 
 void mitk::NavigationDataSequentialPlayer::
     SetFileName(const std::string& _FileName)
 {
   m_FileName = _FileName;
 
   if(!m_Doc->LoadFile(m_FileName))
   {
     this->SetNumberOfOutputs(0);
     std::ostringstream s;
     s << "File " << _FileName << " could not be loaded";
     throw std::invalid_argument(s.str());
   }
   else
     this->ReinitXML();
 
   this->Modified();
 }
 
 void mitk::NavigationDataSequentialPlayer::
     SetXMLString(const std::string& _XMLString)
 {
   m_XMLString = _XMLString;
 
   m_Doc->Parse( m_XMLString.c_str() );
   this->ReinitXML();
 
   this->Modified();
 }
 
 void mitk::NavigationDataSequentialPlayer::GenerateData()
 {
   assert(m_DataElem);
 
   // very important: go through the tools (there could be more then one)
   mitk::NavigationData::Pointer tmp;
   for (unsigned int index = 0; index < this->GetNumberOfOutputs(); index++)
   {
     // go to the first element
     if(!m_CurrentElem)
       m_CurrentElem = m_DataElem->FirstChildElement("ND");
     // go to the next element
     else
       m_CurrentElem = m_CurrentElem->NextSiblingElement();
 
     // if repeat is on: go back to the first element (prior calls delivered NULL
     // elem)
     if(!m_CurrentElem && m_Repeat)
       m_CurrentElem = m_DataElem->FirstChildElement("ND");
 
     mitk::NavigationData* output = this->GetOutput(index);
     tmp = this->ReadVersion1();
     if(tmp.IsNotNull())
+      {
       output->Graft(tmp);
+      m_StreamValid = true;
+      }
     else // no valid output
+      {
       output->SetDataValid(false);
+      m_StreamValid = false;
+      m_ErrorMessage = "Error: Cannot parse input file.";
+      }
   }
 }
 
 mitk::NavigationData::Pointer mitk::NavigationDataSequentialPlayer::ReadVersion1()
 {
 
   TiXmlElement* elem = m_CurrentElem;
 
   if(!elem)
     return NULL;
 
   return this->ReadNavigationData(elem);
 }
 
 void mitk::NavigationDataSequentialPlayer::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }