diff --git a/Core/Code/DataManagement/mitkLevelWindowManager.cpp b/Core/Code/DataManagement/mitkLevelWindowManager.cpp
index 8f6ca0a1ee..5bec2b552c 100644
--- a/Core/Code/DataManagement/mitkLevelWindowManager.cpp
+++ b/Core/Code/DataManagement/mitkLevelWindowManager.cpp
@@ -1,439 +1,477 @@
 /*===================================================================
 
 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 "mitkLevelWindowManager.h"
 #include <itkCommand.h>
 #include "mitkDataStorage.h"
 #include "mitkNodePredicateBase.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkProperties.h"
 #include "mitkMessage.h"
+#include "mitkRenderingModeProperty.h"
 
 
 mitk::LevelWindowManager::LevelWindowManager()
 : m_DataStorage(NULL)
 , m_LevelWindowProperty(NULL)
 , m_AutoTopMost(true)
 , m_IsObserverTagSet(false)
 , m_CurrentImage(NULL)
 , m_IsPropertyModifiedTagSet(false)
 {
 }
 
 
 mitk::LevelWindowManager::~LevelWindowManager()
 {
   if (m_DataStorage.IsNotNull())
   {
     m_DataStorage->AddNodeEvent.RemoveListener(
         MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageAddedNode ));
     m_DataStorage->RemoveNodeEvent.RemoveListener(
         MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageRemovedNode ));
     m_DataStorage = NULL;
   }
 
   if (m_IsPropertyModifiedTagSet && m_LevelWindowProperty.IsNotNull())
   {
     m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag);
     m_IsPropertyModifiedTagSet = false;
   }
 
   //clear both observer maps
   this->ClearPropObserverLists();
 }
 
 
 void mitk::LevelWindowManager::SetDataStorage( mitk::DataStorage* ds )
 {
   if (ds == NULL) return;
 
   /* remove listeners of old DataStorage */
   if (m_DataStorage.IsNotNull())
   {
     m_DataStorage->AddNodeEvent.RemoveListener(
         MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageAddedNode ));
     m_DataStorage->RemoveNodeEvent.RemoveListener(
         MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageRemovedNode ));
   }
 
   /* register listener for new DataStorage */
   m_DataStorage = ds;  // register
   m_DataStorage->AddNodeEvent.AddListener(
       MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageAddedNode ));
   m_DataStorage->RemoveNodeEvent.AddListener(
       MessageDelegate1<LevelWindowManager, const mitk::DataNode*>( this, &LevelWindowManager::DataStorageRemovedNode ));
 
   this->DataStorageAddedNode(); // update us with new DataStorage
 }
 
 
 void mitk::LevelWindowManager::OnPropertyModified(const itk::EventObject& )
 {
   Modified();
 }
 
 
 void mitk::LevelWindowManager::SetAutoTopMostImage(bool autoTopMost, const mitk::DataNode* removedNode)
 {
   m_AutoTopMost = autoTopMost;
   if (m_AutoTopMost == false)
     return;
 
   if (m_IsPropertyModifiedTagSet && m_LevelWindowProperty.IsNotNull())
   {
     m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag);
     m_IsPropertyModifiedTagSet = false;
   }
 
   /* search topmost image */
   if (m_DataStorage.IsNull())
   {
     itkExceptionMacro("DataStorage not set");
   }
 
   int maxLayer = itk::NumericTraits<int>::min();
   m_LevelWindowProperty = NULL;
 
   mitk::DataNode::Pointer topLevelNode;
 
   mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
   {
     mitk::DataNode::Pointer node = it->Value();
     if (node.IsNull() || (removedNode != NULL && node == removedNode))
       continue;
 
     node->SetBoolProperty( "imageForLevelWindow", false );
 
     if (node->IsVisible(NULL) == false)
       continue;
 
     int layer = 0;
     node->GetIntProperty("layer", layer);
     if ( layer < maxLayer )
       continue;
 
     mitk::LevelWindowProperty::Pointer levelWindowProperty = dynamic_cast<mitk::LevelWindowProperty*>(node->GetProperty("levelwindow"));
     if (levelWindowProperty.IsNull())
       continue;
 
+    int currMode;
+    int nonLvlWinMode1 = mitk::RenderingModeProperty::LOOKUPTABLE_COLOR;
+    int nonLvlWinMode2 = mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR;
+
+    mitk::RenderingModeProperty::Pointer mode = dynamic_cast<mitk::RenderingModeProperty*>(node->GetProperty( "Image Rendering.Mode" ));
+    if(mode.IsNotNull())
+    {
+      currMode = mode->GetRenderingMode();
+    }
+    if ( currMode == nonLvlWinMode1 || currMode == nonLvlWinMode2 )
+    {
+      continue;
+    }
+
     m_LevelWindowProperty = levelWindowProperty;
     m_CurrentImage = dynamic_cast<mitk::Image*>(node->GetData());
     topLevelNode = node;
 
     maxLayer = layer;
   }
 
   if (topLevelNode.IsNotNull())
   {
     topLevelNode->SetBoolProperty( "imageForLevelWindow", true );
   }
 
   this->SetLevelWindowProperty( m_LevelWindowProperty );
 
   if ( m_LevelWindowProperty.IsNull() )
   {
     Modified();
   }
   // else SetLevelWindowProperty will call Modified();
 }
 
 // sets an specific LevelWindowProperty, all changes will affect the image belonging to this property.
 void mitk::LevelWindowManager::SetLevelWindowProperty(LevelWindowProperty::Pointer levelWindowProperty)
 {
   if (levelWindowProperty.IsNull())
     return;
 
   if (m_IsPropertyModifiedTagSet)  // remove listener for old property
   {
     m_LevelWindowProperty->RemoveObserver(m_PropertyModifiedTag);
     m_IsPropertyModifiedTagSet = false;
   }
 
   m_LevelWindowProperty = levelWindowProperty;
 
   itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command = itk::ReceptorMemberCommand<LevelWindowManager>::New();  // register listener for new property
   command->SetCallbackFunction(this, &LevelWindowManager::OnPropertyModified);
   m_PropertyModifiedTag = m_LevelWindowProperty->AddObserver( itk::ModifiedEvent(), command );
   m_IsPropertyModifiedTagSet = true;
 
   /* search image than belongs to the property */
   mitk::NodePredicateProperty::Pointer p = mitk::NodePredicateProperty::New("levelwindow", m_LevelWindowProperty);
   mitk::DataNode* n = m_DataStorage->GetNode(p);
   if (n == NULL)
   {
     mitkThrow() << "No Image in DataStorage that belongs to LevelWindow property" << m_LevelWindowProperty;
   }
 
   m_CurrentImage = dynamic_cast<mitk::Image*>(n->GetData());
   n->SetBoolProperty( "imageForLevelWindow", true );
   this->Modified();
 }
 
 
 // returns the current mitkLevelWindowProperty object from the image that is affected by changes
 mitk::LevelWindowProperty::Pointer mitk::LevelWindowManager::GetLevelWindowProperty()
 {
   return m_LevelWindowProperty;
 }
 
 
 // returns Level/Window values for the current image
 const mitk::LevelWindow& mitk::LevelWindowManager::GetLevelWindow()
 {
   if (m_LevelWindowProperty.IsNotNull())
   {
     return m_LevelWindowProperty->GetLevelWindow();
   }
   else
   {
     itkExceptionMacro("No LevelWindow available!");
   }
 }
 
 // sets new Level/Window values and informs all listeners about changes
 void mitk::LevelWindowManager::SetLevelWindow(const mitk::LevelWindow& levelWindow)
 {
   if (m_LevelWindowProperty.IsNotNull())
   {
     m_LevelWindowProperty->SetLevelWindow(levelWindow);
   }
   this->Modified();
 }
 
 void mitk::LevelWindowManager::DataStorageAddedNode( const mitk::DataNode* )
 {
 
   //update observers with new data storage
   UpdateObservers();
 
   //Initialize LevelWindowsManager to new image
   SetAutoTopMostImage(true);
 
   //check if everything is still ok
   if ((m_PropObserverToNode.size() != m_PropObserverToNode2.size()) || (m_PropObserverToNode2.size() != this->GetRelevantNodes()->size()))
      {mitkThrow() << "Wrong number of observers in Level Window Manager!";}
 
 }
 
 void mitk::LevelWindowManager::DataStorageRemovedNode( const mitk::DataNode* removedNode )
 {
   //first: check if deleted node is part of relevant nodes. If not, abort method because there is no need change anything.
   if ((this->GetRelevantNodes()->size() == 0)) return;
   bool removedNodeIsRelevant = false;
   /* Iterator code: is crashing, don't know why... so using for loop
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = this->GetRelevantNodes()->Begin();
        it != this->GetRelevantNodes()->End();
        ++it)
   {if (it->Value() == removedNode) {removedNodeIsRelevant=true;}}*/
   for (unsigned int i=0; i<this->GetRelevantNodes()->size(); i++)
     {
     if (this->GetRelevantNodes()->at(i) == removedNode) {removedNodeIsRelevant=true;}
     }
   if (!removedNodeIsRelevant) return;
 
   //remember node which will be removed
   m_NodeMarkedToDelete = removedNode;
 
   //update observers
   UpdateObservers();
 
   /* search image than belongs to the property */
   if (m_LevelWindowProperty.IsNull())
   {
     SetAutoTopMostImage(true, removedNode);
   }
   else
   {
     mitk::NodePredicateProperty::Pointer p2 = mitk::NodePredicateProperty::New("levelwindow", m_LevelWindowProperty);
     mitk::DataNode* n = m_DataStorage->GetNode(p2);
     if (n == NULL || m_AutoTopMost) // if node was deleted, change our behaviour to AutoTopMost, if AutoTopMost is true change level window to topmost node
     {
       SetAutoTopMostImage(true, removedNode);
     }
   }
 
   //reset variable
   m_NodeMarkedToDelete = NULL;
 
   //check if everything is still ok
   if ((m_PropObserverToNode.size() != m_PropObserverToNode2.size()) || (m_PropObserverToNode2.size() != (this->GetRelevantNodes()->size()-1)))
      {mitkThrow() << "Wrong number of observers in Level Window Manager!";}
 }
 
 void mitk::LevelWindowManager::UpdateObservers()
 {
   this->ClearPropObserverLists(); //remove old observers
   CreatePropObserverLists(); //create new observer lists
 
 
 
 
 }
 
 
 int mitk::LevelWindowManager::GetNumberOfObservers()
 {
   return m_PropObserverToNode.size();
 }
 
 mitk::DataStorage* mitk::LevelWindowManager::GetDataStorage()
 {
   return m_DataStorage.GetPointer();
 }
 
 
 // true if changes on slider or line-edits will affect always the topmost layer image
 bool mitk::LevelWindowManager::isAutoTopMost()
 {
   return m_AutoTopMost;
 }
 
 
 void mitk::LevelWindowManager::Update(const itk::EventObject&)  // visible property of a image has changed
 {
   if (m_AutoTopMost)
   {
     SetAutoTopMostImage(true);
     return;
   }
   mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin();
        it != all->End();
        ++it)
   {
     mitk::DataNode::Pointer node = it->Value();
     if (node.IsNull())
       continue;
 
     node->SetBoolProperty( "imageForLevelWindow", false );
 
     if (node->IsVisible(NULL) == false)
       continue;
 
     mitk::LevelWindowProperty::Pointer levelWindowProperty = dynamic_cast<mitk::LevelWindowProperty*>(node->GetProperty("levelwindow"));
     if (levelWindowProperty.IsNull())
       continue;
 
     m_LevelWindowProperty = levelWindowProperty;
     m_CurrentImage = dynamic_cast<mitk::Image*>(node->GetData());
     node->SetBoolProperty( "imageForLevelWindow", true );
     if (m_LevelWindowProperty.IsNull() && m_LevelWindowProperty.GetPointer() == levelWindowProperty) // we found our m_LevelWindowProperty
     {
       return;
     }
   }
   Modified();
 }
 
 
 mitk::DataStorage::SetOfObjects::ConstPointer mitk::LevelWindowManager::GetRelevantNodes()
 {
   if (m_DataStorage.IsNull())
     return mitk::DataStorage::SetOfObjects::ConstPointer(mitk::DataStorage::SetOfObjects::New());  // return empty set
 
   mitk::BoolProperty::Pointer trueProp = mitk::BoolProperty::New(true);
   mitk::NodePredicateProperty::Pointer notBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(false));
   mitk::NodePredicateProperty::Pointer hasLevelWindow = mitk::NodePredicateProperty::New("levelwindow", NULL);
 
   mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
   mitk::NodePredicateDataType::Pointer isDImage = mitk::NodePredicateDataType::New("DiffusionImage");
   mitk::NodePredicateDataType::Pointer isTImage = mitk::NodePredicateDataType::New("TensorImage");
   mitk::NodePredicateDataType::Pointer isQImage = mitk::NodePredicateDataType::New("QBallImage");
   mitk::NodePredicateOr::Pointer predicateTypes = mitk::NodePredicateOr::New();
   predicateTypes->AddPredicate(isImage);
   predicateTypes->AddPredicate(isDImage);
   predicateTypes->AddPredicate(isTImage);
   predicateTypes->AddPredicate(isQImage);
 
   mitk::NodePredicateAnd::Pointer predicate = mitk::NodePredicateAnd::New();
   predicate->AddPredicate(notBinary);
   predicate->AddPredicate(hasLevelWindow);
   predicate->AddPredicate(predicateTypes);
 
   mitk::DataStorage::SetOfObjects::ConstPointer relevantNodes = m_DataStorage->GetSubset( predicate );
 
   return relevantNodes;
 }
 
 
 mitk::Image* mitk::LevelWindowManager::GetCurrentImage()
 {
   return m_CurrentImage;
 }
 
 void mitk::LevelWindowManager::ClearPropObserverLists()
 {
 for( ObserverToPropertyMap::iterator iter = m_PropObserverToNode.begin();
        iter != m_PropObserverToNode.end();
        ++iter )
   {
     (*iter).second->RemoveObserver((*iter).first.first);
     (*iter).second = 0;
   }
   m_PropObserverToNode.clear();
 
   for( ObserverToPropertyMap::iterator iter = m_PropObserverToNode2.begin();
        iter != m_PropObserverToNode2.end();
        ++iter )
   {
     (*iter).second->RemoveObserver((*iter).first.first);
     (*iter).second = 0;
   }
   m_PropObserverToNode2.clear();
+
+  for( ObserverToPropertyMap::iterator iter = m_PropObserverToNode3.begin();
+       iter != m_PropObserverToNode3.end();
+       ++iter )
+  {
+    (*iter).second->RemoveObserver((*iter).first.first);
+    (*iter).second = 0;
+  }
+  m_PropObserverToNode3.clear();
 }
 
 void mitk::LevelWindowManager::CreatePropObserverLists()
 {
   if (m_DataStorage.IsNull())     //check if data storage is set
     {itkExceptionMacro("DataStorage not set");}
 
   /* add observers for all relevant nodes */
   mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin();
        it != all->End();
        ++it)
   {
     if ((it->Value().IsNull()) || (it->Value() == m_NodeMarkedToDelete))
       {continue;}
 
     /* register listener for changes in visible property */
     itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command = itk::ReceptorMemberCommand<LevelWindowManager>::New();
     command->SetCallbackFunction(this, &LevelWindowManager::Update);
     unsigned long idx = it->Value()->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command );
     m_PropObserverToNode[PropDataPair(idx, it->Value())] = it->Value()->GetProperty("visible");
   }
 
   /* add observers for all layer properties*/
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin();
        it != all->End();
        ++it)
   {
     if ((it->Value().IsNull()) || (it->Value() == m_NodeMarkedToDelete))
       {continue;}
     /* register listener for changes in layer property */
     itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command2 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
     command2->SetCallbackFunction(this, &LevelWindowManager::Update);
     unsigned long idx = it->Value()->GetProperty("layer")->AddObserver( itk::ModifiedEvent(), command2 );
     m_PropObserverToNode2[PropDataPair(idx, it->Value())] = it->Value()->GetProperty("layer");
   }
 
+  /* add observers for all Image rendering.mode properties*/
+  for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin();
+       it != all->End();
+       ++it)
+  {
+    if ((it->Value().IsNull()) || (it->Value() == m_NodeMarkedToDelete))
+      {continue;}
+    /* register listener for changes in layer property */
+    itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command3 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
+    command3->SetCallbackFunction(this, &LevelWindowManager::Update);
+    unsigned long idx = it->Value()->GetProperty("Image Rendering.Mode")->AddObserver( itk::ModifiedEvent(), command3 );
+    m_PropObserverToNode3[PropDataPair(idx, it->Value())] = it->Value()->GetProperty("Image Rendering.Mode");
+  }
+
 }
diff --git a/Core/Code/DataManagement/mitkLevelWindowManager.h b/Core/Code/DataManagement/mitkLevelWindowManager.h
index 0327c51dfb..3f20943e5e 100644
--- a/Core/Code/DataManagement/mitkLevelWindowManager.h
+++ b/Core/Code/DataManagement/mitkLevelWindowManager.h
@@ -1,142 +1,143 @@
 /*===================================================================
 
 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 mitkLevelWindowManager_h
 #define mitkLevelWindowManager_h
 
 #include "mitkDataStorage.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkBaseProperty.h"
 #include <map>
 #include <utility>
 
 namespace mitk
 {
 
 /**
   \brief Provides access to the LevelWindowProperty object and LevelWindow of the "current" image.
 
   - provides a LevelWindowProperty for purposes like GUI editors
   - this property comes from one of two possible sources
     - either something (e.g. the application) sets the property because of some user selection
     - OR the "Auto top-most" logic is used to search a DataStorage for the image with the highest "layer" property value
 
   Changes on Level/Window can be set with SetLevelWindow() and will affect either the topmost layer image,
   if isAutoTopMost() returns true, or an image which is set by SetLevelWindowProperty(LevelWindowProperty::Pointer levelWindowProperty).
 
   Changes to Level/Window, when another image gets active or by SetLevelWindow(const LevelWindow& levelWindow),
   will be sent to all listeners by Modified().
 
   DataStorageChanged() listens to the DataStorage for new or removed images. Depending on how m_AutoTopMost is set,
   the new image becomes active or not. If an image is removed from the DataStorage and m_AutoTopMost is false,
   there is a check to proof, if the active image is still available. If not, then m_AutoTopMost becomes true.
 
   Note that this class is not thread safe at the moment!
 */
 
   class MITK_CORE_EXPORT LevelWindowManager : public itk::Object
   {
   public:
 
     mitkClassMacro(LevelWindowManager, itk::Object)
     itkNewMacro(Self);
 
     void SetDataStorage(DataStorage* ds);
     DataStorage* GetDataStorage();  ///< returns the datastorage
 
     /** @brief (Re-)Initializes the LevelWindowManager by setting the topmost image.
      *         Use the removedNode parameter if a node was removed...
      *  @param autoTopMost true: sets the topmost layer image to be affected by changes
      *  @param removedNode != NULL a node was removed from DataStorage */
     void SetAutoTopMostImage(bool autoTopMost, const DataNode* removedNode = NULL);
 
     void Update(const itk::EventObject& e);  ///< gets called if a visible property changes
 
     /** @brief Sets an specific LevelWindowProperty, all changes will affect the image belonging to this property.
      *  @throw mitk::Exception Throws an exception if the there is no image in the data storage which belongs to this property.*/
     void SetLevelWindowProperty(LevelWindowProperty::Pointer levelWindowProperty);
 
     /** @brief Sets new Level/Window values and informs all listeners about changes. */
     void SetLevelWindow(const LevelWindow& levelWindow);
 
     /** @return Returns Level/Window values for the current image.*/
     const LevelWindow& GetLevelWindow();
 
     /** @return Returns the current mitkLevelWindowProperty object from the image that is affected by changes.*/
     LevelWindowProperty::Pointer GetLevelWindowProperty();
 
     /** @return true if changes on slider or line-edits will affect always the topmost layer image. */
     bool isAutoTopMost();
 
     /** @brief This method is called when a node is added to the data storage.
       *        A listener on the data storage is used to call this method automatically after a node was added.
       * @throw mitk::Exception Throws an exception if something is wrong, e.g. if the number of observers differs from the number of nodes.
       */
     void DataStorageAddedNode(const DataNode* n = NULL);
 
     /** @brief This method is called when a node is removed to the data storage.
       *        A listener on the data storage is used to call this method automatically directly before a node will be removed.
       * @throw mitk::Exception Throws an exception if something is wrong, e.g. if the number of observers differs from the number of nodes.
       */
     void DataStorageRemovedNode(const DataNode* removedNode = NULL);
 
     /** @brief change notifications from mitkLevelWindowProperty */
     void OnPropertyModified(const itk::EventObject& e);
 
     Image* GetCurrentImage(); ///< return the currently active image
 
     /**
      * @return Returns the current number of observers which are registered in this object.
      * @throw mitk::Exception Throws an exception if the number of observers differs from
      *                        the number of relevant objects
      *                        which means that something is wrong.
      *
      */
     int GetNumberOfObservers();
 
 
     /**
     *  returns all nodes in the DataStorage that have the following properties:
     *  "visible" == true, "binary" == false, "levelwindow", and DataType == Image
     */
     DataStorage::SetOfObjects::ConstPointer GetRelevantNodes();
 
   protected:
     LevelWindowManager();
     ~LevelWindowManager();
 
     DataStorage::Pointer         m_DataStorage;
     LevelWindowProperty::Pointer m_LevelWindowProperty; ///< pointer to the LevelWindowProperty of the current image
     typedef std::pair<unsigned long, DataNode::Pointer> PropDataPair;
     typedef std::map<PropDataPair, BaseProperty::Pointer> ObserverToPropertyMap;
 
     ObserverToPropertyMap        m_PropObserverToNode;  ///< map to hold observer IDīs to every visible property of DataNodeīs BaseProperty
     ObserverToPropertyMap        m_PropObserverToNode2; ///< map to hold observer IDīs to every layer property of DataNodeīs BaseProperty
+    ObserverToPropertyMap        m_PropObserverToNode3; ///< map to hold observer IDīs to every Image Rendering.Mode property of DataNodeīs BaseProperty
     void UpdateObservers();                             ///< updates the internal observer list. Ignores nodes which are marked to be deleted in the variable m_NodeMarkedToDelete
     void ClearPropObserverLists();                      ///< internal help method to clear both lists/maps.
     void CreatePropObserverLists();                     ///< internal help method to create both lists/maps.
     const mitk::DataNode*        m_NodeMarkedToDelete;  ///< this variable holds a data node which will be deleted from the datastorage immedeately (if there is one, NULL otherways)
 
     bool                         m_AutoTopMost;
     unsigned long                m_ObserverTag;
     bool                         m_IsObserverTagSet;
     unsigned long                m_PropertyModifiedTag;
     Image*                 m_CurrentImage;
     bool                         m_IsPropertyModifiedTagSet;
   };
 }
 #endif