diff --git a/Core/Code/DataManagement/mitkDataNode.cpp b/Core/Code/DataManagement/mitkDataNode.cpp
index 7c61d404b1..57e790dfe6 100644
--- a/Core/Code/DataManagement/mitkDataNode.cpp
+++ b/Core/Code/DataManagement/mitkDataNode.cpp
@@ -1,564 +1,568 @@
 /*===================================================================
 
 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 "mitkDataNode.h"
 #include "mitkCoreObjectFactory.h"
 #include <vtkTransform.h>
 
 #include "mitkProperties.h"
 #include "mitkStringProperty.h"
 #include "mitkGroupTagProperty.h"
 #include "mitkSmartPointerProperty.h"
 //#include "mitkMaterialProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkGeometry3D.h"
 #include "mitkRenderingManager.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkEventMapper.h"
 #include "mitkGenericProperty.h"
 
 #include "mitkCoreObjectFactory.h"
 
 
 
 mitk::Mapper* mitk::DataNode::GetMapper(MapperSlotId id) const
 {
   if( (id >= m_Mappers.size()) || (m_Mappers[id].IsNull()) )
   {
     if(id >= m_Mappers.capacity())
     {
 //      int i, size=id-m_Mappers.capacity()+10;
       m_Mappers.resize(id+10);
     }
     m_Mappers[id] = CoreObjectFactory::GetInstance()->CreateMapper(const_cast<DataNode*>(this),id);
   }
   return m_Mappers[id];
 }
 
 mitk::BaseData* mitk::DataNode::GetData() const
 {
   return m_Data;
 }
 
 mitk::Interactor* mitk::DataNode::GetInteractor() const
 {
   return m_Interactor;
 }
 
 void mitk::DataNode::SetData(mitk::BaseData* baseData)
 {
   if(m_Data!=baseData)
   {
     m_Data=baseData;
 
     m_Mappers.clear();
     m_Mappers.resize(10);
 
     mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(this);
 
     m_DataReferenceChangedTime.Modified();
     Modified();
 
     //inform the interactor about the change
     if (m_Interactor.IsNotNull())
       m_Interactor->DataChanged();
   }
 }
 
 void mitk::DataNode::SetInteractor(mitk::Interactor* interactor)
 {
   m_Interactor = interactor;
   if(m_Interactor.IsNotNull())
     m_Interactor->SetDataNode(this);
 }
 
 mitk::DataNode::DataNode() : m_Data(NULL), m_PropertyListModifiedObserverTag(0)
 {
   m_Mappers.resize(10);
 
   m_PropertyList = PropertyList::New();
 
   // subscribe for modified event
   itk::MemberCommand<mitk::DataNode>::Pointer _PropertyListModifiedCommand =
     itk::MemberCommand<mitk::DataNode>::New();
   _PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::DataNode::PropertyListModified);
   m_PropertyListModifiedObserverTag = m_PropertyList->AddObserver(itk::ModifiedEvent(), _PropertyListModifiedCommand);
 }
 
 
 mitk::DataNode::~DataNode()
 {
   if(m_PropertyList.IsNotNull())
     // remove modified event listener
     m_PropertyList->RemoveObserver(m_PropertyListModifiedObserverTag);
 
   Interactor* interactor = this->GetInteractor();
 
   if ( interactor )
   {
     mitk::GlobalInteraction::GetInstance()->RemoveInteractor( interactor );
   }
   m_Mappers.clear();
   m_Data = NULL;
 }
 
 mitk::DataNode& mitk::DataNode::operator=(const DataNode& right)
 {
   mitk::DataNode* node=mitk::DataNode::New();
   node->SetData(right.GetData());
   return *node;
 }
 
 mitk::DataNode& mitk::DataNode::operator=(mitk::BaseData* right)
 {
   mitk::DataNode* node=mitk::DataNode::New();
   node->SetData(right);
   return *node;
 }
 
 #if (_MSC_VER > 1200) || !defined(_MSC_VER)
 MBI_STD::istream& mitk::operator>>( MBI_STD::istream& i, mitk::DataNode::Pointer& dtn )
 #endif
 #if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
 MBI_STD::istream& operator>>( MBI_STD::istream& i, mitk::DataNode::Pointer& dtn )
 #endif
 {
   dtn = mitk::DataNode::New();
   //i >> av.get();
   return i;
 }
 
 #if (_MSC_VER > 1200) || !defined(_MSC_VER)
 MBI_STD::ostream& mitk::operator<<( MBI_STD::ostream& o, mitk::DataNode::Pointer& dtn)
 #endif
 #if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
 MBI_STD::ostream& operator<<( MBI_STD::ostream& o, mitk::DataNode::Pointer& dtn)
 #endif
 {
   if(dtn->GetData()!=NULL)
     o<<dtn->GetData()->GetNameOfClass();
   else
     o<<"empty data";
   return o;
 }
 
 void mitk::DataNode::SetMapper(MapperSlotId id, mitk::Mapper* mapper)
 {
   m_Mappers[id] = mapper;
 
   if (mapper!=NULL)
     mapper->SetDataNode(this);
 }
 
 void mitk::DataNode::UpdateOutputInformation()
 {
   if (this->GetSource())
   {
     this->GetSource()->UpdateOutputInformation();
   }
 }
 
 void mitk::DataNode::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 bool mitk::DataNode::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 
 bool mitk::DataNode::VerifyRequestedRegion()
 {
     return true;
 }
 
 void mitk::DataNode::SetRequestedRegion( const itk::DataObject * /*data*/)
 {
 }
 
 void mitk::DataNode::CopyInformation(const itk::DataObject * /*data*/)
 {
 }
 mitk::PropertyList* mitk::DataNode::GetPropertyList(const mitk::BaseRenderer* renderer) const
 {
   if(renderer==NULL)
     return m_PropertyList;
 
   mitk::PropertyList::Pointer & propertyList = m_MapOfPropertyLists[renderer];
 
   if(propertyList.IsNull())
     propertyList = mitk::PropertyList::New();
 
   assert(m_MapOfPropertyLists[renderer].IsNotNull());
 
   return propertyList;
 }
 
 void mitk::DataNode::ConcatenatePropertyList(PropertyList *pList, bool replace)
 {
   m_PropertyList->ConcatenatePropertyList(pList, replace);
 }
 
 mitk::BaseProperty* mitk::DataNode::GetProperty(const char *propertyKey, const mitk::BaseRenderer* renderer) const
 {
   if(propertyKey==NULL)
     return NULL;
 
   //renderer specified?
   if (renderer)
   {
     std::map<const mitk::BaseRenderer*,mitk::PropertyList::Pointer>::const_iterator it;
     //check for the renderer specific property
     it=m_MapOfPropertyLists.find(renderer);
     if(it!=m_MapOfPropertyLists.end()) //found
     {
       mitk::BaseProperty::Pointer property;
       property=it->second->GetProperty(propertyKey);
       if(property.IsNotNull())//found an enabled property in the render specific list
         return property;
       else //found a renderer specific list, but not the desired property
         return m_PropertyList->GetProperty(propertyKey); //return renderer unspecific property
     }
     else //didn't find the property list of the given renderer
     {
       //return the renderer unspecific property if there is one
       return m_PropertyList->GetProperty(propertyKey);
     }
   }
   else //no specific renderer given; use the renderer independent one
   {
     mitk::BaseProperty::Pointer property;
     property=m_PropertyList->GetProperty(propertyKey);
     if(property.IsNotNull())
       return property;
   }
 
   //only to satisfy compiler!
   return NULL;
 }
 
 mitk::DataNode::GroupTagList mitk::DataNode::GetGroupTags() const
 {
   GroupTagList groups;
   const PropertyList::PropertyMap* propertyMap = m_PropertyList->GetMap();
 
   for ( PropertyList::PropertyMap::const_iterator groupIter = propertyMap->begin(); // m_PropertyList is created in the constructor, so we don't check it here
         groupIter != propertyMap->end();
         ++groupIter )
   {
     const BaseProperty* bp = groupIter->second;
     if ( dynamic_cast<const GroupTagProperty*>(bp) )
     {
       groups.insert( groupIter->first );
     }
   }
 
   return groups;
 }
 
 bool mitk::DataNode::GetBoolProperty(const char* propertyKey, bool& boolValue, mitk::BaseRenderer* renderer) const
 {
   mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty*>(GetProperty(propertyKey, renderer));
   if(boolprop.IsNull())
     return false;
 
   boolValue = boolprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetIntProperty(const char* propertyKey, int &intValue, mitk::BaseRenderer* renderer) const
 {
   mitk::IntProperty::Pointer intprop = dynamic_cast<mitk::IntProperty*>(GetProperty(propertyKey, renderer));
   if(intprop.IsNull())
     return false;
 
   intValue = intprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetFloatProperty(const char* propertyKey, float &floatValue, mitk::BaseRenderer* renderer) const
 {
   mitk::FloatProperty::Pointer floatprop = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey, renderer));
   if(floatprop.IsNull())
     return false;
 
   floatValue = floatprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetStringProperty(const char* propertyKey, std::string& string, mitk::BaseRenderer* renderer) const
 {
   mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty*>(GetProperty(propertyKey, renderer));
   if(stringProp.IsNull())
   {
     return false;
   }
   else
   {
     //memcpy((void*)string, stringProp->GetValue(), strlen(stringProp->GetValue()) + 1 ); // looks dangerous
     string = stringProp->GetValue();
     return true;
   }
 }
 
 bool mitk::DataNode::GetColor(float rgb[3], mitk::BaseRenderer* renderer, const char* propertyKey) const
 {
   mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetProperty(propertyKey, renderer));
   if(colorprop.IsNull())
     return false;
 
   memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
   return true;
 }
 
 bool mitk::DataNode::GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* propertyKey) const
 {
   mitk::FloatProperty::Pointer opacityprop = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey, renderer));
   if(opacityprop.IsNull())
     return false;
 
   opacity=opacityprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetLevelWindow(mitk::LevelWindow &levelWindow, mitk::BaseRenderer* renderer, const char* propertyKey) const
 {
   mitk::LevelWindowProperty::Pointer levWinProp = dynamic_cast<mitk::LevelWindowProperty*>(GetProperty(propertyKey, renderer));
   if(levWinProp.IsNull())
     return false;
 
   levelWindow=levWinProp->GetLevelWindow();
   return true;
 }
 
 void mitk::DataNode::SetColor(const mitk::Color &color, mitk::BaseRenderer* renderer, const char* propertyKey)
 {
   mitk::ColorProperty::Pointer prop;
   prop = mitk::ColorProperty::New(color);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetColor(float red, float green, float blue, mitk::BaseRenderer* renderer, const char* propertyKey)
 {
   float color[3];
   color[0]=red;
   color[1]=green;
   color[2]=blue;
   SetColor(color, renderer, propertyKey);
 }
 
 void mitk::DataNode::SetColor(const float rgb[3], mitk::BaseRenderer* renderer, const char* propertyKey)
 {
   mitk::ColorProperty::Pointer prop;
   prop = mitk::ColorProperty::New(rgb);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetVisibility(bool visible, mitk::BaseRenderer* renderer, const char* propertyKey)
 {
   mitk::BoolProperty::Pointer prop;
   prop = mitk::BoolProperty::New(visible);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetOpacity(float opacity, mitk::BaseRenderer* renderer, const char* propertyKey)
 {
   mitk::FloatProperty::Pointer prop;
   prop = mitk::FloatProperty::New(opacity);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetLevelWindow(mitk::LevelWindow levelWindow, mitk::BaseRenderer* renderer, const char* propertyKey)
 {
   mitk::LevelWindowProperty::Pointer prop;
   prop = mitk::LevelWindowProperty::New(levelWindow);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetIntProperty(const char* propertyKey, int intValue, mitk::BaseRenderer* renderer)
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::IntProperty::New(intValue));
 }
 void mitk::DataNode::SetBoolProperty( const char* propertyKey, bool boolValue, mitk::BaseRenderer* renderer/*=NULL*/ )
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
 }
 
 void mitk::DataNode::SetFloatProperty( const char* propertyKey, float floatValue, mitk::BaseRenderer* renderer/*=NULL*/ )
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
 }
 
 void mitk::DataNode::SetStringProperty( const char* propertyKey, const char* stringValue, mitk::BaseRenderer* renderer/*=NULL*/ )
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
 }
 
 void mitk::DataNode::SetProperty(const char *propertyKey,
                                      BaseProperty* propertyValue,
                                      const mitk::BaseRenderer* renderer)
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, propertyValue);
 }
 
 void mitk::DataNode::ReplaceProperty(const char *propertyKey,
                                          BaseProperty* propertyValue,
                                          const mitk::BaseRenderer* renderer)
 {
   GetPropertyList(renderer)->ReplaceProperty(propertyKey, propertyValue);
 }
 
 void mitk::DataNode::AddProperty(const char *propertyKey,
                                      BaseProperty* propertyValue,
                                      const mitk::BaseRenderer* renderer,
                                      bool overwrite)
 {
   if((overwrite) || (GetProperty(propertyKey, renderer) == NULL))
   {
     SetProperty(propertyKey, propertyValue, renderer);
   }
 }
 
 
 vtkLinearTransform* mitk::DataNode::GetVtkTransform(int t) const
 {
   assert(m_Data.IsNotNull());
 
   mitk::Geometry3D* geometry = m_Data->GetGeometry(t);
 
   if(geometry == NULL)
     return NULL;
 
   return geometry->GetVtkTransform();
 }
 
 unsigned long mitk::DataNode::GetMTime() const
 {
   unsigned long time = Superclass::GetMTime();
   if(m_Data.IsNotNull())
   {
     if((time < m_Data->GetMTime()) ||
        ((m_Data->GetSource().IsNotNull()) && (time < m_Data->GetSource()->GetMTime()))
     )
     {
       Modified();
       return Superclass::GetMTime();
     }
   }
   return time;
 }
 
 void mitk::DataNode::SetSelected(bool selected, mitk::BaseRenderer* renderer)
 {
   mitk::BoolProperty::Pointer selectedProperty = dynamic_cast<mitk::BoolProperty*>(GetProperty("selected"));
 
   if ( selectedProperty.IsNull() )
   {
     selectedProperty = mitk::BoolProperty::New();
     selectedProperty->SetValue(false);
     SetProperty("selected", selectedProperty, renderer);
   }
 
   if( selectedProperty->GetValue() != selected )
   {
     selectedProperty->SetValue(selected);
     itk::ModifiedEvent event;
     InvokeEvent( event );
   }
 }
 
 /*
 class SelectedEvent : public itk::ModifiedEvent
 {
 public:
   typedef SelectedEvent Self;
   typedef itk::ModifiedEvent Superclass;
 
   SelectedEvent(DataNode* dataNode)
     { m_DataNode = dataNode; };
   DataNode* GetDataNode()
     { return m_DataNode; };
   virtual const char * GetEventName() const
     { return "SelectedEvent"; }
   virtual bool CheckEvent(const ::itk::EventObject* e) const
     { return dynamic_cast<const Self*>(e); }
   virtual ::itk::EventObject* MakeObject() const
     { return new Self(m_DataNode); }
 private:
   DataNode* m_DataNode;
   SelectedEvent(const Self& event)
     { m_DataNode = event.m_DataNode; };
   void operator=(const Self& event)
   { m_DataNode = event.m_DataNode; }
 };
 */
 
 bool mitk::DataNode::IsSelected(mitk::BaseRenderer* renderer)
 {
   bool selected;
 
   if ( !GetBoolProperty("selected", selected, renderer) )
     return false;
 
   return selected;
 }
 
 void mitk::DataNode::SetInteractorEnabled( const bool& enabled )
 {
   if ( m_Interactor.IsNull() )
   {
     itkWarningMacro("Interactor is NULL. Couldn't enable or disable interaction.");
     return;
   }
   if ( enabled )
     mitk::GlobalInteraction::GetInstance()->AddInteractor( m_Interactor.GetPointer() );
   else
     mitk::GlobalInteraction::GetInstance()->RemoveInteractor( m_Interactor.GetPointer() );
 }
 
 void mitk::DataNode::EnableInteractor()
 {
   SetInteractorEnabled( true );
 }
 
 void mitk::DataNode::DisableInteractor()
 {
   SetInteractorEnabled( false );
 }
 
 bool mitk::DataNode::IsInteractorEnabled() const
 {
   return mitk::GlobalInteraction::GetInstance()->InteractorRegistered( m_Interactor.GetPointer() );
 }
 
 void mitk::DataNode::SetDataInteractor(const DataInteractor::Pointer& interactor)
 {
   m_DataInteractor = interactor;
   Modified();
+
+  // the interactor has changed, so we have ti invoke an InteractorChangedEvent
+  const mitk::DataNode::InteractorChangedEvent changedEvent;
+  InvokeEvent( changedEvent );
 }
 
 mitk::DataInteractor::Pointer mitk::DataNode::GetDataInteractor() const
 {
   return m_DataInteractor;
 }
 
 void mitk::DataNode::PropertyListModified( const itk::Object* /*caller*/, const itk::EventObject& )
 {
   Modified();
 }
 
diff --git a/Core/Code/DataManagement/mitkDataNode.h b/Core/Code/DataManagement/mitkDataNode.h
index 6f39881565..51eb210449 100644
--- a/Core/Code/DataManagement/mitkDataNode.h
+++ b/Core/Code/DataManagement/mitkDataNode.h
@@ -1,533 +1,539 @@
 /*===================================================================
 
 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 DATATREENODE_H_HEADER_INCLUDED_C1E14338
 #define DATATREENODE_H_HEADER_INCLUDED_C1E14338
 
 #include "mitkImageSource.h"
 #include "mitkBaseData.h"
 //#include "mitkMapper.h"
 #include "mitkInteractor.h"
 #include "mitkDataInteractor.h"
 
 #ifdef MBI_NO_STD_NAMESPACE
 #define MBI_STD
 #include <iostream.h>
 #include <fstream.h>
 #else
 #define MBI_STD std
 #include <iostream>
 #include <fstream>
 #endif
 
 #include "mitkStringProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkPropertyList.h"
 //#include "mitkMapper.h"
 
 #include <map>
 #include <set>
 #include "mitkLevelWindow.h"
 
 class vtkLinearTransform;
 
 namespace mitk {
 
 class BaseRenderer;
 class Mapper;
 
 
 //##Documentation
 //## @brief Class for nodes of the DataTree
 //##
 //## Contains the data (instance of BaseData), a list of mappers, which can
 //## draw the data, a transform (vtkTransform) and a list of properties
 //## (PropertyList).
 //## @ingroup DataManagement
 //##
 //## @todo clean up all the GetProperty methods. There are too many different flavours... Can most probably be reduced to <tt>bool GetProperty<type>(type&)</tt>
 //##
 //## @warning Change in semantics of SetProperty() since Aug 25th 2006. Check your usage of this method if you do
 //##          more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
 class MITK_CORE_EXPORT DataNode : public itk::DataObject
 {
 public:
 
   typedef mitk::Geometry3D::Pointer Geometry3DPointer;
   typedef std::vector< itk::SmartPointer< Mapper > > MapperVector;
   typedef std::map<const mitk::BaseRenderer*,mitk::PropertyList::Pointer> MapOfPropertyLists;
   typedef std::set<std::string> GroupTagList;
 
+  /**
+  * \brief Definition of an itk::Event that is invoked when
+  * a DataInteractor is set on this DataNode.
+  */
+  itkEventMacro(InteractorChangedEvent, itk::AnyEvent);
+
   mitkClassMacro(DataNode, itk::DataObject);
 
   itkNewMacro(Self);
 
   mitk::Mapper* GetMapper(MapperSlotId id) const;
   //##Documentation
   //## @brief Get the data object (instance of BaseData, e.g., an Image)
   //## managed by this DataNode
   BaseData* GetData() const;
   //##Documentation
   //## @brief Get the transformation applied prior to displaying the data as
   //## a vtkTransform
   //## \deprecated use GetData()->GetGeometry()->GetVtkTransform() instead
   vtkLinearTransform* GetVtkTransform(int t=0) const;
   //##Documentation
   //## @brief Get the Interactor.
   //## @deprecatedSince{2013_03} Use DataInteractor and GetDataInteractor instead.
   Interactor* GetInteractor() const;
   //##Documentation
   //## @brief Set the data object (instance of BaseData, e.g., an Image)
   //## managed by this DataNode
   //## @warning the actor-mode of the vtkInteractor does not work any more, if the transform of the
   //## data-tree-node is connected to the transform of the basedata via vtkTransform->SetInput.
   virtual void SetData(mitk::BaseData* baseData);
   //##Documentation
   //## @brief Set the Interactor.
   //## @deprecatedSince{2013_03} Use DataInteractor and SetDataInteractor instead.
   virtual void SetInteractor(Interactor* interactor);
 
   virtual void SetDataInteractor(const DataInteractor::Pointer& interactor);
   virtual DataInteractor::Pointer GetDataInteractor() const;
 
   mitk::DataNode& operator=(const DataNode& right);
 
   mitk::DataNode& operator=(BaseData* right);
   virtual void SetMapper(MapperSlotId id, mitk::Mapper* mapper);
   virtual void UpdateOutputInformation();
 
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   virtual bool VerifyRequestedRegion();
 
   virtual void SetRequestedRegion( const itk::DataObject *data);
 
   virtual void CopyInformation(const itk::DataObject *data);
 
   //##Documentation
   //## @brief Set the property (instance of BaseProperty) with key @a propertyKey in the PropertyList
   //## of the @a renderer (if NULL, use BaseRenderer-independent PropertyList). This is set-by-value.
   //##
   //## @warning Change in semantics since Aug 25th 2006. Check your usage of this method if you do
   //##          more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
   //##
   //## @sa GetProperty
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   void SetProperty(const char *propertyKey, BaseProperty* property, const mitk::BaseRenderer* renderer = NULL);
 
   //##Documentation
   //## @brief Replace the property (instance of BaseProperty) with key @a propertyKey in the PropertyList
   //## of the @a renderer (if NULL, use BaseRenderer-independent PropertyList). This is set-by-reference.
   //##
   //## If @a renderer is @a NULL the property is set in the BaseRenderer-independent
   //## PropertyList of this DataNode.
   //## @sa GetProperty
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   void ReplaceProperty(const char *propertyKey, BaseProperty* property, const mitk::BaseRenderer* renderer = NULL);
 
   //##Documentation
   //## @brief Add the property (instance of BaseProperty) if it does
   //## not exist (or always if \a overwrite is \a true)
   //## with key @a propertyKey in the PropertyList
   //## of the @a renderer (if NULL, use BaseRenderer-independent
   //## PropertyList). This is set-by-value.
   //##
   //## For \a overwrite == \a false the property is \em not changed
   //## if it already exists. For \a overwrite == \a true the method
   //## is identical to SetProperty.
   //##
   //## @sa SetProperty
   //## @sa GetProperty
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   void AddProperty(const char *propertyKey, BaseProperty* property, const mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
   //##Documentation
   //## @brief Get the PropertyList of the @a renderer. If @a renderer is @a
   //## NULL, the BaseRenderer-independent PropertyList of this DataNode
   //## is returned.
   //## @sa GetProperty
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   mitk::PropertyList* GetPropertyList(const mitk::BaseRenderer* renderer = NULL) const;
 
   //##Documentation
   //## @brief Add values from another PropertyList.
   //##
   //## Overwrites values in m_PropertyList only when possible (i.e. when types are compatible).
   //## If you want to allow for object type changes (replacing a "visible":BoolProperty with "visible":IntProperty,
   //## set the @param replace.
   //##
   //## @param replace true: if @param pList contains a property "visible" of type ColorProperty and our m_PropertyList also has a "visible" property of a different type (e.g. BoolProperty), change the type, i.e. replace the objects behind the pointer.
   //##
   //## @sa SetProperty
   //## @sa ReplaceProperty
   //## @sa m_PropertyList
   void ConcatenatePropertyList(PropertyList* pList, bool replace = false);
 
   //##Documentation
   //## @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList
   //## of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
   //##
   //## If @a renderer is @a NULL or the @a propertyKey cannot be found
   //## in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
   //## PropertyList of this DataNode is queried.
   //## @sa GetPropertyList
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   mitk::BaseProperty* GetProperty(const char *propertyKey, const mitk::BaseRenderer* renderer = NULL) const;
 
   //##Documentation
   //## @brief Get the property of type T with key @a propertyKey from the PropertyList
   //## of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
   //##
   //## If @a renderer is @a NULL or the @a propertyKey cannot be found
   //## in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
   //## PropertyList of this DataNode is queried.
   //## @sa GetPropertyList
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   template <typename T>
     bool GetProperty(itk::SmartPointer<T> &property, const char *propertyKey, const mitk::BaseRenderer* renderer = NULL) const
   {
     property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
     return property.IsNotNull();
   }
 
   //##Documentation
   //## @brief Get the property of type T with key @a propertyKey from the PropertyList
   //## of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
   //##
   //## If @a renderer is @a NULL or the @a propertyKey cannot be found
   //## in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
   //## PropertyList of this DataNode is queried.
   //## @sa GetPropertyList
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   template <typename T>
     bool GetProperty(T* &property, const char *propertyKey, const mitk::BaseRenderer* renderer = NULL) const
   {
     property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
     return property!=NULL;
   }
 
   //##Documentation
   //## @brief Convenience access method for GenericProperty<T> properties
   //## (T being the type of the second parameter)
   //## @return @a true property was found
   template <typename T>
     bool GetPropertyValue(const char* propertyKey, T & value, mitk::BaseRenderer* renderer=NULL) const
     {
       GenericProperty<T>* gp= dynamic_cast<GenericProperty<T>*>(GetProperty(propertyKey, renderer));
       if ( gp != NULL )
       {
         value = gp->GetValue();
         return true;
       }
       return false;
     }
 
   // @brief Get a set of all group tags from this node's property list
   GroupTagList GetGroupTags() const;
 
   //##Documentation
   //## @brief Convenience access method for bool properties (instances of
   //## BoolProperty)
   //## @return @a true property was found
   bool GetBoolProperty(const char* propertyKey, bool &boolValue, mitk::BaseRenderer* renderer = NULL) const;
 
   //##Documentation
   //## @brief Convenience access method for int properties (instances of
   //## IntProperty)
   //## @return @a true property was found
   bool GetIntProperty(const char* propertyKey, int &intValue, mitk::BaseRenderer* renderer=NULL) const;
 
   //##Documentation
   //## @brief Convenience access method for float properties (instances of
   //## FloatProperty)
   //## @return @a true property was found
   bool GetFloatProperty(const char* propertyKey, float &floatValue, mitk::BaseRenderer* renderer = NULL) const;
 
   //##Documentation
   //## @brief Convenience access method for string properties (instances of
   //## StringProperty)
   //## @return @a true property was found
   bool GetStringProperty(const char* propertyKey, std::string& string, mitk::BaseRenderer* renderer = NULL) const;
 
   //##Documentation
   //## @brief Convenience access method for color properties (instances of
   //## ColorProperty)
   //## @return @a true property was found
   bool GetColor(float rgb[3], mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "color") const;
 
   //##Documentation
   //## @brief Convenience access method for level-window properties (instances of
   //## LevelWindowProperty)
   //## @return @a true property was found
   bool GetLevelWindow(mitk::LevelWindow &levelWindow, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "levelwindow") const;
 
   //##
   //##Documentation
   //## @brief set the node as selected
   void SetSelected(bool selected, mitk::BaseRenderer* renderer=NULL);
 
   //##
   //##Documentation
   //## @brief set the node as selected
   //## @return @a true node is selected
   bool IsSelected(mitk::BaseRenderer* renderer=NULL);
 
   //##Documentation
   //## @brief Convenience access method for accessing the name of an object (instance of
   //## StringProperty with property-key "name")
   //## @return @a true property was found
   bool GetName(std::string& nodeName, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "name") const
   {
     return GetStringProperty(propertyKey, nodeName, renderer);
   }
 
   //##Documentation
   //## @brief Extra convenience access method for accessing the name of an object (instance of
   //## StringProperty with property-key "name").
   //##
   //## This method does not take the renderer specific
   //## propertylists into account, because the name of an object should never be renderer specific.
   //## @returns a std::string with the name of the object (content of "name" Property).
   //## If there is no "name" Property, an empty string will be returned.
   virtual std::string GetName() const
   {
     mitk::StringProperty* sp = dynamic_cast<mitk::StringProperty*>(this->GetProperty("name"));
     if (sp == NULL)
       return "";
     return sp->GetValue();
   }
 
   //##Documentation
   //## @brief Extra convenience access method to set the name of an object.
   //##
   //## The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
   virtual void SetName( const char* name)
   {
     if (name == NULL)
       return;
     this->SetProperty("name", StringProperty::New(name));
   }
   //##Documentation
   //## @brief Extra convenience access method to set the name of an object.
   //##
   //## The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
   virtual void SetName( const std::string name)
   {
     this->SetName(name.c_str());
   }
 
   //##Documentation
   //## @brief Convenience access method for visibility properties (instances
   //## of BoolProperty with property-key "visible")
   //## @return @a true property was found
   //## @sa IsVisible
   bool GetVisibility(bool &visible, mitk::BaseRenderer* renderer, const char* propertyKey = "visible") const
   {
     return GetBoolProperty(propertyKey, visible, renderer);
   }
 
   //##Documentation
   //## @brief Convenience access method for opacity properties (instances of
   //## FloatProperty)
   //## @return @a true property was found
   bool GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* propertyKey = "opacity") const;
 
   //##Documentation
   //## @brief Convenience access method for boolean properties (instances
   //## of BoolProperty). Return value is the value of the property. If the property is
   //## not found, the value of @a defaultIsOn is returned.
   //##
   //## Thus, the return value has a different meaning than in the
   //## GetBoolProperty method!
   //## @sa GetBoolProperty
   bool IsOn(const char* propertyKey, mitk::BaseRenderer* renderer, bool defaultIsOn = true) const
   {
     if(propertyKey==NULL)
       return defaultIsOn;
     GetBoolProperty(propertyKey, defaultIsOn, renderer);
     return defaultIsOn;
   }
 
   //##Documentation
   //## @brief Convenience access method for visibility properties (instances
   //## of BoolProperty). Return value is the visibility. Default is
   //## visible==true, i.e., true is returned even if the property (@a
   //## propertyKey) is not found.
   //##
   //## Thus, the return value has a different meaning than in the
   //## GetVisibility method!
   //## @sa GetVisibility
   //## @sa IsOn
   bool IsVisible(mitk::BaseRenderer* renderer, const char* propertyKey = "visible", bool defaultIsOn = true) const
   {
     return IsOn(propertyKey, renderer, defaultIsOn);
   }
 
   //##Documentation
   //## @brief Convenience method for setting color properties (instances of
   //## ColorProperty)
   void SetColor(const mitk::Color &color, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "color");
   //##Documentation
   //## @brief Convenience method for setting color properties (instances of
   //## ColorProperty)
   void SetColor(float red, float green, float blue, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "color");
   //##Documentation
   //## @brief Convenience method for setting color properties (instances of
   //## ColorProperty)
   void SetColor(const float rgb[3], mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "color");
 
   //##Documentation
   //## @brief Convenience method for setting visibility properties (instances
   //## of BoolProperty)
   //## @param visible If set to true, the data will be rendered. If false, the render will skip this data.
   //## @param renderer Specify a renderer if the visibility shall be specific to a renderer
   //## @param propertykey Can be used to specify a user defined name of the visibility propery.
   void SetVisibility(bool visible, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "visible");
 
   //##Documentation
   //## @brief Convenience method for setting opacity properties (instances of
   //## FloatProperty)
   void SetOpacity(float opacity, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "opacity");
 
   //##Documentation
   //## @brief Convenience method for setting level-window properties
   //## (instances of LevelWindowProperty)
   void SetLevelWindow(mitk::LevelWindow levelWindow, mitk::BaseRenderer* renderer = NULL, const char* propertyKey = "levelwindow");
 
   //##Documentation
   //## @brief Convenience method for setting int properties (instances of
   //## IntProperty)
   void SetIntProperty(const char* propertyKey, int intValue, mitk::BaseRenderer* renderer=NULL);
 
   //##Documentation
   //## @brief Convenience method for setting int properties (instances of
   //## IntProperty)
   void SetBoolProperty(const char* propertyKey, bool boolValue, mitk::BaseRenderer* renderer=NULL);
 
   //##Documentation
   //## @brief Convenience method for setting int properties (instances of
   //## IntProperty)
   void SetFloatProperty(const char* propertyKey, float floatValue, mitk::BaseRenderer* renderer=NULL);
 
   //##Documentation
   //## @brief Convenience method for setting int properties (instances of
   //## IntProperty)
   void SetStringProperty(const char* propertyKey, const char* string, mitk::BaseRenderer* renderer=NULL);
 
   //##Documentation
   //## @brief Get the timestamp of the last change of the contents of this node or
   //## the referenced BaseData.
   virtual unsigned long GetMTime() const;
 
   //##Documentation
   //## @brief Get the timestamp of the last change of the reference to the
   //## BaseData.
   unsigned long GetDataReferenceChangedTime() const
   {
     return m_DataReferenceChangedTime.GetMTime();
   }
 
   //##Documentation
   //## @brief Adds or removes the associated interactor to mitk::GLobalInteraction.
   //##
   virtual void SetInteractorEnabled( const bool& enabled );
 
   //##Documentation
   //## @brief Adds the interactor to mitk::GlobalInteraction
   //##
   virtual void EnableInteractor();
 
   //##Documentation
   //## @brief Removes the Interactor from mitk::GlobalInteraction
   //##
   virtual void DisableInteractor();
 
   //##Documentation
   //## @brief Tests, if the interactor is already added to mitk::GlobalInteraction
   //##
   virtual bool IsInteractorEnabled() const;
 
 protected:
   DataNode();
 
   virtual ~DataNode();
 
   //##
   //## Invoked when the property list was modified. Calls Modified() of the DataNode
   virtual void PropertyListModified(const itk::Object *caller, const itk::EventObject &event);
 
   //##Documentation
   //## @brief Mapper-slots
   mutable MapperVector m_Mappers;
 
   //##Documentation
   //## @brief The data object (instance of BaseData, e.g., an Image) managed
   //## by this DataNode
   BaseData::Pointer m_Data;
 
   //##Documentation
   //## @brief BaseRenderer-independent PropertyList
   //##
   //## Properties herein can be overwritten specifically for each BaseRenderer
   //## by the BaseRenderer-specific properties defined in m_MapOfPropertyLists.
   PropertyList::Pointer m_PropertyList;
 
   //##Documentation
   //## @brief Map associating each BaseRenderer with its own PropertyList
   mutable MapOfPropertyLists m_MapOfPropertyLists;
 
   //##Documentation
   //## @brief Interactor, that handles the Interaction
   Interactor::Pointer m_Interactor; // TODO: INTERACTION_LEGACY
 
   DataInteractor::Pointer m_DataInteractor;
 
 
   //##Documentation
   //## @brief Timestamp of the last change of m_Data
   itk::TimeStamp m_DataReferenceChangedTime;
 
   unsigned long m_PropertyListModifiedObserverTag;
 };
 
 
 #if (_MSC_VER > 1200) || !defined(_MSC_VER)
 MITK_CORE_EXPORT MBI_STD::istream& operator>>( MBI_STD::istream& i, DataNode::Pointer& dtn );
 
 MITK_CORE_EXPORT MBI_STD::ostream& operator<<( MBI_STD::ostream& o, DataNode::Pointer& dtn);
 #endif
 } // namespace mitk
 
 #if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
 MITK_CORE_EXPORT MBI_STD::istream& operator>>( MBI_STD::istream& i, mitk::DataNode::Pointer& dtn );
 
 MITK_CORE_EXPORT MBI_STD::ostream& operator<<( MBI_STD::ostream& o, mitk::DataNode::Pointer& dtn);
 #endif
 
 
 #endif /* DATATREENODE_H_HEADER_INCLUDED_C1E14338 */