diff --git a/Core/Code/Interactions/mitkDispatcher.cpp b/Core/Code/Interactions/mitkDispatcher.cpp
index e14376a7de..49edf6d322 100644
--- a/Core/Code/Interactions/mitkDispatcher.cpp
+++ b/Core/Code/Interactions/mitkDispatcher.cpp
@@ -1,230 +1,234 @@
/*===================================================================
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 "mitkDispatcher.h"
#include "mitkInteractionEvent.h"
#include "mitkInternalEvent.h"
// MicroServices
#include "mitkGetModuleContext.h"
#include "mitkModule.h"
#include "mitkModuleRegistry.h"
#include "mitkInteractionEventObserver.h"
mitk::Dispatcher::Dispatcher() :
- m_ProcessingMode(REGULAR), m_EventObserverTracker(GetModuleContext())
+ m_ProcessingMode(REGULAR)
{
- m_EventObserverTracker.Open();
+ m_EventObserverTracker = new mitk::ServiceTracker<InteractionEventObserver*>(GetModuleContext());
+ m_EventObserverTracker->Open();
}
void mitk::Dispatcher::AddDataInteractor(const DataNode* dataNode)
{
RemoveDataInteractor(dataNode);
RemoveOrphanedInteractors();
DataInteractor::Pointer dataInteractor = dataNode->GetDataInteractor();
if (dataInteractor.IsNotNull())
{
m_Interactors.push_back(dataInteractor);
}
}
/*
* Note: One DataInteractor can only have one DataNode and vice versa,
* BUT the m_Interactors list may contain another DataInteractor that is still connected to this DataNode,
* in this case we have to remove >1 DataInteractor. (Some special case of switching DataNodes between DataInteractors and registering a
* DataNode to a DataStorage after assigning it to an DataInteractor)
*/
void mitk::Dispatcher::RemoveDataInteractor(const DataNode* dataNode)
{
for (ListInteractorType::iterator it = m_Interactors.begin(); it != m_Interactors.end();)
{
if ((*it)->GetDataNode() == dataNode)
{
it = m_Interactors.erase(it);
}
else
{
++it;
}
}
}
size_t mitk::Dispatcher::GetNumberOfInteractors()
{
return m_Interactors.size();
}
mitk::Dispatcher::~Dispatcher()
{
+ if (m_EventObserverTracker != NULL) {
+ delete m_EventObserverTracker;
+ }
}
bool mitk::Dispatcher::ProcessEvent(InteractionEvent* event)
{
InteractionEvent::Pointer p = event;
//MITK_INFO << event->GetEventClass();
bool eventIsHandled = false;
/* Filter out and handle Internal Events separately */
InternalEvent* internalEvent = dynamic_cast<InternalEvent*>(event);
if (internalEvent != NULL)
{
eventIsHandled = HandleInternalEvent(internalEvent);
// InternalEvents that are handled are not sent to the listeners
if (eventIsHandled)
{
return true;
}
}
switch (m_ProcessingMode)
{
case CONNECTEDMOUSEACTION:
// finished connected mouse action
if (p->GetEventClass() == "MouseReleaseEvent")
{
m_ProcessingMode = REGULAR;
eventIsHandled = m_SelectedInteractor->HandleEvent(event, m_SelectedInteractor->GetDataNode());
}
// give event to selected interactor
if (eventIsHandled == false)
{
eventIsHandled = m_SelectedInteractor->HandleEvent(event, m_SelectedInteractor->GetDataNode());
}
break;
case GRABINPUT:
eventIsHandled = m_SelectedInteractor->HandleEvent(event, m_SelectedInteractor->GetDataNode());
SetEventProcessingMode(m_SelectedInteractor);
break;
case PREFERINPUT:
if (m_SelectedInteractor->HandleEvent(event, m_SelectedInteractor->GetDataNode()) == true)
{
SetEventProcessingMode(m_SelectedInteractor);
eventIsHandled = true;
}
break;
case REGULAR:
break;
}
// Standard behavior. Is executed in STANDARD mode and PREFERINPUT mode, if preferred interactor rejects event.
if (m_ProcessingMode == REGULAR || (m_ProcessingMode == PREFERINPUT && eventIsHandled == false))
{
m_Interactors.sort(cmp()); // sorts interactors by layer (descending);
for (std::list<DataInteractor::Pointer>::iterator it = m_Interactors.begin(); it != m_Interactors.end(); ++it)
{
// explicit copy of pointer because HandleEvent function causes the m_Interactors list to be updated,
// which in turn invalidates the iterator.
DataInteractor::Pointer dataInteractor = *it;
if (dataInteractor->HandleEvent(event, dataInteractor->GetDataNode()))
{ // if an event is handled several properties are checked, in order to determine the processing mode of the dispatcher
SetEventProcessingMode(dataInteractor);
if (p->GetEventClass() == "MousePressEvent" && m_ProcessingMode == REGULAR)
{
m_SelectedInteractor = dataInteractor;
m_ProcessingMode = CONNECTEDMOUSEACTION;
}
eventIsHandled = true;
break;
}
}
}
/* Notify InteractionEventObserver */
std::list<mitk::ServiceReference> listEventObserver;
- m_EventObserverTracker.GetServiceReferences(listEventObserver);
+ m_EventObserverTracker->GetServiceReferences(listEventObserver);
for (std::list<mitk::ServiceReference>::iterator it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
{
Any patternName = it->GetProperty("org.mitk.statemachinepattern");
//if (!patternName.Empty() || patternName.ToString() == "")
//{
- InteractionEventObserver* interactionEventObserver = m_EventObserverTracker.GetService(*it);
+ InteractionEventObserver* interactionEventObserver = m_EventObserverTracker->GetService(*it);
if (interactionEventObserver != NULL)
{
interactionEventObserver->Notify(event, eventIsHandled);
}
//}
}
// Process event queue
if (!m_QueuedEvents.empty())
{
InteractionEvent::Pointer e = m_QueuedEvents.front();
m_QueuedEvents.pop_front();
ProcessEvent(e);
}
return eventIsHandled;
}
/*
* Checks if DataNodes associated with DataInteractors point back to them.
* If not remove the DataInteractors. (This can happen when s.o. tries to set DataNodes to multiple DataInteractors)
*/
void mitk::Dispatcher::RemoveOrphanedInteractors()
{
for (ListInteractorType::iterator it = m_Interactors.begin(); it != m_Interactors.end();)
{
DataNode::Pointer dn = (*it)->GetDataNode();
if (dn.IsNull())
{
it = m_Interactors.erase(it);
}
else
{
DataInteractor::Pointer interactor = dn->GetDataInteractor();
if (interactor != it->GetPointer())
{
it = m_Interactors.erase(it);
}
else
{
++it;
}
}
}
}
void mitk::Dispatcher::QueueEvent(InteractionEvent* event)
{
m_QueuedEvents.push_back(event);
}
void mitk::Dispatcher::SetEventProcessingMode(DataInteractor::Pointer dataInteractor)
{
m_ProcessingMode = dataInteractor->GetMode();
if (dataInteractor->GetMode() != REGULAR)
{
m_SelectedInteractor = dataInteractor;
}
}
bool mitk::Dispatcher::HandleInternalEvent(InternalEvent* internalEvent)
{
if (internalEvent->GetSignalName() == IntDeactivateMe && internalEvent->GetTargetInteractor() != NULL)
{
internalEvent->GetTargetInteractor()->GetDataNode()->SetDataInteractor(NULL);
internalEvent->GetTargetInteractor()->SetDataNode(NULL);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
return false;
}
diff --git a/Core/Code/Interactions/mitkDispatcher.h b/Core/Code/Interactions/mitkDispatcher.h
index 2ba95e36d4..e5815dbc73 100644
--- a/Core/Code/Interactions/mitkDispatcher.h
+++ b/Core/Code/Interactions/mitkDispatcher.h
@@ -1,131 +1,131 @@
/*===================================================================
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 mitkDispatcher_h
#define mitkDispatcher_h
#include "itkLightObject.h"
#include "itkObjectFactory.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include "mitkDataInteractor.h"
#include <MitkExports.h>
#include <list>
#include "mitkServiceTracker.h"
namespace mitk
{
class InternalEvent;
class InteractionEvent;
class InteractionEventObserver;
/**
* \class Dispatcher
* \brief Manages event distribution
*
* Receives Events (Mouse-,Key-, ... Events) and dispatches them to the registered DataInteractor Objects.
* The order in which DataInteractors are offered to handle an event is determined by layer of their associated DataNode.
* Higher layers are preferred.
*
* \ingroup Interaction
*/
class MITK_CORE_EXPORT Dispatcher: public itk::LightObject
{
public:
mitkClassMacro(Dispatcher, itk::LightObject);
itkNewMacro(Self);
typedef std::list<DataInteractor::Pointer> ListInteractorType;
typedef std::list<itk::SmartPointer<InteractionEvent> > ListEventsType;
/**
* To post new Events which are to be handled by the Dispatcher.
*
* @return Returns true if the event has been handled by an DataInteractor, and false else.
*/
bool ProcessEvent(InteractionEvent* event);
/**
* Adds an Event to the Dispatchers EventQueue, these events will be processed after a a regular posted event has been fully handled.
* This allows DataInteractors to post their own events without interrupting regular Dispatching workflow.
* It is important to note that the queued events will be processed AFTER the state change of a current transition (which queued the events)
* is performed.
*
* \note 1) If an event is added from an other source than an DataInteractor / Observer its execution will be delayed until the next regular event
* comes in.
* \note 2) Make sure you're not causing infinite loops!
*/
void QueueEvent(InteractionEvent* event);
/**
* Adds the DataInteractor that is associated with the DataNode to the Dispatcher Queue.
* If there already exists an DataInteractor that has a reference to the same DataNode, it is removed.
* Note that within this method also all other DataInteractors are checked and removed if they are no longer active,
* and were not removed properly.
*/
void AddDataInteractor(const DataNode* dataNode);
/**
* Remove all DataInteractors related to this Node, to prevent double entries and dead references.
*/
void RemoveDataInteractor(const DataNode* dataNode);
size_t GetNumberOfInteractors(); // DEBUG TESTING
protected:
Dispatcher();
virtual ~Dispatcher();
private:
struct cmp{
bool operator()(DataInteractor::Pointer d1, DataInteractor::Pointer d2){
return (d1->GetLayer() > d2->GetLayer());
}
};
std::list<DataInteractor::Pointer> m_Interactors;
ListEventsType m_QueuedEvents;
/**
* Removes all Interactors without a DataNode pointing to them, this is necessary especially when a DataNode is assigned to a new Interactor
*/
void RemoveOrphanedInteractors();
/**
* See \ref DispatcherEventDistSection for a description of ProcessEventModes
*/
ProcessEventMode m_ProcessingMode;
DataInteractor::Pointer m_SelectedInteractor;
void SetEventProcessingMode(DataInteractor::Pointer);
/**
* Function to handle special internal events,
* such as events that are directed at a specific DataInteractor,
* or the request to delete an Interactor and its DataNode.
*/
bool HandleInternalEvent(InternalEvent* internalEvent);
/**
* Hold microservice reference to object that takes care of informing the InteractionEventObservers about InteractionEvents
*/
- mitk::ServiceTracker<InteractionEventObserver*> m_EventObserverTracker;
+ mitk::ServiceTracker<InteractionEventObserver*>* m_EventObserverTracker;
};
} /* namespace mitk */
#endif /* mitkDispatcher_h */
diff --git a/Examples/QtFreeRender/QtFreeRender.cpp b/Examples/QtFreeRender/QtFreeRender.cpp
index 421c89fa8e..3149c7cbb4 100644
--- a/Examples/QtFreeRender/QtFreeRender.cpp
+++ b/Examples/QtFreeRender/QtFreeRender.cpp
@@ -1,385 +1,373 @@
/*===================================================================
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 "mitkRenderWindow.h"
#include <mitkDataNodeFactory.h>
#include <mitkStandaloneDataStorage.h>
#include <mitkProperties.h>
#include <mitkTransferFunction.h>
#include <mitkTransferFunctionProperty.h>
#include <mitkRenderingManager.h>
#include <mitkGlobalInteraction.h>
#include "mitkProperties.h"
#include "mitkGeometry2DDataMapper2D.h"
#include "mitkGlobalInteraction.h"
#include "mitkDisplayInteractor.h"
#include "mitkPositionEvent.h"
#include "mitkStateEvent.h"
#include "mitkLine.h"
#include "mitkInteractionConst.h"
#include "mitkVtkLayerController.h"
#include "mitkPositionTracker.h"
#include "mitkDisplayInteractor.h"
#include "mitkSlicesRotator.h"
#include "mitkSlicesSwiveller.h"
#include "mitkRenderWindowFrame.h"
#include "mitkGradientBackground.h"
#include "mitkCoordinateSupplier.h"
#include "mitkDataStorage.h"
#include "vtkTextProperty.h"
#include "vtkCornerAnnotation.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkAnnotatedCubeActor.h"
#include "vtkOrientationMarkerWidget.h"
#include "vtkProperty.h"
// us
#include "mitkGetModuleContext.h"
#include "mitkModule.h"
#include "mitkModuleRegistry.h"
-#include "mitkInformer.h"
+#include "mitkInteractionEventObserver.h"
//##Documentation
//## @brief Example of a NON QT DEPENDENT MITK RENDERING APPLICATION.
mitk::RenderWindow::Pointer mitkWidget1;
mitk::RenderWindow::Pointer mitkWidget2;
mitk::RenderWindow::Pointer mitkWidget3;
mitk::RenderWindow::Pointer mitkWidget4;
mitk::DisplayInteractor::Pointer m_DisplayInteractor;
mitk::CoordinateSupplier::Pointer m_LastLeftClickPositionSupplier;
mitk::GradientBackground::Pointer m_GradientBackground4;
mitk::RenderWindowFrame::Pointer m_RectangleRendering1;
mitk::RenderWindowFrame::Pointer m_RectangleRendering2;
mitk::RenderWindowFrame::Pointer m_RectangleRendering3;
mitk::RenderWindowFrame::Pointer m_RectangleRendering4;
mitk::SliceNavigationController* m_TimeNavigationController = NULL;
mitk::DataStorage::Pointer m_DataStorage;
mitk::DataNode::Pointer m_PlaneNode1;
mitk::DataNode::Pointer m_PlaneNode2;
mitk::DataNode::Pointer m_PlaneNode3;
mitk::DataNode::Pointer m_Node;
void InitializeWindows()
{
// Set default view directions for SNCs
mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
//initialize m_TimeNavigationController: send time via sliceNavigationControllers
m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget1->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget2->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget3->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget4->GetSliceNavigationController(), false);
mitkWidget1->GetSliceNavigationController()->ConnectGeometrySendEvent(mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
//reverse connection between sliceNavigationControllers and m_TimeNavigationController
mitkWidget1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
// Let NavigationControllers listen to GlobalInteraction
mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
gi->AddListener(m_TimeNavigationController);
m_LastLeftClickPositionSupplier = mitk::CoordinateSupplier::New("navigation", NULL);
mitk::GlobalInteraction::GetInstance()->AddListener(m_LastLeftClickPositionSupplier);
m_GradientBackground4 = mitk::GradientBackground::New();
m_GradientBackground4->SetRenderWindow(mitkWidget4->GetVtkRenderWindow());
m_GradientBackground4->SetGradientColors(0.1, 0.1, 0.1, 0.5, 0.5, 0.5);
m_GradientBackground4->Enable();
m_RectangleRendering1 = mitk::RenderWindowFrame::New();
m_RectangleRendering1->SetRenderWindow(mitkWidget1->GetVtkRenderWindow());
m_RectangleRendering1->Enable(1.0, 0.0, 0.0);
m_RectangleRendering2 = mitk::RenderWindowFrame::New();
m_RectangleRendering2->SetRenderWindow(mitkWidget2->GetVtkRenderWindow());
m_RectangleRendering2->Enable(0.0, 1.0, 0.0);
m_RectangleRendering3 = mitk::RenderWindowFrame::New();
m_RectangleRendering3->SetRenderWindow(mitkWidget3->GetVtkRenderWindow());
m_RectangleRendering3->Enable(0.0, 0.0, 1.0);
m_RectangleRendering4 = mitk::RenderWindowFrame::New();
m_RectangleRendering4->SetRenderWindow(mitkWidget4->GetVtkRenderWindow());
m_RectangleRendering4->Enable(1.0, 1.0, 0.0);
}
void AddDisplayPlaneSubTree()
{
// add the displayed planes of the multiwidget to a node to which the subtree
// @a planesSubTree points ...
float white[3] =
{ 1.0f, 1.0f, 1.0f };
mitk::Geometry2DDataMapper2D::Pointer mapper;
mitk::IntProperty::Pointer layer = mitk::IntProperty::New(1000);
// ... of widget 1
m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("layer", layer);
m_PlaneNode1->SetColor(1.0, 0.0, 0.0);
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 2
m_PlaneNode2 = (mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("name", mitk::StringProperty::New("widget2Plane"));
m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("layer", layer);
m_PlaneNode2->SetColor(0.0, 1.0, 0.0);
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 3
m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("name", mitk::StringProperty::New("widget3Plane"));
m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("layer", layer);
m_PlaneNode3->SetColor(0.0, 0.0, 1.0);
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
m_Node = mitk::DataNode::New();
m_Node->SetProperty("name", mitk::StringProperty::New("Widgets"));
m_Node->SetProperty("helper object", mitk::BoolProperty::New(true));
//AddPlanesToDataStorage
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Add(m_Node);
m_DataStorage->Add(m_PlaneNode1, m_Node);
m_DataStorage->Add(m_PlaneNode2, m_Node);
m_DataStorage->Add(m_PlaneNode3, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode1->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(
m_DataStorage, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode2->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(
m_DataStorage, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode3->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(
m_DataStorage, m_Node);
}
}
}
void Fit()
{
vtkRenderer * vtkrenderer;
mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
int w = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkObject::SetGlobalWarningDisplay(w);
}
int main(int argc, char* argv[])
{
if (argc < 2)
{
fprintf(stderr, "Usage: %s [filename1] [filename2] ...\n\n", "");
return 1;
}
// Create a DataStorage
m_DataStorage = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading files
//*************************************************************************
int i;
for (i = 1; i < argc; ++i)
{
// For testing
if (strcmp(argv[i], "-testing") == 0)
continue;
// Create a DataNodeFactory to read a data format supported
// by the DataNodeFactory (many image formats, surface formats, etc.)
mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
const char * filename = argv[i];
try
{
nodeReader->SetFileName(filename);
nodeReader->Update();
// Since the DataNodeFactory directly creates a node,
// use the datastorage to add the read node
mitk::DataNode::Pointer node = nodeReader->GetOutput();
m_DataStorage->Add(node);
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if (image.IsNotNull())
{
// Set the property "volumerendering" to the Boolean value "true"
node->SetProperty("volumerendering", mitk::BoolProperty::New(false));
node->SetProperty("name", mitk::StringProperty::New("testimage"));
node->SetProperty("layer", mitk::IntProperty::New(1));
}
} catch (...)
{
fprintf(stderr, "Could not open file %s \n\n", filename);
exit(2);
}
}
//*************************************************************************
// Part V: Create window and pass the tree to it
//*************************************************************************
// Global Interaction initialize
// legacy because window manager relies still on existence if global interaction
mitk::GlobalInteraction::GetInstance()->Initialize("global");
//mitk::GlobalInteraction::GetInstance()->AddListener(m_DisplayInteractor);
// Create renderwindows
mitkWidget1 = mitk::RenderWindow::New();
mitkWidget2 = mitk::RenderWindow::New();
mitkWidget3 = mitk::RenderWindow::New();
mitkWidget4 = mitk::RenderWindow::New();
// Tell the renderwindow which (part of) the datastorage to render
mitkWidget1->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget2->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget3->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget4->GetRenderer()->SetDataStorage(m_DataStorage);
// Let NavigationControllers listen to GlobalInteraction
mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
gi->AddListener(mitkWidget1->GetSliceNavigationController());
gi->AddListener(mitkWidget2->GetSliceNavigationController());
gi->AddListener(mitkWidget3->GetSliceNavigationController());
gi->AddListener(mitkWidget4->GetSliceNavigationController());
// instantiate display interactor
if (m_DisplayInteractor.IsNull())
{
m_DisplayInteractor = mitk::DisplayInteractor::New();
m_DisplayInteractor->LoadStateMachine("DisplayInteraction.xml");
m_DisplayInteractor->LoadEventConfig("DisplayConfigMITK.xml");
- // Register as listener
+ // Register as listener via micro services
+
mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
- if (context != NULL)
- {
- mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::InformerService>();
- mitk::InformerService* service = dynamic_cast<mitk::InformerService*>(context->GetService(serviceRef));
- if (serviceRef != NULL)
- {
- service->RegisterObserver(m_DisplayInteractor.GetPointer());
- } else {
- MITK_ERROR << "Service not registered.";
- }
- }
- else
- {
- MITK_ERROR<< "Invalid Module context.";
- }
+ context->RegisterService<mitk::InteractionEventObserver>(
+ m_DisplayInteractor.GetPointer());
}
// Use it as a 2D View
mitkWidget1->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget2->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget3->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget4->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
mitkWidget1->SetSize(400, 400);
mitkWidget2->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1]);
mitkWidget2->SetSize(400, 400);
mitkWidget3->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0],
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
mitkWidget3->SetSize(400, 400);
mitkWidget4->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
mitkWidget4->SetSize(400, 400);
InitializeWindows();
AddDisplayPlaneSubTree();
Fit();
// Initialize the RenderWindows
mitk::TimeSlicedGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
m_DataStorage->Print(std::cout);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// reinit the mitkVTKEventProvider;
// this is only necessary once after calling
// ForceImmediateUpdateAll() for the first time
mitkWidget1->ReinitEventProvider();
mitkWidget2->ReinitEventProvider();
mitkWidget3->ReinitEventProvider();
mitkWidget1->GetVtkRenderWindow()->Render();
mitkWidget2->GetVtkRenderWindow()->Render();
mitkWidget3->GetVtkRenderWindow()->Render();
mitkWidget4->GetVtkRenderWindow()->Render();
mitkWidget4->GetVtkRenderWindowInteractor()->Start();
return 0;
}