Manages and coordinates instances of mitk::Tool. More...

#include <mitkToolManager.h>

Collaboration diagram for mitk::ToolManager:

Public Types
typedef std::vector < Tool::Pointer >	ToolVectorType
typedef std::vector < Tool::ConstPointer >	ToolVectorTypeConst
typedef std::vector< DataNode * >	DataVectorType
typedef std::map< DataNode *, unsigned long >	NodeTagMapType
typedef ToolManager	Self
typedef itk::Object	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
const ToolVectorTypeConst	GetTools ()
	Gives you a list of all tools. This is const on purpose.
int	GetToolID (const Tool *tool)
Tool *	GetToolById (int id)
bool	ActivateTool (int id)
template<class T >
int	GetToolIdByToolType ()
int	GetActiveToolID ()
Tool *	GetActiveTool ()
void	SetReferenceData (DataVectorType)
void	SetReferenceData (DataNode *)
void	SetWorkingData (DataVectorType)
void	SetWorkingData (DataNode *)
void	SetRoiData (DataVectorType)
void	SetRoiData (DataNode *)
DataVectorType	GetReferenceData ()
DataNode *	GetReferenceData (int)
DataVectorType	GetWorkingData ()
DataNode *	GetWorkingData (int)
DataVectorType	GetRoiData ()
DataNode *	GetRoiData (int idx)
DataStorage *	GetDataStorage ()
void	SetDataStorage (DataStorage &storage)
void	RegisterClient ()
void	UnregisterClient ()
void	OnOneOfTheReferenceDataDeletedConst (const itk::Object *caller, const itk::EventObject &e)
void	OnOneOfTheReferenceDataDeleted (itk::Object *caller, const itk::EventObject &e)
void	OnOneOfTheWorkingDataDeletedConst (const itk::Object *caller, const itk::EventObject &e)
void	OnOneOfTheWorkingDataDeleted (itk::Object *caller, const itk::EventObject &e)
void	OnOneOfTheRoiDataDeletedConst (const itk::Object *caller, const itk::EventObject &e)
void	OnOneOfTheRoiDataDeleted (itk::Object *caller, const itk::EventObject &e)
void	OnToolErrorMessage (std::string s)
void	OnGeneralToolMessage (std::string s)
Static Public Member Functions
static Pointer	New (DataStorage *_arg)
Public Attributes
Message	NodePropertiesChanged
Message	NewNodesGenerated
Message1< DataVectorType * >	NewNodeObjectsGenerated
Message	ActiveToolChanged
Message	ReferenceDataChanged
Message	WorkingDataChanged
Message	RoiDataChanged
Message1< std::string >	ToolErrorMessage
Message1< std::string >	GeneralToolMessage
Protected Member Functions
	ToolManager (DataStorage *storage)
virtual	~ToolManager ()
Protected Attributes
ToolVectorType	m_Tools
Tool *	m_ActiveTool
int	m_ActiveToolID
DataVectorType	m_ReferenceData
NodeTagMapType	m_ReferenceDataObserverTags
DataVectorType	m_WorkingData
NodeTagMapType	m_WorkingDataObserverTags
DataVectorType	m_RoiData
NodeTagMapType	m_RoiDataObserverTags
int	m_RegisteredClients
WeakPointer< DataStorage >	m_DataStorage

Detailed Description

Manages and coordinates instances of mitk::Tool.

See also:: QmitkToolSelectionBox; QmitkToolReferenceDataSelectionBox; QmitkToolWorkingDataSelectionBox; Tool; QmitkInteractiveSegmentation

There is a separate page describing the general design of QmitkInteractiveSegmentation: QmitkInteractiveSegmentationTechnicalPage

This class creates and manages several instances of mitk::Tool.

ToolManager creates instances of mitk::Tool by asking the itk::ObjectFactory to list all known implementations of mitk::Tool. As a result, one has to implement both a subclass of mitk::Tool and a matching subclass of itk::ObjectFactoryBase that is registered to the top-level itk::ObjectFactory. For an example, see mitkContourToolFactory.h. (this limitiation of one-class-one-factory is due to the implementation of itk::ObjectFactory). In MITK, the right place to register the factories to itk::ObjectFactory is the mitk::QMCoreObjectFactory or mitk::SBCoreObjectFactory.

One (and only one - or none at all) of the registered tools can be activated using ActivateTool. This tool is registered to mitk::GlobalInteraction as a listener and will receive all mouse clicks and keyboard strokes that get into the MITK event mechanism. Tools are automatically unregistered from GlobalInteraction when no clients are registered to ToolManager (see RegisterClient()).

ToolManager knows a set of "reference" DataNodes and a set of "working" DataNodes. The first application are segmentation tools, where the reference is the original image and the working data the (kind of) binary segmentation. However, ToolManager is implemented more generally, so that there could be other tools that work, e.g., with surfaces.

Any "user/client" of ToolManager, i.e. every functionality that wants to use a tool, should call RegisterClient when the tools should be active. ToolManager keeps track of how many clients want it to be used, and when this count reaches zero, it unregistes the active Tool from GlobalInteraction. In "normal" settings, the functionality does not need to care about that if it uses a QmitkToolSelectionBox, which does exactly that when it is enabled/disabled.

There is a set of events that are sent by ToolManager. At the moment these are TODO update documentation:
- mitk::ToolReferenceDataChangedEvent whenever somebody calls SetReferenceData. Most of the time this actually means that the data has changed, but there might be cases where the same data is passed to SetReferenceData a second time, so don't rely on the assumption that something actually changed.
- mitk::ToolSelectedEvent is sent when a (truly) different tool was activated. In reaction to this event you can ask for the active Tool using GetActiveTool or GetActiveToolID (where NULL or -1 indicate that NO tool is active at the moment).

Design descisions:

Not a singleton, because there could be two functionalities using tools, each one with different reference/working data.

$Author$

Definition at line 85 of file mitkToolManager.h.

Member Typedef Documentation

typedef itk::SmartPointer<const Self> mitk::ToolManager::ConstPointer

Definition at line 106 of file mitkToolManager.h.

typedef std::vector<DataNode*> mitk::ToolManager::DataVectorType

Definition at line 91 of file mitkToolManager.h.

typedef std::map<DataNode*, unsigned long> mitk::ToolManager::NodeTagMapType

Definition at line 92 of file mitkToolManager.h.

typedef itk::SmartPointer<Self> mitk::ToolManager::Pointer

Definition at line 106 of file mitkToolManager.h.

typedef ToolManager mitk::ToolManager::Self

Definition at line 106 of file mitkToolManager.h.

typedef itk::Object mitk::ToolManager::Superclass

Definition at line 106 of file mitkToolManager.h.

typedef std::vector<Tool::Pointer> mitk::ToolManager::ToolVectorType

Definition at line 89 of file mitkToolManager.h.

typedef std::vector<Tool::ConstPointer> mitk::ToolManager::ToolVectorTypeConst

Definition at line 90 of file mitkToolManager.h.

Constructor & Destructor Documentation

mitk::ToolManager::ToolManager ( DataStorage * storage ) [protected]

You may specify a list of tool "groups" that should be available for this ToolManager. Every Tool can report its group as a string. This constructor will try to find the tool's group inside the supplied string. If there is a match, the tool is accepted. Effectively, you can provide a human readable list like "default, lymphnodevolumetry, oldERISstuff".

Definition at line 27 of file mitkToolManager.cpp.

References mitk::CoreObjectFactory::GetInstance(), m_Tools, OnGeneralToolMessage(), and OnToolErrorMessage().

:m_ActiveTool(NULL),
 m_ActiveToolID(-1),
 m_RegisteredClients(0),
 m_DataStorage(storage)
{
  CoreObjectFactory::GetInstance(); // to make sure a CoreObjectFactory was instantiated (and in turn, possible tools are registered) - bug 1029

  // get a list of all known mitk::Tools
  std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");

  // remember these tools
  for ( std::list<itk::LightObject::Pointer>::iterator iter = thingsThatClaimToBeATool.begin();
    iter != thingsThatClaimToBeATool.end();
    ++iter )
  {
    if ( Tool* tool = dynamic_cast<Tool*>( iter->GetPointer() ) )
    {
      tool->SetToolManager(this); // important to call right after instantiation
      tool->ErrorMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnToolErrorMessage );
      tool->GeneralMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnGeneralToolMessage );
      m_Tools.push_back( tool );
    }
  }

  //ActivateTool(0); // first one is default
}

mitk::ToolManager::~ToolManager ( ) [protected, virtual]

Definition at line 55 of file mitkToolManager.cpp.

References mitk::GlobalInteraction::GetInstance(), and mitk::GlobalInteraction::RemoveListener().

{
  if (m_ActiveTool)
  {
    m_ActiveTool->Deactivated();
    GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );

    m_ActiveTool = NULL;
    m_ActiveToolID = -1; // no tool active

    ActiveToolChanged.Send();
  }
  for ( NodeTagMapType::iterator observerTagMapIter = m_ReferenceDataObserverTags.begin(); observerTagMapIter != m_ReferenceDataObserverTags.end(); ++observerTagMapIter )
  {
    observerTagMapIter->first->RemoveObserver( observerTagMapIter->second );
  }
}

Member Function Documentation

bool mitk::ToolManager::ActivateTool ( int id )

Parameters:

id	The tool to activate. Provide -1 for disabling any tools. Counting starts with 0.

Definition at line 110 of file mitkToolManager.cpp.

References mitk::GlobalInteraction::AddListener(), mitk::GlobalInteraction::GetInstance(), and mitk::GlobalInteraction::RemoveListener().

Referenced by QmitkSegmentationView::Deactivated().

{
  //MITK_INFO << "ToolManager::ActivateTool("<<id<<")"<<std::endl;
  //if( GetToolById(id) == NULL ) return false; // NO, invalid IDs are actually used here. Parameter -1 or anything that does not exists will deactivate all tools!

  if ( GetToolById( id ) == m_ActiveTool ) return true; // no change needed

  static int nextTool = -1;
  nextTool = id;
  //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): nextTool = "<<nextTool<<std::endl;

  static bool inActivateTool = false;
  if (inActivateTool)
  {
    //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): already inside ActivateTool somehow, returning now "<<std::endl;
    return true;
  }
  inActivateTool = true;

  while ( nextTool != m_ActiveToolID )
  {
    //MITK_INFO <<"ToolManager::ActivateTool: nextTool = " << nextTool << " (active tool = " << m_ActiveToolID<<")"<<std::endl;
    if (m_ActiveTool)
    {
      m_ActiveTool->Deactivated();
      GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
    }

    m_ActiveTool = GetToolById( nextTool );
    m_ActiveToolID = m_ActiveTool ? nextTool : -1; // current ID if tool is valid, otherwise -1

    ActiveToolChanged.Send();

    if (m_ActiveTool)
    {
      if (m_RegisteredClients)
      {
        m_ActiveTool->Activated();
        GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
      }
    }
  }

  inActivateTool = false;
  return (m_ActiveTool != NULL);
}

mitk::Tool * mitk::ToolManager::GetActiveTool ( )

Returns:: NULL for "No tool is active"

Definition at line 446 of file mitkToolManager.cpp.

{
  return m_ActiveTool;
}

int mitk::ToolManager::GetActiveToolID ( )

Returns:: -1 for "No tool is active"

Definition at line 441 of file mitkToolManager.cpp.

{
  return m_ActiveToolID;
}

virtual const char* mitk::ToolManager::GetClassName ( ) const [virtual]

mitk::DataStorage * mitk::ToolManager::GetDataStorage ( )

Definition at line 410 of file mitkToolManager.cpp.

{
  if ( m_DataStorage.IsNotNull() )
  {
    return m_DataStorage;
  }
  else
  {
    return NULL;
  }
}

mitk::ToolManager::DataVectorType mitk::ToolManager::GetReferenceData ( )

Definition at line 371 of file mitkToolManager.cpp.

Referenced by QmitkSegmentationView::CheckImageAlignment(), QmitkSegmentationView::CreateNewSegmentation(), QmitkSegmentationView::CreateSegmentationFromSurface(), QmitkSegmentationView::ForceDisplayPreferencesUponAllImages(), QmitkSlicesInterpolator::OnInterpolationActivated(), and QmitkSegmentationView::ToolboxStackPageChanged().

{
  return m_ReferenceData;
}

mitk::DataNode * mitk::ToolManager::GetReferenceData ( int idx )

Definition at line 376 of file mitkToolManager.cpp.

{
  try
  {
    return m_ReferenceData.at(idx);
  }
  catch(std::exception&)
  {
    return NULL;
  }
}

mitk::DataNode * mitk::ToolManager::GetRoiData ( int idx )

Definition at line 398 of file mitkToolManager.cpp.

{
  try
  {
    return m_RoiData.at(idx);
  }
  catch(std::exception&)
  {
    return NULL;
  }
}

mitk::ToolManager::DataVectorType mitk::ToolManager::GetRoiData ( )

Definition at line 393 of file mitkToolManager.cpp.

{
  return m_RoiData;
}

mitk::Tool * mitk::ToolManager::GetToolById ( int id )

Definition at line 98 of file mitkToolManager.cpp.

Referenced by QmitkSegmentationView::CreateNewSegmentation().

{
  try
  {
    return m_Tools.at(id);
  }
  catch(std::exception&)
  {
    return NULL;
  }
}

int mitk::ToolManager::GetToolID ( const Tool * tool )

Definition at line 479 of file mitkToolManager.cpp.

{
  int id(0);
  for ( ToolVectorType::iterator iter = m_Tools.begin();
    iter != m_Tools.end();
    ++iter, ++id )
  {
    if ( tool == iter->GetPointer() )
    {
      return id;
    }
  }
  return -1;
}

template<class T >

int mitk::ToolManager::GetToolIdByToolType ( ) [inline]

Definition at line 130 of file mitkToolManager.h.

    {
      int id = 0;
      for ( ToolVectorType::iterator iter = m_Tools.begin();
            iter != m_Tools.end();
            ++iter, ++id )
      {
        if ( dynamic_cast<T*>(iter->GetPointer()) )
        {
          return id;
        }
      }
      return -1;
    }

const mitk::ToolManager::ToolVectorTypeConst mitk::ToolManager::GetTools ( )

Gives you a list of all tools. This is const on purpose.

Definition at line 84 of file mitkToolManager.cpp.

{
  ToolVectorTypeConst resultList;

  for ( ToolVectorType::iterator iter = m_Tools.begin();
    iter != m_Tools.end();
    ++iter )
  {
    resultList.push_back( iter->GetPointer() );
  }

  return resultList;
}

mitk::ToolManager::DataVectorType mitk::ToolManager::GetWorkingData ( )

Definition at line 388 of file mitkToolManager.cpp.

Referenced by QmitkSegmentationView::ForceDisplayPreferencesUponAllImages(), QmitkSlicesInterpolator::Initialize(), QmitkSlicesInterpolator::Interpolate(), QmitkSlicesInterpolator::OnInterpolationActivated(), and QmitkSegmentationView::ToolboxStackPageChanged().

{
  return m_WorkingData;
}

mitk::DataNode * mitk::ToolManager::GetWorkingData ( int idx )

Definition at line 429 of file mitkToolManager.cpp.

{
  try
  {
    return m_WorkingData.at(idx);
  }
  catch(std::exception&)
  {
    return NULL;
  }
}

static Pointer mitk::ToolManager::New ( DataStorage * _arg ) [inline, static]

Definition at line 107 of file mitkToolManager.h.

Referenced by mitkToolManagerTest(), QmitkToolReferenceDataSelectionBox::QmitkToolReferenceDataSelectionBox(), QmitkToolRoiDataSelectionBox::QmitkToolRoiDataSelectionBox(), QmitkToolSelectionBox::QmitkToolSelectionBox(), QmitkToolWorkingDataSelectionBox::QmitkToolWorkingDataSelectionBox(), and QmitkSegmentationPostProcessing::ThresholdImage().

void mitk::ToolManager::OnGeneralToolMessage ( std::string s )

Definition at line 78 of file mitkToolManager.cpp.

Referenced by ToolManager().

{
  this->GeneralToolMessage(s);
}

void mitk::ToolManager::OnOneOfTheReferenceDataDeleted	(	itk::Object *	caller,
		const itk::EventObject &	e
	)

Definition at line 195 of file mitkToolManager.cpp.

Referenced by SetReferenceData().

{
  //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
  DataVectorType v;

  for (DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
  {
    //MITK_INFO << " In list: " << (void*)(*dataIter);
    if ( (void*)(*dataIter) != (void*)caller )
    {
      v.push_back( *dataIter );
      //MITK_INFO << " kept" << std::endl;
    }
    else
    {
      //MITK_INFO << " removed" << std::endl;
      m_ReferenceDataObserverTags.erase( *dataIter ); // no tag to remove anymore
    }
  }
  this->SetReferenceData( v );
}

void mitk::ToolManager::OnOneOfTheReferenceDataDeletedConst	(	const itk::Object *	caller,
		const itk::EventObject &	e
	)

Definition at line 190 of file mitkToolManager.cpp.

Referenced by SetReferenceData().

{
  OnOneOfTheReferenceDataDeleted( const_cast<itk::Object*>(caller), e );
}

void mitk::ToolManager::OnOneOfTheRoiDataDeleted	(	itk::Object *	caller,
		const itk::EventObject &	e
	)

Definition at line 349 of file mitkToolManager.cpp.

Referenced by SetRoiData().

{
  //MITK_INFO << "Deleted: " << (void*)caller << " Removing from roi data list." << std::endl;
  DataVectorType v;

  for (DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
  {
    //MITK_INFO << " In list: " << (void*)(*dataIter);
    if ( (void*)(*dataIter) != (void*)caller )
    {
      v.push_back( *dataIter );
      //MITK_INFO << " kept" << std::endl;
    }
    else
    {
      //MITK_INFO << " removed" << std::endl;
      m_RoiDataObserverTags.erase( *dataIter ); // no tag to remove anymore
    }
  }
  this->SetRoiData( v );
}

void mitk::ToolManager::OnOneOfTheRoiDataDeletedConst	(	const itk::Object *	caller,
		const itk::EventObject &	e
	)

Definition at line 344 of file mitkToolManager.cpp.

Referenced by SetRoiData().

{
  OnOneOfTheRoiDataDeleted( const_cast<itk::Object*>(caller), e );
}

void mitk::ToolManager::OnOneOfTheWorkingDataDeleted	(	itk::Object *	caller,
		const itk::EventObject &	e
	)

Definition at line 266 of file mitkToolManager.cpp.

Referenced by SetWorkingData().

{
  //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
  DataVectorType v;

  for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
  {
    //MITK_INFO << " In list: " << (void*)(*dataIter);
    if ( (void*)(*dataIter) != (void*)caller )
    {
      v.push_back( *dataIter );
      //MITK_INFO << " kept" << std::endl;
    }
    else
    {
      //MITK_INFO << " removed" << std::endl;
      m_WorkingDataObserverTags.erase( *dataIter ); // no tag to remove anymore
    }
  }
  this->SetWorkingData( v );
}

void mitk::ToolManager::OnOneOfTheWorkingDataDeletedConst	(	const itk::Object *	caller,
		const itk::EventObject &	e
	)

Definition at line 261 of file mitkToolManager.cpp.

Referenced by SetWorkingData().

{
  OnOneOfTheWorkingDataDeleted( const_cast<itk::Object*>(caller), e );
}

void mitk::ToolManager::OnToolErrorMessage ( std::string s )

Definition at line 73 of file mitkToolManager.cpp.

Referenced by ToolManager().

{
  this->ToolErrorMessage(s);
}

void mitk::ToolManager::RegisterClient ( )

Definition at line 451 of file mitkToolManager.cpp.

References mitk::GlobalInteraction::AddListener(), and mitk::GlobalInteraction::GetInstance().

{
  if ( m_RegisteredClients == 0 )
  {
    if ( m_ActiveTool )
    {
      m_ActiveTool->Activated();
      GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
    }
  }

  ++m_RegisteredClients;
}

void mitk::ToolManager::SetDataStorage ( DataStorage & storage )

Definition at line 422 of file mitkToolManager.cpp.

Referenced by QmitkSegmentationView::CreateQtPartControl().

{
  m_DataStorage = &storage;
}

void mitk::ToolManager::SetReferenceData ( DataVectorType data )

Definition at line 157 of file mitkToolManager.cpp.

References OnOneOfTheReferenceDataDeleted(), and OnOneOfTheReferenceDataDeletedConst().

Referenced by QmitkSegmentationView::SetToolManagerSelection().

{
  if (data != m_ReferenceData)
  {
    // remove observers from old nodes
    for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
    {
      NodeTagMapType::iterator searchIter = m_ReferenceDataObserverTags.find( *dataIter );
      if ( searchIter != m_ReferenceDataObserverTags.end() )
      {
        //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
        (*dataIter)->RemoveObserver( searchIter->second );
      }
    }

    m_ReferenceData = data;
    // TODO tell active tool?

    // attach new observers
    m_ReferenceDataObserverTags.clear();
    for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
    {
      //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
      itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
      command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeleted );
      command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeletedConst );
      m_ReferenceDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
    }

    ReferenceDataChanged.Send();
  }
}

void mitk::ToolManager::SetReferenceData ( DataNode * data )

Definition at line 217 of file mitkToolManager.cpp.

{
  //MITK_INFO << "ToolManager::SetReferenceData(" << (void*)data << ")" << std::endl;
  DataVectorType v;
  if (data)
  {
    v.push_back(data);
  }
  SetReferenceData(v);
}

void mitk::ToolManager::SetRoiData ( DataNode * data )

Definition at line 333 of file mitkToolManager.cpp.

{
  DataVectorType v;

  if(data)
  {
    v.push_back(data);
  }
  this->SetRoiData(v);
}

void mitk::ToolManager::SetRoiData ( DataVectorType data )

Definition at line 301 of file mitkToolManager.cpp.

References OnOneOfTheRoiDataDeleted(), and OnOneOfTheRoiDataDeletedConst().

{
  if (data != m_RoiData)
  {
    // remove observers from old nodes
    for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
    {
      NodeTagMapType::iterator searchIter = m_RoiDataObserverTags.find( *dataIter );
      if ( searchIter != m_RoiDataObserverTags.end() )
      {
        //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
        (*dataIter)->RemoveObserver( searchIter->second );
      }
    }

    m_RoiData = data;
    // TODO tell active tool?

    // attach new observers
    m_RoiDataObserverTags.clear();
    for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
    {
      //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
      itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
      command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeleted );
      command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeletedConst );
      m_RoiDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
    }
    RoiDataChanged.Send();
  }
}

void mitk::ToolManager::SetWorkingData ( DataNode * data )

Definition at line 289 of file mitkToolManager.cpp.

{
  DataVectorType v;

  if (data) // don't allow for NULL nodes
  {
    v.push_back(data);
  }

  SetWorkingData(v);
}

void mitk::ToolManager::SetWorkingData ( DataVectorType data )

Definition at line 228 of file mitkToolManager.cpp.

References OnOneOfTheWorkingDataDeleted(), and OnOneOfTheWorkingDataDeletedConst().

Referenced by QmitkSegmentationView::SetToolManagerSelection().

{
  if ( data != m_WorkingData )
  {
    // remove observers from old nodes
    for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
    {
      NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( *dataIter );
      if ( searchIter != m_WorkingDataObserverTags.end() )
      {
        //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
        (*dataIter)->RemoveObserver( searchIter->second );
      }
    }

    m_WorkingData = data;
    // TODO tell active tool?

    // attach new observers
    m_WorkingDataObserverTags.clear();
    for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
    {
      //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
      itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
      command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeleted );
      command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeletedConst );
      m_WorkingDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
    }

    WorkingDataChanged.Send();
  }
}

void mitk::ToolManager::UnregisterClient ( )

Definition at line 465 of file mitkToolManager.cpp.

References mitk::GlobalInteraction::GetInstance(), and mitk::GlobalInteraction::RemoveListener().

{
  --m_RegisteredClients;

  if ( m_RegisteredClients == 0 )
  {
    if ( m_ActiveTool )
    {
      m_ActiveTool->Deactivated();
      GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
    }
  }
}