diff --git a/Core/Code/Controllers/mitkVtkLayerController.cpp b/Core/Code/Controllers/mitkVtkLayerController.cpp index 691a3f8bfc..bca29edba0 100644 --- a/Core/Code/Controllers/mitkVtkLayerController.cpp +++ b/Core/Code/Controllers/mitkVtkLayerController.cpp @@ -1,342 +1,342 @@ /*=================================================================== 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 "mitkVtkLayerController.h" #include #include #include #include #include mitk::VtkLayerController::vtkLayerControllerMapType mitk::VtkLayerController::s_LayerControllerMap; mitk::VtkLayerController* mitk::VtkLayerController::GetInstance(vtkSmartPointer renWin) { for(vtkLayerControllerMapType::iterator mapit = s_LayerControllerMap.begin(); mapit != s_LayerControllerMap.end(); mapit++) { if( (*mapit).first == renWin) return (*mapit).second; } return NULL; } void mitk::VtkLayerController::AddInstance(vtkSmartPointer renWin, vtkSmartPointer mitkSceneRenderer) { // ensure that no vtkRenderWindow is managed twice mitk::VtkLayerController::RemoveInstance(renWin); // instanciate controller, add it to the map mitk::VtkLayerController* ControllerInstance = new mitk::VtkLayerController(renWin); ControllerInstance->InsertSceneRenderer(mitkSceneRenderer); s_LayerControllerMap.insert(vtkLayerControllerMapType::value_type(renWin,ControllerInstance)); } void mitk::VtkLayerController::RemoveInstance(vtkSmartPointer renWin) { vtkLayerControllerMapType::iterator mapit = s_LayerControllerMap.find(renWin); if(mapit != s_LayerControllerMap.end()) { delete mapit->second; s_LayerControllerMap.erase( mapit ); } } mitk::VtkLayerController::VtkLayerController(vtkSmartPointer renderWindow) { m_RenderWindow = renderWindow; m_RenderWindow->Register( NULL ); m_BackgroundRenderers.clear(); m_ForegroundRenderers.clear(); m_SceneRenderers.clear(); } mitk::VtkLayerController::~VtkLayerController() { if ( m_RenderWindow != NULL ) { m_RenderWindow->UnRegister( NULL ); } } /** * Connects a VTK renderer with a vtk renderwindow. The renderer will be rendered in the background. * With forceAbsoluteBackground set true a renderer can be placed at the absolute background of the scene. * Multiple calls with forceAbsoluteBackground set true will set the latest registered renderer as background. */ void mitk::VtkLayerController::InsertBackgroundRenderer(vtkSmartPointer renderer, bool forceAbsoluteBackground) { if(renderer == NULL) return; // Remove renderer if it already exists RemoveRenderer(renderer); if(forceAbsoluteBackground) { RendererVectorType::iterator it = m_BackgroundRenderers.begin(); m_BackgroundRenderers.insert(it,renderer); } else m_BackgroundRenderers.push_back(renderer); UpdateLayers(); } /** * Connects a VTK renderer with a vtk renderwindow. The renderer will be rendered in the foreground. * With forceAbsoluteBackground set true a renderer can be placed at the absolute foreground of the scene. * Multiple calls with forceAbsoluteForeground set true will set the latest registered renderer as foreground. */ void mitk::VtkLayerController::InsertForegroundRenderer(vtkSmartPointer renderer, bool forceAbsoluteForeground) { if(renderer == NULL) return; // Remove renderer if it already exists RemoveRenderer(renderer); if(forceAbsoluteForeground) { RendererVectorType::iterator it = m_ForegroundRenderers.begin(); m_ForegroundRenderers.insert(it,renderer); } else m_ForegroundRenderers.push_back(renderer); UpdateLayers(); } /** * Returns the Scene Renderer */ vtkSmartPointer mitk::VtkLayerController::GetSceneRenderer() { if(m_SceneRenderers.size() > 0) { RendererVectorType::iterator it = m_SceneRenderers.begin(); return (*it); } else return NULL; } /** * Connects a VTK renderer with a vtk renderwindow. The renderer will be rendered between background renderers and * foreground renderers. */ void mitk::VtkLayerController::InsertSceneRenderer(vtkSmartPointer renderer) { if(renderer == NULL) return; // Remove renderer if it already exists RemoveRenderer(renderer); m_SceneRenderers.push_back(renderer); UpdateLayers(); } /** * A renderer which has been inserted via a insert... function can be removed from the vtkRenderWindow with * RemoveRenderer. */ void mitk::VtkLayerController::RemoveRenderer(vtkSmartPointer renderer) { RendererVectorType::iterator it; // background layers if(m_BackgroundRenderers.size() > 0) { it = std::find(m_BackgroundRenderers.begin(),m_BackgroundRenderers.end(),renderer); if(it != m_BackgroundRenderers.end()) { m_BackgroundRenderers.erase(it); UpdateLayers(); return; } } // scene layers if(m_SceneRenderers.size() > 0) { it = std::find(m_SceneRenderers.begin(),m_SceneRenderers.end(),renderer); if(it != m_SceneRenderers.end()) { m_SceneRenderers.erase(it); UpdateLayers(); return; } } // foreground layers if(m_ForegroundRenderers.size() > 0 ) { it = std::find(m_ForegroundRenderers.begin(),m_ForegroundRenderers.end(),renderer); if(it != m_ForegroundRenderers.end()) { m_ForegroundRenderers.erase(it); UpdateLayers(); return; } } } /** * Connects a VtkRenderWindow with the layer controller. */ void mitk::VtkLayerController::SetRenderWindow(vtkSmartPointer renwin) { if(renwin != NULL) { RendererVectorType::iterator it; // Tell all renderers that there is a new renderwindow for(it = m_BackgroundRenderers.begin(); it != m_BackgroundRenderers.end(); it++) { (*it)->SetRenderWindow(renwin); } for(it = m_SceneRenderers.begin(); it != m_SceneRenderers.end(); it++) { (*it)->SetRenderWindow(renwin); } for(it = m_ForegroundRenderers.begin(); it != m_ForegroundRenderers.end(); it++) { (*it)->SetRenderWindow(renwin); } // Set the new RenderWindow m_RenderWindow = renwin; } // Now sort renderers and add them to the renderwindow UpdateLayers(); } /** * Returns true if a renderer has been inserted */ bool mitk::VtkLayerController::IsRendererInserted(vtkSmartPointer renderer) { RendererVectorType::iterator it; // background layers if(m_BackgroundRenderers.size() > 0) { it = std::find(m_BackgroundRenderers.begin(),m_BackgroundRenderers.end(),renderer); if ( it != m_BackgroundRenderers.end() ) { return true; } } // scene layers if(m_SceneRenderers.size() > 0) { it = std::find(m_SceneRenderers.begin(),m_SceneRenderers.end(),renderer); if ( it != m_SceneRenderers.end() ) { return true; } } // foreground layers if(m_ForegroundRenderers.size() > 0 ) { it = std::find(m_ForegroundRenderers.begin(),m_ForegroundRenderers.end(),renderer); if ( it != m_ForegroundRenderers.end() ) { return true; } } return false; } /** * Internally used to sort all registered renderers and to connect the with the vtkRenderWindow. * Mention that VTK Version 5 and above is rendering higher numbers in the background and VTK * Verison < 5 in the foreground. */ void mitk::VtkLayerController::UpdateLayers() { // Remove all Renderers from renderwindow vtkSmartPointer v = m_RenderWindow->GetRenderers(); v->RemoveAllItems(); unsigned int numberOfLayers = static_cast(m_BackgroundRenderers.size() + m_SceneRenderers.size() + m_ForegroundRenderers.size()); int currentLayerNumber; bool traverseUpwards; currentLayerNumber = 0; traverseUpwards = true; m_RenderWindow->SetNumberOfLayers(numberOfLayers); RendererVectorType::iterator it; // assign a layer number for the backround renderers for(it = m_BackgroundRenderers.begin(); it != m_BackgroundRenderers.end(); it++) { (*it)->SetRenderWindow(m_RenderWindow); (*it)->SetLayer(currentLayerNumber); m_RenderWindow->AddRenderer((*it)); if(traverseUpwards) currentLayerNumber++; else currentLayerNumber--; } // assign a layer number for the scene renderers for(it = m_SceneRenderers.begin(); it != m_SceneRenderers.end(); it++) { (*it)->SetRenderWindow(m_RenderWindow); (*it)->SetLayer(currentLayerNumber); m_RenderWindow->AddRenderer((*it)); if(traverseUpwards) currentLayerNumber++; else currentLayerNumber--; } // assign a layer number for the foreground renderers for(it = m_ForegroundRenderers.begin(); it != m_ForegroundRenderers.end(); it++) { (*it)->SetRenderWindow(m_RenderWindow); (*it)->SetLayer(currentLayerNumber); m_RenderWindow->AddRenderer((*it)); if(traverseUpwards) currentLayerNumber++; else currentLayerNumber--; } } /** * Returns the number of renderers in the renderwindow. */ unsigned int mitk::VtkLayerController::GetNumberOfRenderers() { return static_cast(m_BackgroundRenderers.size() + m_SceneRenderers.size() + m_ForegroundRenderers.size()); } void mitk::VtkLayerController::SetEraseForAllRenderers(int i) { this->m_RenderWindow->SetErase(i); RendererVectorType::iterator it; for(it = m_BackgroundRenderers.begin(); it != m_BackgroundRenderers.end(); it++) (*it)->SetErase(i); for(it = m_SceneRenderers.begin(); it != m_SceneRenderers.end(); it++) - (*it)->SetErase(i); + (*it)->SetErase(i); for(it = m_ForegroundRenderers.begin(); it != m_ForegroundRenderers.end(); it++) - (*it)->SetErase(i); + (*it)->SetErase(i); } diff --git a/Core/Code/Controllers/mitkVtkLayerController.h b/Core/Code/Controllers/mitkVtkLayerController.h index 3f86f28cd5..6951a06baa 100644 --- a/Core/Code/Controllers/mitkVtkLayerController.h +++ b/Core/Code/Controllers/mitkVtkLayerController.h @@ -1,130 +1,127 @@ /*=================================================================== 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 mitkVtkLayerController_h #define mitkVtkLayerController_h #include #include #include #include class vtkRenderWindow; class vtkRenderer; namespace mitk { #ifdef _MSC_VER # pragma warning(push) # pragma warning(disable: 4251) #endif /** * Manages the VTK layer hierarchy * of a vtkRenderWindow. * For simple access the layers are divided into three * main groups: background, scene and foreground layers. * Renderers can be registered via the insert... functions and * removed via the RemoveRenderer function. */ class MITK_CORE_EXPORT VtkLayerController { - public: - static VtkLayerController* GetInstance(vtkSmartPointer renWin); - static void AddInstance(vtkSmartPointer renWin, vtkSmartPointer mitkSceneRenderer); - static void RemoveInstance(vtkSmartPointer renWin); +public: + static VtkLayerController* GetInstance(vtkSmartPointer renWin); + static void AddInstance(vtkSmartPointer renWin, vtkSmartPointer mitkSceneRenderer); + static void RemoveInstance(vtkSmartPointer renWin); - VtkLayerController(vtkSmartPointer renderWindow); - virtual ~VtkLayerController(); + VtkLayerController(vtkSmartPointer renderWindow); + virtual ~VtkLayerController(); - /** + /** * Returns the current vtkRenderer of the Scene */ - vtkSmartPointer GetSceneRenderer(); + vtkSmartPointer GetSceneRenderer(); - /** + /** * Connects a VTK renderer with a vtk renderwindow. The renderer will be rendered in the background. * With forceAbsoluteBackground set true a renderer can be placed at the absolute background of the scene. * Multiple calls with forceAbsoluteBackground set true will set the latest registered renderer as background. */ - void InsertBackgroundRenderer(vtkSmartPointer renderer, bool forceAbsoluteBackground); + void InsertBackgroundRenderer(vtkSmartPointer renderer, bool forceAbsoluteBackground); - /** + /** * Connects a VTK renderer with a vtk renderwindow. The renderer will be rendered in the foreground. * With forceAbsoluteBackground set true a renderer can be placed at the absolute foreground of the scene. * Multiple calls with forceAbsoluteForeground set true will set the latest registered renderer as foreground. */ - void InsertForegroundRenderer(vtkSmartPointer renderer, bool forceAbsoluteForeground); + void InsertForegroundRenderer(vtkSmartPointer renderer, bool forceAbsoluteForeground); - /** + /** * Connects a VTK renderer with a vtk renderwindow. The renderer will be rendered between background renderers and * foreground renderers. */ - void InsertSceneRenderer(vtkSmartPointer renderer); + void InsertSceneRenderer(vtkSmartPointer renderer); - /** + /** * Connects a VtkRenderWindow with the layer controller. */ - void SetRenderWindow(vtkSmartPointer renwin); + void SetRenderWindow(vtkSmartPointer renwin); - /** + /** * A renderer which has been inserted via a insert... function can be removed from the vtkRenderWindow with * RemoveRenderer. */ - void RemoveRenderer(vtkSmartPointer renderer); + void RemoveRenderer(vtkSmartPointer renderer); - /** + /** * Returns true if a renderer has been inserted */ - bool IsRendererInserted(vtkSmartPointer renderer); + bool IsRendererInserted(vtkSmartPointer renderer); - /** + /** * Returns the number of renderers in the renderwindow. */ - unsigned int GetNumberOfRenderers(); + unsigned int GetNumberOfRenderers(); - void SetEraseForAllRenderers(int i); - protected: - vtkSmartPointer m_RenderWindow; + void SetEraseForAllRenderers(int i); +protected: + vtkSmartPointer m_RenderWindow; - private: +private: - /** + /** * Internally used to sort all registered renderers and to connect the with the vtkRenderWindow. * Mention that VTK Version 5 and above is rendering higher numbers in the background and VTK * Verison < 5 in the foreground. */ - void UpdateLayers(); + void UpdateLayers(); - // Layer Management - typedef std::vector< vtkSmartPointer > RendererVectorType; - RendererVectorType m_BackgroundRenderers; - RendererVectorType m_SceneRenderers; - RendererVectorType m_ForegroundRenderers; + // Layer Management + typedef std::vector< vtkSmartPointer > RendererVectorType; + RendererVectorType m_BackgroundRenderers; + RendererVectorType m_SceneRenderers; + RendererVectorType m_ForegroundRenderers; - typedef std::map,mitk::VtkLayerController*> vtkLayerControllerMapType; - static vtkLayerControllerMapType s_LayerControllerMap; + typedef std::map,mitk::VtkLayerController*> vtkLayerControllerMapType; + static vtkLayerControllerMapType s_LayerControllerMap; }; - #ifdef _MSC_VER # pragma warning(pop) #endif - } // Namespace MITK - #endif /* mitkVtkLayerController_h */ diff --git a/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.cpp b/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.cpp index 826e0442e5..adc1e6a3a7 100644 --- a/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.cpp +++ b/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.cpp @@ -1,407 +1,403 @@ /*=================================================================== 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 "mitkPlaneGeometryDataMapper2D.h" //mitk includes -#include "mitkDataNode.h" -#include "mitkProperties.h" #include "mitkVtkPropRenderer.h" -#include "mitkPointSet.h" -#include "mitkPlaneGeometry.h" -#include "mitkPlaneOrientationProperty.h" -#include "mitkLine.h" - -//vtk includes -#include - +#include +#include +#include +#include +#include +#include #include #include #include -#include + +//vtk includes +#include #include #include #include #include #include -#include -#include mitk::PlaneGeometryDataMapper2D::AllInstancesContainer mitk::PlaneGeometryDataMapper2D::s_AllInstances; -// input for this mapper ( = point set) +// input for this mapper ( = PlaneGeometryData) const mitk::PlaneGeometryData* mitk::PlaneGeometryDataMapper2D::GetInput() const { return static_cast< PlaneGeometryData * >(GetDataNode()->GetData()); } // constructor PlaneGeometryDataMapper2D mitk::PlaneGeometryDataMapper2D::PlaneGeometryDataMapper2D() -: m_RenderOrientationArrows( false ), - m_ArrowOrientationPositive( true ), - m_DepthValue(1.0f) + : m_RenderOrientationArrows( false ), + m_ArrowOrientationPositive( true ), + m_DepthValue(1.0f) { s_AllInstances.insert(this); } // destructor mitk::PlaneGeometryDataMapper2D::~PlaneGeometryDataMapper2D() { s_AllInstances.erase(this); } // returns propassembly vtkProp* mitk::PlaneGeometryDataMapper2D::GetVtkProp(mitk::BaseRenderer * renderer) { LocalStorage *ls = m_LSH.GetLocalStorage(renderer); return ls->m_CrosshairAssembly; } void mitk::PlaneGeometryDataMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer ) { BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer); // The PlaneGeometryDataMapper2D mapper is special in that the rendering of // OTHER PlaneGeometryDatas affects how we render THIS PlaneGeometryData // (for the gap at the point where they intersect). A change in any of the // other PlaneGeometryData nodes could mean that we render ourself // differently, so we check for that here. bool generateDataRequired = false; for (AllInstancesContainer::iterator it = s_AllInstances.begin(); it != s_AllInstances.end(); ++it) { generateDataRequired = ls->IsGenerateDataRequired(renderer, this, (*it)->GetDataNode()); if (generateDataRequired) break; } -// if (!generateDataRequired) return; + // if (!generateDataRequired) return; ls->UpdateGenerateDataTime(); // Collect all other PlaneGeometryDatas that are being mapped by this mapper m_OtherPlaneGeometries.clear(); for (AllInstancesContainer::iterator it = s_AllInstances.begin(); it != s_AllInstances.end(); ++it) { Self *otherInstance = *it; // Skip ourself if (otherInstance == this) continue; mitk::DataNode *otherNode = otherInstance->GetDataNode(); if (!otherNode) continue; // Skip other PlaneGeometryData nodes that are not visible on this renderer if (!otherNode->IsVisible(renderer)) continue; PlaneGeometryData* otherData = dynamic_cast(otherNode->GetData()); if (!otherData) continue; PlaneGeometry* otherGeometry = dynamic_cast(otherData->GetPlaneGeometry()); if ( otherGeometry && !dynamic_cast(otherData->GetPlaneGeometry()) ) { m_OtherPlaneGeometries.push_back(otherNode); } } CreateVtkCrosshair(renderer); ApplyAllProperties(renderer); } void mitk::PlaneGeometryDataMapper2D::CreateVtkCrosshair(mitk::BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if(!visible) return; PlaneGeometryData::Pointer input = const_cast< PlaneGeometryData * >(this->GetInput()); mitk::DataNode* geometryDataNode = renderer->GetCurrentWorldPlaneGeometryNode(); const PlaneGeometryData* rendererWorldPlaneGeometryData = dynamic_cast< PlaneGeometryData * >(geometryDataNode->GetData()); // intersecting with ourself? if ( input.IsNull() || input.GetPointer() == rendererWorldPlaneGeometryData) { return; // do rectangle stuff! } const PlaneGeometry *inputPlaneGeometry = dynamic_cast< const PlaneGeometry * >( input->GetPlaneGeometry() ); const PlaneGeometry* worldPlaneGeometry = dynamic_cast< const PlaneGeometry* >( - rendererWorldPlaneGeometryData->GetPlaneGeometry() ); + rendererWorldPlaneGeometryData->GetPlaneGeometry() ); if ( worldPlaneGeometry && dynamic_cast(worldPlaneGeometry)==NULL && inputPlaneGeometry && dynamic_cast(input->GetPlaneGeometry() )==NULL && inputPlaneGeometry->GetReferenceGeometry() ) { const BaseGeometry *referenceGeometry = inputPlaneGeometry->GetReferenceGeometry(); // calculate intersection of the plane data with the border of the // world geometry rectangle Point3D point1, point2; Line3D crossLine; // Calculate the intersection line of the input plane with the world plane if ( worldPlaneGeometry->IntersectionLine( inputPlaneGeometry, crossLine ) ) { Point3D boundingBoxMin, boundingBoxMax; boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum(); boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum(); referenceGeometry->IndexToWorld(boundingBoxMin,boundingBoxMin); referenceGeometry->IndexToWorld(boundingBoxMax,boundingBoxMax); // Then, clip this line with the (transformed) bounding box of the // reference geometry. crossLine.BoxLineIntersection( - boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2], - boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2], - crossLine.GetPoint(), crossLine.GetDirection(), - point1, point2 ); + boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2], + boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2], + crossLine.GetPoint(), crossLine.GetDirection(), + point1, point2 ); crossLine.SetPoints(point1,point2); vtkSmartPointer lines = vtkSmartPointer::New(); vtkSmartPointer points = vtkSmartPointer::New(); vtkSmartPointer linesPolyData = vtkSmartPointer::New(); // Now iterate through all other lines displayed in this window and // calculate the positions of intersection with the line to be // rendered; these positions will be stored in lineParams to form a // gap afterwards. NodesVectorType::iterator otherPlanesIt = m_OtherPlaneGeometries.begin(); NodesVectorType::iterator otherPlanesEnd = m_OtherPlaneGeometries.end(); std::vector intersections; intersections.push_back(point1); otherPlanesIt = m_OtherPlaneGeometries.begin(); int gapsize = 32; this->GetDataNode()->GetPropertyValue( "Crosshair.Gap Size",gapsize, NULL ); ScalarType lineLength = point1.EuclideanDistanceTo(point2); DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry(); ScalarType gapinmm = gapsize * displayGeometry->GetScaleFactorMMPerDisplayUnit(); float gapSizeParam = gapinmm / lineLength; while ( otherPlanesIt != otherPlanesEnd ) { PlaneGeometry *otherPlane = static_cast< PlaneGeometry * >( - static_cast< PlaneGeometryData * >((*otherPlanesIt)->GetData() )->GetPlaneGeometry() ); + static_cast< PlaneGeometryData * >((*otherPlanesIt)->GetData() )->GetPlaneGeometry() ); if (otherPlane != inputPlaneGeometry && otherPlane != worldPlaneGeometry) { Point3D planeIntersection; otherPlane->IntersectionPoint(crossLine,planeIntersection); ScalarType sectionLength = point1.EuclideanDistanceTo(planeIntersection); ScalarType lineValue = sectionLength/lineLength; if(lineValue-gapSizeParam > 0.0) intersections.push_back(crossLine.GetPoint(lineValue-gapSizeParam)); else intersections.pop_back(); if(lineValue+gapSizeParam < 1.0) intersections.push_back(crossLine.GetPoint(lineValue+gapSizeParam)); } ++otherPlanesIt; } if(intersections.size()%2 == 1) intersections.push_back(point2); if(intersections.empty()) { this->DrawLine(point1,point2,lines,points); } else for(unsigned int i = 0 ; i< intersections.size()-1 ; i+=2) { this->DrawLine(intersections[i],intersections[i+1],lines,points); } // Add the points to the dataset linesPolyData->SetPoints(points); // Add the lines to the dataset linesPolyData->SetLines(lines); // Visualize vtkSmartPointer mapper = vtkSmartPointer::New(); mapper->SetInputData(linesPolyData); LocalStorage* ls = m_LSH.GetLocalStorage(renderer); ls->m_CrosshairActor->SetMapper(mapper); // Determine if we should draw the area covered by the thick slicing, default is false. // This will also show the area of slices that do not have thick slice mode enabled bool showAreaOfThickSlicing = false; GetDataNode()->GetBoolProperty( "reslice.thickslices.showarea", showAreaOfThickSlicing ); // get the normal of the inputPlaneGeometry Vector3D normal = inputPlaneGeometry->GetNormal(); // determine the pixelSpacing in that direction double thickSliceDistance = SlicedGeometry3D::CalculateSpacing( referenceGeometry->GetSpacing(), normal ); IntProperty *intProperty=0; if( GetDataNode()->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty ) - thickSliceDistance *= intProperty->GetValue()+0.5; + thickSliceDistance *= intProperty->GetValue()+0.5; else - showAreaOfThickSlicing = false; + showAreaOfThickSlicing = false; // not the nicest place to do it, but we have the width of the visible bloc in MM here // so we store it in this fancy property GetDataNode()->SetFloatProperty( "reslice.thickslices.sizeinmm", thickSliceDistance*2 ); if ( showAreaOfThickSlicing ) { vtkSmartPointer helperlines = vtkSmartPointer::New(); vtkSmartPointer helperlinesPolyData = vtkSmartPointer::New(); // vectorToHelperLine defines how to reach the helperLine from the mainLine Vector3D vectorToHelperLine; vectorToHelperLine = normal; vectorToHelperLine.Normalize(); // got the right direction, so we multiply the width vectorToHelperLine *= thickSliceDistance; this->DrawLine(point1 - vectorToHelperLine, point2 - vectorToHelperLine,helperlines,points); this->DrawLine(point1 + vectorToHelperLine, point2 + vectorToHelperLine,helperlines,points); // Add the points to the dataset helperlinesPolyData->SetPoints(points); // Add the lines to the dataset helperlinesPolyData->SetLines(helperlines); // Visualize vtkSmartPointer helperLinesmapper = vtkSmartPointer::New(); helperLinesmapper->SetInputData(helperlinesPolyData); ls->m_CrosshairActor->GetProperty()->SetLineStipplePattern(0xf0f0); ls->m_CrosshairActor->GetProperty()->SetLineStippleRepeatFactor(1); ls->m_CrosshairHelperLineActor->SetMapper(helperLinesmapper); ls->m_CrosshairAssembly->AddPart(ls->m_CrosshairHelperLineActor); } else { ls->m_CrosshairAssembly->RemovePart(ls->m_CrosshairHelperLineActor); ls->m_CrosshairActor->GetProperty()->SetLineStipplePattern(0xffff); } } } } void mitk::PlaneGeometryDataMapper2D::DrawLine( mitk::Point3D p0,mitk::Point3D p1, vtkCellArray* lines, vtkPoints* points ) { vtkIdType pidStart = points->InsertNextPoint(p0[0],p0[1], p0[2]); vtkIdType pidEnd = points->InsertNextPoint(p1[0],p1[1], p1[2]); vtkSmartPointer lineVtk = vtkSmartPointer::New(); lineVtk->GetPointIds()->SetId(0,pidStart); lineVtk->GetPointIds()->SetId(1,pidEnd); lines->InsertNextCell(lineVtk); } int mitk::PlaneGeometryDataMapper2D::DetermineThickSliceMode( DataNode * dn, int &thickSlicesNum ) { int thickSlicesMode = 0; // determine the state and the extend of the thick-slice mode mitk::ResliceMethodProperty *resliceMethodEnumProperty=0; if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty ) thickSlicesMode = resliceMethodEnumProperty->GetValueAsId(); IntProperty *intProperty=0; if( dn->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty ) { thickSlicesNum = intProperty->GetValue(); if(thickSlicesNum < 1) thickSlicesNum=0; if(thickSlicesNum > 10) thickSlicesNum=10; } if ( thickSlicesMode == 0 ) thickSlicesNum = 0; return thickSlicesMode; } void mitk::PlaneGeometryDataMapper2D::ApplyAllProperties( BaseRenderer *renderer ) { LocalStorage *ls = m_LSH.GetLocalStorage(renderer); Superclass::ApplyColorAndOpacityProperties(renderer, ls->m_CrosshairActor); Superclass::ApplyColorAndOpacityProperties(renderer, ls->m_CrosshairHelperLineActor); PlaneOrientationProperty* decorationProperty; this->GetDataNode()->GetProperty( decorationProperty, "decoration", renderer ); if ( decorationProperty != NULL ) { if ( decorationProperty->GetPlaneDecoration() == - PlaneOrientationProperty::PLANE_DECORATION_POSITIVE_ORIENTATION ) + PlaneOrientationProperty::PLANE_DECORATION_POSITIVE_ORIENTATION ) { m_RenderOrientationArrows = true; m_ArrowOrientationPositive = true; } else if ( decorationProperty->GetPlaneDecoration() == - PlaneOrientationProperty::PLANE_DECORATION_NEGATIVE_ORIENTATION ) + PlaneOrientationProperty::PLANE_DECORATION_NEGATIVE_ORIENTATION ) { m_RenderOrientationArrows = true; m_ArrowOrientationPositive = false; } else { m_RenderOrientationArrows = false; } } } void mitk::PlaneGeometryDataMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) { node->AddProperty( "Line width", mitk::IntProperty::New(2), renderer, overwrite ); node->AddProperty( "Crosshair.Gap Size", mitk::IntProperty::New(32), renderer, overwrite ); node->AddProperty( "decoration", mitk::PlaneOrientationProperty ::New(PlaneOrientationProperty::PLANE_DECORATION_NONE), renderer, overwrite ); Superclass::SetDefaultProperties(node, renderer, overwrite); } -void mitk::PlaneGeometryDataMapper2D::UpdateVtkTransform(mitk::BaseRenderer *renderer) +void mitk::PlaneGeometryDataMapper2D::UpdateVtkTransform(mitk::BaseRenderer* /*renderer*/) { } mitk::PlaneGeometryDataMapper2D::LocalStorage::LocalStorage() { m_CrosshairAssembly = vtkSmartPointer ::New(); m_CrosshairActor = vtkSmartPointer ::New(); m_CrosshairHelperLineActor = vtkSmartPointer ::New(); m_CrosshairAssembly->AddPart(m_CrosshairActor); m_CrosshairAssembly->AddPart(m_CrosshairHelperLineActor); } // destructor LocalStorage mitk::PlaneGeometryDataMapper2D::LocalStorage::~LocalStorage() { } diff --git a/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.h b/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.h index e5622b601f..921547dbbe 100644 --- a/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.h +++ b/Core/Code/Rendering/mitkPlaneGeometryDataMapper2D.h @@ -1,137 +1,125 @@ /*=================================================================== 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 MITKPlaneGeometryDataMapper2D_H_HEADER_INCLUDED_C1902626 -#define MITKPlaneGeometryDataMapper2D_H_HEADER_INCLUDED_C1902626 +#ifndef mitkPlaneGeometryDataMapper2D_h +#define mitkPlaneGeometryDataMapper2D_h - -#include #include "mitkVtkMapper.h" #include "mitkBaseRenderer.h" -#include "mitkPointSetShapeProperty.h" +#include +#include #include -#include "mitkWeakPointer.h" class vtkActor; class vtkPropAssembly; -class vtkPolyData; -class vtkPolyDataMapper; -class vtkGlyphSource2D; -class vtkGlyph3D; class vtkFloatArray; class vtkCellArray; - namespace mitk { - class PointSet; - - /** - * @brief Vtk-based 2D mapper +/** + * @brief Vtk-based 2D mapper for rendering a crosshair with the plane geometry. * @ingroup Mapper */ - class MITK_CORE_EXPORT PlaneGeometryDataMapper2D : public VtkMapper - { - public: - mitkClassMacro(PlaneGeometryDataMapper2D, VtkMapper); +class MITK_CORE_EXPORT PlaneGeometryDataMapper2D : public VtkMapper +{ +public: + mitkClassMacro(PlaneGeometryDataMapper2D, VtkMapper); - itkFactorylessNewMacro(Self) - itkCloneMacro(Self) + itkFactorylessNewMacro(Self) + itkCloneMacro(Self) - virtual const mitk::PlaneGeometryData* GetInput() const; + virtual const mitk::PlaneGeometryData* GetInput() const; - /** \brief returns the a prop assembly */ - virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer); + /** \brief returns the a prop assembly */ + virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer); - /** Applies properties specific to this mapper */ - virtual void ApplyAllProperties( BaseRenderer *renderer ); + /** Applies properties specific to this mapper */ + virtual void ApplyAllProperties( BaseRenderer *renderer ); - virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer); + virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer); - /** \brief set the default properties for this mapper */ - static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false); + /** \brief set the default properties for this mapper */ + static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false); - /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */ - class LocalStorage : public mitk::Mapper::BaseLocalStorage - { + /** \brief Internal class holding the mapper, actor, etc. for each of the 3 2D render windows */ + class LocalStorage : public mitk::Mapper::BaseLocalStorage + { - public: + public: - /* constructor */ - LocalStorage(); + /* constructor */ + LocalStorage(); - /* destructor */ - ~LocalStorage(); + /* destructor */ + ~LocalStorage(); - // actor - vtkSmartPointer m_CrosshairActor; - vtkSmartPointer m_CrosshairHelperLineActor; - vtkSmartPointer m_CrosshairAssembly; + // actor + vtkSmartPointer m_CrosshairActor; + vtkSmartPointer m_CrosshairHelperLineActor; + vtkSmartPointer m_CrosshairAssembly; - }; + }; - /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */ - mitk::LocalStorageHandler m_LSH; + /** \brief The LocalStorageHandler holds all (three) LocalStorages for the three 2D render windows. */ + mitk::LocalStorageHandler m_LSH; - protected: +protected: - /* constructor */ - PlaneGeometryDataMapper2D(); + /* constructor */ + PlaneGeometryDataMapper2D(); - /* destructor */ - virtual ~PlaneGeometryDataMapper2D(); + /* destructor */ + virtual ~PlaneGeometryDataMapper2D(); - /* \brief Applies the color and opacity properties and calls CreateVTKRenderObjects */ - virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer); + /* \brief Applies the color and opacity properties and calls CreateVTKRenderObjects */ + virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer); - void CreateVtkCrosshair(BaseRenderer *renderer); + void CreateVtkCrosshair(BaseRenderer *renderer); - /** + /** * \brief Returns the thick slice mode for the given datanode. * * This method returns the value of the 'reslice.thickslices' property for * the given datanode. * '0': thick slice mode disabled * '1': thick slice mode enabled * * The variable 'thickSlicesNum' contains the value of the 'reslice.thickslices.num' * property that defines how many slices are shown at once. */ - int DetermineThickSliceMode( DataNode * dn, int &thickSlicesNum ); - - void DrawLine(Point3D p0, Point3D p1, - vtkCellArray *lines, - vtkPoints *points); + int DetermineThickSliceMode( DataNode * dn, int &thickSlicesNum ); - // member variables holding the current value of the properties used in this mapper - typedef std::vector NodesVectorType; - NodesVectorType m_OtherPlaneGeometries; + void DrawLine(Point3D p0, Point3D p1, + vtkCellArray *lines, + vtkPoints *points); - typedef std::set AllInstancesContainer; - static AllInstancesContainer s_AllInstances; + // member variables holding the current value of the properties used in this mapper + typedef std::vector NodesVectorType; + NodesVectorType m_OtherPlaneGeometries; - bool m_RenderOrientationArrows; - bool m_ArrowOrientationPositive; - mitk::ScalarType m_DepthValue; - - }; + typedef std::set AllInstancesContainer; + static AllInstancesContainer s_AllInstances; + bool m_RenderOrientationArrows; + bool m_ArrowOrientationPositive; + mitk::ScalarType m_DepthValue; +}; } // namespace mitk - -#endif /* MITKPlaneGeometryDataMapper2D_H_HEADER_INCLUDED_C1902626 */ +#endif /* mitkPlaneGeometryDataMapper2D_h */ diff --git a/Core/Code/Rendering/mitkRenderWindowFrame.cpp b/Core/Code/Rendering/mitkRenderWindowFrame.cpp index 4b6bf77db3..80a8432435 100644 --- a/Core/Code/Rendering/mitkRenderWindowFrame.cpp +++ b/Core/Code/Rendering/mitkRenderWindowFrame.cpp @@ -1,111 +1,110 @@ /*=================================================================== 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 "mitkRenderWindowFrame.h" - #include "mitkVtkLayerController.h" #include "vtkMitkRectangleProp.h" #include #include mitk::RenderWindowFrame::RenderWindowFrame() { m_RenderWindow = NULL; m_RectangleRenderer = vtkSmartPointer::New(); m_IsEnabled = false; } mitk::RenderWindowFrame::~RenderWindowFrame() { if ( m_RenderWindow != NULL ) if ( this->IsEnabled() ) this->Disable(); } /** * Sets the renderwindow, in which the text * will be shown. Make sure, you have called this function * before calling Enable() */ void mitk::RenderWindowFrame::SetRenderWindow(vtkSmartPointer renderWindow ) { m_RenderWindow = renderWindow; } /** * Returns the vtkRenderWindow, which is used * for displaying the text */ vtkSmartPointer mitk::RenderWindowFrame::GetRenderWindow() { return m_RenderWindow; } /** * Returns the renderer responsible for * rendering the text into the * vtkRenderWindow */ vtkSmartPointer mitk::RenderWindowFrame::GetVtkRenderer() { return m_RectangleRenderer; } /** * Disables drawing of the text label collection. * If you want to enable it, call the Enable() function. */ void mitk::RenderWindowFrame::Disable() { if ( this->IsEnabled()) { m_RectangleRenderer->EraseOn(); mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_RectangleRenderer); m_IsEnabled = false; } } /** * Enables drawing of the text label collection. * If you want to disable it, call the Disable() function. */ void mitk::RenderWindowFrame::Enable(float col1, float col2, float col3) { vtkSmartPointer rect = vtkSmartPointer::New(); rect->SetRenderWindow(m_RenderWindow); rect->SetColor(col1, col2, col3); m_RectangleRenderer->AddActor(rect); if(!mitk::VtkLayerController::GetInstance(m_RenderWindow)->IsRendererInserted( m_RectangleRenderer )) { m_RectangleRenderer->EraseOff(); m_RectangleRenderer->SetInteractive(0); mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertForegroundRenderer(m_RectangleRenderer,true); m_IsEnabled = true; } } /** * Checks, if the text is currently * enabled (visible) */ bool mitk::RenderWindowFrame::IsEnabled() { return m_IsEnabled; } diff --git a/Core/Code/Rendering/mitkRenderWindowFrame.h b/Core/Code/Rendering/mitkRenderWindowFrame.h index 0fe704f0b8..3ff5b46331 100644 --- a/Core/Code/Rendering/mitkRenderWindowFrame.h +++ b/Core/Code/Rendering/mitkRenderWindowFrame.h @@ -1,104 +1,101 @@ /*=================================================================== 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 mitkRenderWindowFrame_h #define mitkRenderWindowFrame_h #include #include #include -#include +#include class vtkRenderer; class vtkRenderWindow; - namespace mitk { /** * This is a simple class for rendering colored rectangles * at the boarders of vtkRenderWindows. * The rectangle rendering itself is performed by means of a * vtkProp (vtkMitkRectangleProp). * This class instantiates the vtkProp and a corresponding vtkRenderer instance. */ class MITK_CORE_EXPORT RenderWindowFrame : public itk::Object { public: mitkClassMacro( RenderWindowFrame, itk::Object ); itkFactorylessNewMacro(Self) itkCloneMacro(Self) /** * Sets the renderwindow, in which colored rectangle boarders will be shown. * Make sure, you have called this function * before calling Enable() */ virtual void SetRenderWindow( vtkSmartPointer renderWindow ); /** * Enables drawing of the colored rectangle. * If you want to disable it, call the Disable() function. */ virtual void Enable(float col1, float col2, float col3); /** * Disables drawing of the colored rectangle. * If you want to enable it, call the Enable() function. */ virtual void Disable(); /** * Checks, if the text is currently * enabled (visible) */ virtual bool IsEnabled(); /** * Returns the vtkRenderWindow, which is used * for displaying the text */ virtual vtkSmartPointer GetRenderWindow(); /** * Returns the renderer responsible for * rendering the text into the * vtkRenderWindow */ virtual vtkSmartPointer GetVtkRenderer(); protected: /** * Constructor */ RenderWindowFrame(); /** * Destructor */ ~RenderWindowFrame(); vtkSmartPointer m_RenderWindow; vtkSmartPointer m_RectangleRenderer; bool m_IsEnabled; - }; - } //end of namespace mitk #endif //mitkRenderWindowFrame_h diff --git a/Core/Code/Rendering/vtkMitkRectangleProp.h b/Core/Code/Rendering/vtkMitkRectangleProp.h index a67200f532..642390d929 100644 --- a/Core/Code/Rendering/vtkMitkRectangleProp.h +++ b/Core/Code/Rendering/vtkMitkRectangleProp.h @@ -1,95 +1,95 @@ /*=================================================================== 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 vtkMitkRectangleProp_h #define vtkMitkRectangleProp_h #include #include #include #include class vtkActor2D; class vtkPolyData; /** * @brief The vtkMitkRectangleProp2 class Renders a rectangle into a renderwindow as a frame. * * This class is a replacement for the deprecated vtkMitkRectangleProp, which * used to render the same effect with pure OpenGL. */ class MITK_EXPORT vtkMitkRectangleProp : public vtkProp { - public: - static vtkMitkRectangleProp* New(); - vtkTypeMacro(vtkMitkRectangleProp,vtkProp); +public: + static vtkMitkRectangleProp* New(); + vtkTypeMacro(vtkMitkRectangleProp,vtkProp); - /** + /** * @brief RenderOverlay Calls the render method of the actor and renders it. * @param viewport viewport of the renderwindow. * @return */ - int RenderOverlay(vtkViewport* viewport); + int RenderOverlay(vtkViewport* viewport); - /** + /** * @brief SetRenderWindow Set the renderwindow. * @param renWin */ - void SetRenderWindow(vtkSmartPointer renWin); + void SetRenderWindow(vtkSmartPointer renWin); - /** + /** * @brief SetColor Set the color of the rectangle. * @param col1 red * @param col2 green * @param col3 blue */ - void SetColor(float col1, float col2, float col3); + void SetColor(float col1, float col2, float col3); - protected: +protected: - vtkMitkRectangleProp(); - virtual ~vtkMitkRectangleProp(); + vtkMitkRectangleProp(); + virtual ~vtkMitkRectangleProp(); - /** + /** * @brief m_RenderWindow renderwindow to add the rectangle to. */ - vtkSmartPointer m_RenderWindow; + vtkSmartPointer m_RenderWindow; - /** - * @brief m_Color color of thr rectangle. + /** + * @brief m_Color color of the rectangle. */ - float m_Color[3]; + float m_Color[3]; - /** + /** * @brief CreateRectangle internal helper to fill a vtkPolydata with a rectangle. */ - void CreateRectangle(); - /** + void CreateRectangle(); + /** * @brief m_PolyData holds the rectangle. */ - vtkSmartPointer m_PolyData; - /** + vtkSmartPointer m_PolyData; + /** * @brief m_RectangleActor actor to render the rectangle. */ - vtkSmartPointer m_RectangleActor; + vtkSmartPointer m_RectangleActor; - /** + /** * @brief IDs of the corner points (the corners of the renderwindow). */ - vtkIdType m_BottomLeft, m_BottomRight, m_TopRight, m_TopLeft; + vtkIdType m_BottomLeft, m_BottomRight, m_TopRight, m_TopLeft; }; #endif /* vtkMitkRectangleProp_h */ diff --git a/Modules/QtWidgets/QmitkRenderWindow.h b/Modules/QtWidgets/QmitkRenderWindow.h index ae24232221..9e81a9c5ce 100644 --- a/Modules/QtWidgets/QmitkRenderWindow.h +++ b/Modules/QtWidgets/QmitkRenderWindow.h @@ -1,179 +1,179 @@ /*=================================================================== 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 QMITKRENDERWINDOW_H_HEADER_INCLUDED_C1C40D66 #define QMITKRENDERWINDOW_H_HEADER_INCLUDED_C1C40D66 #include "mitkRenderWindowBase.h" #include #include "QVTKWidget.h" #include "QmitkRenderWindowMenu.h" #include "mitkInteractionEventConst.h" #include "mitkBaseRenderer.h" class QmitkStdMultiWidget; class QDragEnterEvent; class QDropEvent; class QInputEvent; /** * \ingroup QmitkModule * \brief MITK implementation of the QVTKWidget */ class QMITK_EXPORT QmitkRenderWindow: public QVTKWidget, public mitk::RenderWindowBase { -Q_OBJECT + Q_OBJECT public: QmitkRenderWindow(QWidget *parent = 0, QString name = "unnamed renderwindow", mitk::VtkPropRenderer* renderer = NULL, - mitk::RenderingManager* renderingManager = NULL,mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard); + mitk::RenderingManager* renderingManager = NULL,mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard); virtual ~QmitkRenderWindow(); /** * \brief Whether Qt events should be passed to parent (default: true) * * With introduction of the QVTKWidget the behaviour regarding Qt events changed. * QVTKWidget "accepts" Qt events like mouse clicks (i.e. set an "accepted" flag). * When this flag is set, Qt fininshed handling of this event -- otherwise it is * reached through to the widget's parent. * * This reaching through to the parent was implicitly required by QmitkMaterialWidget / QmitkMaterialShowCase. *QmitkStdMultiWidget * The default behaviour of QmitkRenderWindow is now to clear the "accepted" flag * of Qt events after they were handled by QVTKWidget. This way parents can also * handle events. * * If you don't want this behaviour, call SetResendQtEvents(true) on your render window. */ virtual void SetResendQtEvents(bool resend); // Set Layout Index to define the Layout Type void SetLayoutIndex(unsigned int layoutIndex); // Get Layout Index to define the Layout Type unsigned int GetLayoutIndex(); //MenuWidget need to update the Layout Design List when Layout had changed void LayoutDesignListChanged(int layoutDesignIndex); void HideRenderWindowMenu(); //Activate or Deactivate MenuWidget. void ActivateMenuWidget(bool state, QmitkStdMultiWidget* stdMultiWidget = 0); bool GetActivateMenuWidgetFlag() { return m_MenuWidgetActivated; } // Get it from the QVTKWidget parent virtual vtkRenderWindow* GetVtkRenderWindow() { return GetRenderWindow(); } virtual vtkRenderWindowInteractor* GetVtkRenderWindowInteractor() { return NULL; } void FullScreenMode(bool state); protected: // overloaded move handler virtual void moveEvent(QMoveEvent* event); // overloaded show handler void showEvent(QShowEvent* event); // overloaded resize handler virtual void resizeEvent(QResizeEvent* event); // overloaded paint handler virtual void paintEvent(QPaintEvent* event); // overloaded mouse press handler virtual void mousePressEvent(QMouseEvent* event); // overloaded mouse double-click handler virtual void mouseDoubleClickEvent( QMouseEvent *event ); // overloaded mouse move handler virtual void mouseMoveEvent(QMouseEvent* event); // overloaded mouse release handler virtual void mouseReleaseEvent(QMouseEvent* event); // overloaded key press handler virtual void keyPressEvent(QKeyEvent* event); // overloaded enter handler virtual void enterEvent(QEvent*); // overloaded leave handler virtual void leaveEvent(QEvent*); /// \brief Simply says we accept the event type. virtual void dragEnterEvent(QDragEnterEvent *event); /// \brief If the dropped type is application/x-mitk-datanodes we process the request by converting to mitk::DataNode pointers and emitting the NodesDropped signal. virtual void dropEvent(QDropEvent * event); #ifndef QT_NO_WHEELEVENT // overload wheel mouse event virtual void wheelEvent(QWheelEvent*); #endif void AdjustRenderWindowMenuVisibility(const QPoint& pos); signals: void ResetView(); // \brief int parameters are enum from QmitkStdMultiWidget void ChangeCrosshairRotationMode(int); void SignalLayoutDesignChanged(int layoutDesignIndex); void moved(); void resized(); /// \brief Emits a signal to say that this window has had the following nodes dropped on it. void NodesDropped(QmitkRenderWindow *thisWindow, std::vector nodes); protected slots: void OnChangeLayoutDesign(int layoutDesignIndex); void OnWidgetPlaneModeChanged(int); void DeferredHideMenu(); private: // Helper Functions to Convert Qt-Events to Mitk-Events mitk::Point2D GetMousePosition(QMouseEvent* me) const; mitk::Point2D GetMousePosition(QWheelEvent* we) const; mitk::InteractionEvent::MouseButtons GetEventButton(QMouseEvent* me) const; mitk::InteractionEvent::MouseButtons GetButtonState(QMouseEvent* me) const; mitk::InteractionEvent::ModifierKeys GetModifiers(QInputEvent* me) const; mitk::InteractionEvent::MouseButtons GetButtonState(QWheelEvent* we) const; std::string GetKeyLetter(QKeyEvent* ke) const; int GetDelta(QWheelEvent* we) const; bool m_ResendQtEvents; QmitkRenderWindowMenu* m_MenuWidget; bool m_MenuWidgetActivated; unsigned int m_LayoutIndex; }; #endif diff --git a/Modules/QtWidgets/QmitkStdMultiWidget.h b/Modules/QtWidgets/QmitkStdMultiWidget.h index e27cd2cd03..d01a152fa6 100644 --- a/Modules/QtWidgets/QmitkStdMultiWidget.h +++ b/Modules/QtWidgets/QmitkStdMultiWidget.h @@ -1,381 +1,381 @@ /*=================================================================== 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 QMITKSTDMULTIWIDGET_H_ #define QMITKSTDMULTIWIDGET_H_ #include #include "mitkPositionTracker.h" #include "mitkSlicesRotator.h" #include "mitkSlicesSwiveller.h" #include "mitkRenderWindowFrame.h" #include "mitkLogoOverlay.h" #include "mitkGradientBackground.h" #include "mitkCoordinateSupplier.h" #include "mitkDataStorage.h" #include "mitkMouseModeSwitcher.h" #include #include #include #include #include #include "vtkTextProperty.h" #include "vtkCornerAnnotation.h" #include "mitkBaseRenderer.h" class QHBoxLayout; class QVBoxLayout; class QGridLayout; class QSpacerItem; class QmitkLevelWindowWidget; class QmitkRenderWindow; namespace mitk { class RenderingManager; } /// \ingroup QmitkModule class QMITK_EXPORT QmitkStdMultiWidget : public QWidget { Q_OBJECT public: QmitkStdMultiWidget(QWidget* parent = 0, Qt::WindowFlags f = 0, mitk::RenderingManager* renderingManager = 0, mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard, const QString& name = "stdmulti"); virtual ~QmitkStdMultiWidget(); mitk::SliceNavigationController* GetTimeNavigationController(); void RequestUpdate(); void ForceImmediateUpdate(); mitk::MouseModeSwitcher* GetMouseModeSwitcher(); QmitkRenderWindow* GetRenderWindow1() const; QmitkRenderWindow* GetRenderWindow2() const; QmitkRenderWindow* GetRenderWindow3() const; QmitkRenderWindow* GetRenderWindow4() const; const mitk::Point3D & GetLastLeftClickPosition() const; const mitk::Point3D GetCrossPosition() const; void EnablePositionTracking(); void DisablePositionTracking(); int GetLayout() const; mitk::SlicesRotator * GetSlicesRotator() const; mitk::SlicesSwiveller * GetSlicesSwiveller() const; bool GetGradientBackgroundFlag() const; /*! \brief Access node of widget plane 1 \return DataNode holding widget plane 1 */ mitk::DataNode::Pointer GetWidgetPlane1(); /*! \brief Access node of widget plane 2 \return DataNode holding widget plane 2 */ mitk::DataNode::Pointer GetWidgetPlane2(); /*! \brief Access node of widget plane 3 \return DataNode holding widget plane 3 */ mitk::DataNode::Pointer GetWidgetPlane3(); /*! \brief Convenience method to access node of widget planes \param id number of widget plane to be returned \return DataNode holding widget plane 3 */ mitk::DataNode::Pointer GetWidgetPlane(int id); bool IsColoredRectanglesEnabled() const; bool IsDepartmentLogoEnabled() const; bool IsCrosshairNavigationEnabled() const; void InitializeWidget(); /// called when the StdMultiWidget is closed to remove the 3 widget planes and the helper node from the DataStorage void RemovePlanesFromDataStorage(); void AddPlanesToDataStorage(); void SetDataStorage( mitk::DataStorage* ds ); /** \brief Listener to the CrosshairPositionEvent Ensures the CrosshairPositionEvent is handled only once and at the end of the Qt-Event loop */ void HandleCrosshairPositionEvent(); /// activate Menu Widget. true: activated, false: deactivated void ActivateMenuWidget( bool state ); bool IsMenuWidgetEnabled() const; /** * @brief SetColorWidget4 Get/Set the color of the decoration of the widget 4. * * This is used to color the frame of the renderwindow and the corner annatation. * For the other 3 widgets, this color is a property of the helper object nodes * which contain the respective plane geometry. The color can be modified via: * GetWidgetPlane1()->SetColor(); */ void SetDecorationColorWidget4(mitk::Color color); mitk::Color GetDecorationColorWidget4(); protected: void UpdateAllWidgets(); void HideAllWidgetToolbars(); mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes); public slots: /// Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update void HandleCrosshairPositionEventDelayed(); void changeLayoutTo2DImagesUp(); void changeLayoutTo2DImagesLeft(); void changeLayoutToDefault(); void changeLayoutToBig3D(); void changeLayoutToWidget1(); void changeLayoutToWidget2(); void changeLayoutToWidget3(); void changeLayoutToRowWidget3And4(); void changeLayoutToColumnWidget3And4(); void changeLayoutToRowWidgetSmall3andBig4(); void changeLayoutToSmallUpperWidget2Big3and4(); void changeLayoutTo2x2Dand3DWidget(); void changeLayoutToLeft2Dand3DRight2D(); void changeLayoutTo2DUpAnd3DDown(); void Fit(); void InitPositionTracking(); void AddDisplayPlaneSubTree(); void EnableStandardLevelWindow(); void DisableStandardLevelWindow(); bool InitializeStandardViews( const mitk::Geometry3D * geometry ); void wheelEvent( QWheelEvent * e ); void mousePressEvent(QMouseEvent * e); void moveEvent( QMoveEvent* e ); void leaveEvent ( QEvent * e ); void EnsureDisplayContainsPoint( - mitk::DisplayGeometry* displayGeometry, const mitk::Point3D& p); + mitk::DisplayGeometry* displayGeometry, const mitk::Point3D& p); void MoveCrossToPosition(const mitk::Point3D& newPosition); void EnableNavigationControllerEventListening(); void DisableNavigationControllerEventListening(); void EnableGradientBackground(); void DisableGradientBackground(); void EnableDepartmentLogo(); void DisableDepartmentLogo(); void EnableColoredRectangles(); void DisableColoredRectangles(); void SetWidgetPlaneVisibility(const char* widgetName, bool visible, mitk::BaseRenderer *renderer=NULL); void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer=NULL); void SetWidgetPlanesLocked(bool locked); void SetWidgetPlanesRotationLocked(bool locked); void SetWidgetPlanesRotationLinked( bool link ); void SetWidgetPlaneMode( int mode ); void SetGradientBackgroundColors( const mitk::Color & upper, const mitk::Color & lower ); void SetDepartmentLogoPath( const char * path ); void SetWidgetPlaneModeToSlicing( bool activate ); void SetWidgetPlaneModeToRotation( bool activate ); void SetWidgetPlaneModeToSwivel( bool activate ); void OnLayoutDesignChanged( int layoutDesignIndex ); void ResetCrosshair(); void MouseModeSelected( mitk::MouseModeSwitcher::MouseMode mouseMode ); signals: void LeftMouseClicked(mitk::Point3D pointValue); void WheelMoved(QWheelEvent*); void WidgetPlanesRotationLinked(bool); void WidgetPlanesRotationEnabled(bool); void ViewsInitialized(); void WidgetPlaneModeSlicing(bool); void WidgetPlaneModeRotation(bool); void WidgetPlaneModeSwivel(bool); void WidgetPlaneModeChange(int); void WidgetNotifyNewCrossHairMode(int); void Moved(); public: /** Define RenderWindow (public)*/ QmitkRenderWindow* mitkWidget1; QmitkRenderWindow* mitkWidget2; QmitkRenderWindow* mitkWidget3; QmitkRenderWindow* mitkWidget4; QmitkLevelWindowWidget* levelWindowWidget; /********************************/ enum { PLANE_MODE_SLICING = 0, PLANE_MODE_ROTATION, PLANE_MODE_SWIVEL }; enum { LAYOUT_DEFAULT = 0, LAYOUT_2D_IMAGES_UP, LAYOUT_2D_IMAGES_LEFT, - LAYOUT_BIG_3D, LAYOUT_WIDGET1, LAYOUT_WIDGET2, LAYOUT_WIDGET3, - LAYOUT_2X_2D_AND_3D_WIDGET, LAYOUT_ROW_WIDGET_3_AND_4, - LAYOUT_COLUMN_WIDGET_3_AND_4, LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4 , - LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4,LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET, - LAYOUT_2D_UP_AND_3D_DOWN}; + LAYOUT_BIG_3D, LAYOUT_WIDGET1, LAYOUT_WIDGET2, LAYOUT_WIDGET3, + LAYOUT_2X_2D_AND_3D_WIDGET, LAYOUT_ROW_WIDGET_3_AND_4, + LAYOUT_COLUMN_WIDGET_3_AND_4, LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4 , + LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4,LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET, + LAYOUT_2D_UP_AND_3D_DOWN}; enum { AXIAL, SAGITTAL, CORONAL, THREE_D }; void SetCornerAnnotation(std::string text, mitk::Color color, int widgetNumber); QmitkRenderWindow *GetRenderWindow(unsigned int number); protected: QHBoxLayout* QmitkStdMultiWidgetLayout; int m_Layout; int m_PlaneMode; mitk::RenderingManager* m_RenderingManager; mitk::RenderWindowFrame::Pointer m_RectangleRendering3; mitk::RenderWindowFrame::Pointer m_RectangleRendering2; mitk::RenderWindowFrame::Pointer m_RectangleRendering1; mitk::RenderWindowFrame::Pointer m_RectangleRendering4; mitk::LogoOverlay::Pointer m_LogoRendering; mitk::GradientBackground::Pointer m_GradientBackground1; mitk::GradientBackground::Pointer m_GradientBackground2; mitk::GradientBackground::Pointer m_GradientBackground4; mitk::GradientBackground::Pointer m_GradientBackground3; bool m_GradientBackgroundFlag; mitk::MouseModeSwitcher::Pointer m_MouseModeSwitcher; mitk::CoordinateSupplier::Pointer m_LastLeftClickPositionSupplier; mitk::PositionTracker::Pointer m_PositionTracker; mitk::SliceNavigationController* m_TimeNavigationController; mitk::SlicesRotator::Pointer m_SlicesRotator; mitk::SlicesSwiveller::Pointer m_SlicesSwiveller; mitk::DataNode::Pointer m_PositionTrackerNode; mitk::DataStorage::Pointer m_DataStorage; mitk::DataNode::Pointer m_PlaneNode1; mitk::DataNode::Pointer m_PlaneNode2; mitk::DataNode::Pointer m_PlaneNode3; /** * @brief m_ParentNodeForGeometryPlanes This helper object is added to the datastorage * and contains the 3 planes for displaying the image geometry (crosshair and 3D planes). */ mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes; /** * @brief m_DecorationColorWidget4 color for annotation and rectangle of widget 4. * * For other widgets1-3, the color is a property of the respective data node. * There is no node for widget 4, hence, we need an extra member. */ mitk::Color m_DecorationColorWidget4; QSplitter *m_MainSplit; QSplitter *m_LayoutSplit; QSplitter *m_SubSplit1; QSplitter *m_SubSplit2; QWidget *mitkWidget1Container; QWidget *mitkWidget2Container; QWidget *mitkWidget3Container; QWidget *mitkWidget4Container; struct CornerAnnotation { vtkSmartPointer cornerText; vtkSmartPointer textProp; vtkSmartPointer ren; } m_CornerAnnotaions[4]; bool m_PendingCrosshairPositionEvent; bool m_CrosshairNavigationEnabled; CornerAnnotation CreateCornerAnnotation(std::string text, mitk::Color color); }; #endif /*QMITKSTDMULTIWIDGET_H_*/ diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp index 9c26fd7051..a861adbe03 100644 --- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp +++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp @@ -1,476 +1,476 @@ /*=================================================================== 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 "QmitkStdMultiWidgetEditor.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include class QmitkStdMultiWidgetEditorPrivate { public: QmitkStdMultiWidgetEditorPrivate(); ~QmitkStdMultiWidgetEditorPrivate(); QmitkStdMultiWidget* m_StdMultiWidget; QmitkMouseModeSwitcher* m_MouseModeToolbar; std::string m_FirstBackgroundColor; std::string m_SecondBackgroundColor; bool m_MenuWidgetsEnabled; berry::IPartListener::Pointer m_PartListener; QHash m_RenderWindows; }; struct QmitkStdMultiWidgetPartListener : public berry::IPartListener { berryObjectMacro(QmitkStdMultiWidgetPartListener) QmitkStdMultiWidgetPartListener(QmitkStdMultiWidgetEditorPrivate* dd) : d(dd) {} Events::Types GetPartEventTypes() const { return Events::CLOSED | Events::HIDDEN | Events::VISIBLE; } void PartClosed (berry::IWorkbenchPartReference::Pointer partRef) { if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID) { QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast(); if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget()) { d->m_StdMultiWidget->RemovePlanesFromDataStorage(); stdMultiWidgetEditor->RequestActivateMenuWidget(false); } } } void PartHidden (berry::IWorkbenchPartReference::Pointer partRef) { if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID) { QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast(); if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget()) { d->m_StdMultiWidget->RemovePlanesFromDataStorage(); stdMultiWidgetEditor->RequestActivateMenuWidget(false); } } } void PartVisible (berry::IWorkbenchPartReference::Pointer partRef) { if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID) { QmitkStdMultiWidgetEditor::Pointer stdMultiWidgetEditor = partRef->GetPart(false).Cast(); if (d->m_StdMultiWidget == stdMultiWidgetEditor->GetStdMultiWidget()) { d->m_StdMultiWidget->AddPlanesToDataStorage(); stdMultiWidgetEditor->RequestActivateMenuWidget(true); } } } private: QmitkStdMultiWidgetEditorPrivate* const d; }; QmitkStdMultiWidgetEditorPrivate::QmitkStdMultiWidgetEditorPrivate() : m_StdMultiWidget(0), m_MouseModeToolbar(0) , m_MenuWidgetsEnabled(false) , m_PartListener(new QmitkStdMultiWidgetPartListener(this)) {} QmitkStdMultiWidgetEditorPrivate::~QmitkStdMultiWidgetEditorPrivate() { } const std::string QmitkStdMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.stdmultiwidget"; QmitkStdMultiWidgetEditor::QmitkStdMultiWidgetEditor() : d(new QmitkStdMultiWidgetEditorPrivate) { } QmitkStdMultiWidgetEditor::~QmitkStdMultiWidgetEditor() { this->GetSite()->GetPage()->RemovePartListener(d->m_PartListener); } QmitkStdMultiWidget* QmitkStdMultiWidgetEditor::GetStdMultiWidget() { return d->m_StdMultiWidget; } QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetActiveQmitkRenderWindow() const { if (d->m_StdMultiWidget) return d->m_StdMultiWidget->GetRenderWindow1(); return 0; } QHash QmitkStdMultiWidgetEditor::GetQmitkRenderWindows() const { return d->m_RenderWindows; } QmitkRenderWindow *QmitkStdMultiWidgetEditor::GetQmitkRenderWindow(const QString &id) const { if (d->m_RenderWindows.contains(id)) return d->m_RenderWindows[id]; return 0; } mitk::Point3D QmitkStdMultiWidgetEditor::GetSelectedPosition(const QString & /*id*/) const { return d->m_StdMultiWidget->GetCrossPosition(); } void QmitkStdMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D &pos, const QString &/*id*/) { d->m_StdMultiWidget->MoveCrossToPosition(pos); } void QmitkStdMultiWidgetEditor::EnableDecorations(bool enable, const QStringList &decorations) { if (decorations.isEmpty() || decorations.contains(DECORATION_BORDER)) { enable ? d->m_StdMultiWidget->EnableColoredRectangles() : d->m_StdMultiWidget->DisableColoredRectangles(); } if (decorations.isEmpty() || decorations.contains(DECORATION_LOGO)) { enable ? d->m_StdMultiWidget->EnableDepartmentLogo() : d->m_StdMultiWidget->DisableDepartmentLogo(); } if (decorations.isEmpty() || decorations.contains(DECORATION_MENU)) { d->m_StdMultiWidget->ActivateMenuWidget(enable); } if (decorations.isEmpty() || decorations.contains(DECORATION_BACKGROUND)) { enable ? d->m_StdMultiWidget->EnableGradientBackground() : d->m_StdMultiWidget->DisableGradientBackground(); } } bool QmitkStdMultiWidgetEditor::IsDecorationEnabled(const QString &decoration) const { if (decoration == DECORATION_BORDER) { return d->m_StdMultiWidget->IsColoredRectanglesEnabled(); } else if (decoration == DECORATION_LOGO) { return d->m_StdMultiWidget->IsColoredRectanglesEnabled(); } else if (decoration == DECORATION_MENU) { return d->m_StdMultiWidget->IsMenuWidgetEnabled(); } else if (decoration == DECORATION_BACKGROUND) { return d->m_StdMultiWidget->GetGradientBackgroundFlag(); } return false; } QStringList QmitkStdMultiWidgetEditor::GetDecorations() const { QStringList decorations; decorations << DECORATION_BORDER << DECORATION_LOGO << DECORATION_MENU << DECORATION_BACKGROUND; return decorations; } mitk::SlicesRotator* QmitkStdMultiWidgetEditor::GetSlicesRotator() const { return d->m_StdMultiWidget->GetSlicesRotator(); } mitk::SlicesSwiveller* QmitkStdMultiWidgetEditor::GetSlicesSwiveller() const { return d->m_StdMultiWidget->GetSlicesSwiveller(); } void QmitkStdMultiWidgetEditor::EnableSlicingPlanes(bool enable) { d->m_StdMultiWidget->SetWidgetPlanesVisibility(enable); } bool QmitkStdMultiWidgetEditor::IsSlicingPlanesEnabled() const { mitk::DataNode::Pointer node = this->d->m_StdMultiWidget->GetWidgetPlane1(); if (node.IsNotNull()) { bool visible = false; node->GetVisibility(visible, 0); return visible; } else { return false; } } void QmitkStdMultiWidgetEditor::EnableLinkedNavigation(bool enable) { enable ? d->m_StdMultiWidget->EnableNavigationControllerEventListening() : d->m_StdMultiWidget->DisableNavigationControllerEventListening(); } bool QmitkStdMultiWidgetEditor::IsLinkedNavigationEnabled() const { return d->m_StdMultiWidget->IsCrosshairNavigationEnabled(); } void QmitkStdMultiWidgetEditor::CreateQtPartControl(QWidget* parent) { if (d->m_StdMultiWidget == 0) { QHBoxLayout* layout = new QHBoxLayout(parent); layout->setContentsMargins(0,0,0,0); if (d->m_MouseModeToolbar == NULL) { d->m_MouseModeToolbar = new QmitkMouseModeSwitcher(parent); // delete by Qt via parent layout->addWidget(d->m_MouseModeToolbar); } berry::IPreferences::Pointer prefs = this->GetPreferences(); mitk::BaseRenderer::RenderingMode::Type renderingMode = static_cast(prefs->GetInt( "Rendering Mode" , 0 )); d->m_StdMultiWidget = new QmitkStdMultiWidget(parent,0,0,renderingMode); d->m_RenderWindows.insert("axial", d->m_StdMultiWidget->GetRenderWindow1()); d->m_RenderWindows.insert("sagittal", d->m_StdMultiWidget->GetRenderWindow2()); d->m_RenderWindows.insert("coronal", d->m_StdMultiWidget->GetRenderWindow3()); d->m_RenderWindows.insert("3d", d->m_StdMultiWidget->GetRenderWindow4()); d->m_MouseModeToolbar->setMouseModeSwitcher( d->m_StdMultiWidget->GetMouseModeSwitcher() ); connect( d->m_MouseModeToolbar, SIGNAL( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ), - d->m_StdMultiWidget, SLOT( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ) ); + d->m_StdMultiWidget, SLOT( MouseModeSelected(mitk::MouseModeSwitcher::MouseMode) ) ); layout->addWidget(d->m_StdMultiWidget); mitk::DataStorage::Pointer ds = this->GetDataStorage(); // Tell the multiWidget which (part of) the tree to render d->m_StdMultiWidget->SetDataStorage(ds); // Initialize views as axial, sagittal, coronar to all data objects in DataStorage // (from top-left to bottom) mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll()); mitk::RenderingManager::GetInstance()->InitializeViews(geo); // Initialize bottom-right view as 3D view d->m_StdMultiWidget->GetRenderWindow4()->GetRenderer()->SetMapperID( - mitk::BaseRenderer::Standard3D ); + mitk::BaseRenderer::Standard3D ); // Enable standard handler for levelwindow-slider d->m_StdMultiWidget->EnableStandardLevelWindow(); // Add the displayed views to the tree to see their positions // in 2D and 3D d->m_StdMultiWidget->AddDisplayPlaneSubTree(); d->m_StdMultiWidget->EnableNavigationControllerEventListening(); // Store the initial visibility status of the menu widget. d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled(); this->GetSite()->GetPage()->AddPartListener(d->m_PartListener); this->OnPreferencesChanged(dynamic_cast(prefs.GetPointer())); this->RequestUpdate(); } } void QmitkStdMultiWidgetEditor::OnPreferencesChanged(const berry::IBerryPreferences* prefs) { // Enable change of logo. If no DepartmentLogo was set explicitly, MBILogo is used. // Set new department logo by prefs->Set("DepartmentLogo", "PathToImage"); // If no logo was set for this plug-in specifically, walk the parent preference nodes // and lookup a logo value there. const berry::IPreferences* currentNode = prefs; while(currentNode) { std::vector keys = currentNode->Keys(); bool logoFound = false; for( std::size_t i = 0; i < keys.size(); ++i ) { if( keys[i] == "DepartmentLogo") { std::string departmentLogoLocation = currentNode->Get("DepartmentLogo", ""); if (departmentLogoLocation.empty()) { d->m_StdMultiWidget->DisableDepartmentLogo(); } else { // we need to disable the logo first, otherwise setting a new logo will have // no effect due to how mitkManufacturerLogo works... d->m_StdMultiWidget->DisableDepartmentLogo(); d->m_StdMultiWidget->SetDepartmentLogoPath(departmentLogoLocation.c_str()); d->m_StdMultiWidget->EnableDepartmentLogo(); } logoFound = true; break; } } if (logoFound) break; currentNode = currentNode->Parent().GetPointer(); } // preferences for gradient background mitk::Color upper = GetColorForWidget("first background color", prefs); mitk::Color lower = GetColorForWidget("second background color", prefs); d->m_StdMultiWidget->SetGradientBackgroundColors(upper, lower); d->m_StdMultiWidget->EnableGradientBackground(); // preferences for renderWindows mitk::Color colorWidget1 = GetColorForWidget("widget1 color", prefs); mitk::Color colorWidget2 = GetColorForWidget("widget2 color", prefs); mitk::Color colorWidget3 = GetColorForWidget("widget3 color", prefs); mitk::Color colorWidget4 = GetColorForWidget("widget4 color", prefs); mitk::BaseRenderer::GetInstance(d->m_StdMultiWidget->GetRenderWindow1()->GetVtkRenderWindow()) ->GetCurrentWorldPlaneGeometryNode()->SetColor(colorWidget1); mitk::BaseRenderer::GetInstance(d->m_StdMultiWidget->GetRenderWindow2()->GetVtkRenderWindow()) ->GetCurrentWorldPlaneGeometryNode()->SetColor(colorWidget2); mitk::BaseRenderer::GetInstance(d->m_StdMultiWidget->GetRenderWindow3()->GetVtkRenderWindow()) ->GetCurrentWorldPlaneGeometryNode()->SetColor(colorWidget3); d->m_StdMultiWidget->SetDecorationColorWidget4(colorWidget4); //The crosshair gap int crosshairgapsize = prefs->GetInt("crosshair gap size", 32); mitk::BaseRenderer::GetInstance(d->m_StdMultiWidget->GetRenderWindow1()->GetVtkRenderWindow()) ->GetCurrentWorldPlaneGeometryNode()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize); mitk::BaseRenderer::GetInstance(d->m_StdMultiWidget->GetRenderWindow2()->GetVtkRenderWindow()) ->GetCurrentWorldPlaneGeometryNode()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize); mitk::BaseRenderer::GetInstance(d->m_StdMultiWidget->GetRenderWindow3()->GetVtkRenderWindow()) ->GetCurrentWorldPlaneGeometryNode()->SetIntProperty("Crosshair.Gap Size", crosshairgapsize); //refresh colors of rectangles d->m_StdMultiWidget->EnableColoredRectangles(); // Set preferences respecting zooming and padding bool constrainedZooming = prefs->GetBool("Use constrained zooming and padding", false); mitk::RenderingManager::GetInstance()->SetConstrainedPaddingZooming(constrainedZooming); mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage()); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // level window setting bool showLevelWindowWidget = prefs->GetBool("Show level/window widget", true); if (showLevelWindowWidget) { d->m_StdMultiWidget->EnableStandardLevelWindow(); } else { d->m_StdMultiWidget->DisableStandardLevelWindow(); } // mouse modes toolbar bool newMode = prefs->GetBool("PACS like mouse interaction", false); d->m_MouseModeToolbar->setVisible( newMode ); d->m_StdMultiWidget->GetMouseModeSwitcher()->SetInteractionScheme( newMode ? mitk::MouseModeSwitcher::PACS : mitk::MouseModeSwitcher::MITK ); d->m_StdMultiWidget->SetCornerAnnotation( prefs->GetByteArray("widget1 corner annotation", "Axial"), colorWidget1, 0); d->m_StdMultiWidget->SetCornerAnnotation( prefs->GetByteArray("widget2 corner annotation", "Sagittal"), colorWidget2, 1); d->m_StdMultiWidget->SetCornerAnnotation( prefs->GetByteArray("widget3 corner annotation", "Coronal"), colorWidget3, 2); d->m_StdMultiWidget->SetCornerAnnotation( prefs->GetByteArray("widget4 corner annotation", "3D"), colorWidget4, 3); } mitk::Color QmitkStdMultiWidgetEditor::GetColorForWidget(std::string widgetName, const berry::IBerryPreferences* prefs) { QString widgetColorQt = QString::fromStdString(prefs->GetByteArray(widgetName, "")); QColor qColor(widgetColorQt); mitk::Color widgetColor; float colorMax = 255.0f; if (widgetColorQt=="") // default value { widgetColor[0] = 1.0; widgetColor[1] = 1.0; widgetColor[2] = 1.0; MITK_ERROR << "Using default color for unknown widget " << widgetName; } else { widgetColor[0] = qColor.red() / colorMax; widgetColor[1] = qColor.green() / colorMax; widgetColor[2] = qColor.blue() / colorMax; } return widgetColor; } void QmitkStdMultiWidgetEditor::SetFocus() { if (d->m_StdMultiWidget != 0) d->m_StdMultiWidget->setFocus(); } void QmitkStdMultiWidgetEditor::RequestActivateMenuWidget(bool on) { if (d->m_StdMultiWidget) { if (on) { d->m_StdMultiWidget->ActivateMenuWidget(d->m_MenuWidgetsEnabled); } else { d->m_MenuWidgetsEnabled = d->m_StdMultiWidget->IsMenuWidgetEnabled(); d->m_StdMultiWidget->ActivateMenuWidget(false); } } } diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp index 82b21db7ed..0608e6731b 100644 --- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp +++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.cpp @@ -1,298 +1,298 @@ /*=================================================================== 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 #include #include #include #include #include #include "QmitkStdMultiWidgetEditorPreferencePage.h" #include QmitkStdMultiWidgetEditorPreferencePage::QmitkStdMultiWidgetEditorPreferencePage() : m_Preferences(NULL), m_Ui(new Ui::QmitkStdMultiWidgetEditorPreferencePage), m_Control(NULL) { } QmitkStdMultiWidgetEditorPreferencePage::~QmitkStdMultiWidgetEditorPreferencePage() { } void QmitkStdMultiWidgetEditorPreferencePage::CreateQtControl(QWidget* parent) { m_Control = new QWidget(parent); m_Ui->setupUi(m_Control); berry::IPreferencesService::Pointer prefService - = berry::Platform::GetServiceRegistry() - .GetServiceById(berry::IPreferencesService::ID); + = berry::Platform::GetServiceRegistry() + .GetServiceById(berry::IPreferencesService::ID); m_Preferences = prefService->GetSystemPreferences()->Node(QmitkStdMultiWidgetEditor::EDITOR_ID); QObject::connect( m_Ui->m_ColorButton1, SIGNAL( clicked() ) - , this, SLOT( FirstColorChanged() ) ); + , this, SLOT( FirstColorChanged() ) ); QObject::connect( m_Ui->m_ColorButton2, SIGNAL( clicked() ) - , this, SLOT( SecondColorChanged() ) ); + , this, SLOT( SecondColorChanged() ) ); QObject::connect( m_Ui->m_ResetButton, SIGNAL( clicked() ) - , this, SLOT( ResetColors() ) ); + , this, SLOT( ResetColors() ) ); QObject::connect( m_Ui->m_RenderingMode, SIGNAL(activated(int) ) - , this, SLOT( ChangeRenderingMode(int) ) ); + , this, SLOT( ChangeRenderingMode(int) ) ); QObject::connect( m_Ui->m_RenderWindowDecorationColor, SIGNAL( clicked() ) - , this, SLOT( WidgetColorChanged() ) ); + , this, SLOT( WidgetColorChanged() ) ); QObject::connect( m_Ui->m_RenderWindowChooser, SIGNAL(activated(int) ) - , this, SLOT( OnWidgetComboBoxChanged(int) ) ); + , this, SLOT( OnWidgetComboBoxChanged(int) ) ); QObject::connect( m_Ui->m_RenderWindowDecorationText, SIGNAL(textChanged(QString) ) - , this, SLOT( AnnotationTextChanged(QString) ) ); + , this, SLOT( AnnotationTextChanged(QString) ) ); this->Update(); } QWidget* QmitkStdMultiWidgetEditorPreferencePage::GetQtControl() const { return m_Control; } void QmitkStdMultiWidgetEditorPreferencePage::Init(berry::IWorkbench::Pointer) { } void QmitkStdMultiWidgetEditorPreferencePage::PerformCancel() { } bool QmitkStdMultiWidgetEditorPreferencePage::PerformOk() { m_Preferences->PutByteArray("first background color", m_FirstColor); m_Preferences->PutByteArray("second background color", m_SecondColor); m_Preferences->PutByteArray("widget1 color", m_Widget1Color); m_Preferences->PutByteArray("widget2 color", m_Widget2Color); m_Preferences->PutByteArray("widget3 color", m_Widget3Color); m_Preferences->PutByteArray("widget4 color", m_Widget4Color); m_Preferences->PutByteArray("widget1 corner annotation", m_Widget1Annotation); m_Preferences->PutByteArray("widget2 corner annotation", m_Widget2Annotation); m_Preferences->PutByteArray("widget3 corner annotation", m_Widget3Annotation); m_Preferences->PutByteArray("widget4 corner annotation", m_Widget4Annotation); m_Preferences->PutInt("crosshair gap size", m_Ui->m_CrosshairGapSize->value()); m_Preferences->PutBool("Use constrained zooming and padding" - , m_Ui->m_EnableFlexibleZooming->isChecked()); + , m_Ui->m_EnableFlexibleZooming->isChecked()); m_Preferences->PutBool("Show level/window widget", m_Ui->m_ShowLevelWindowWidget->isChecked()); m_Preferences->PutBool("PACS like mouse interaction", m_Ui->m_PACSLikeMouseMode->isChecked()); m_Preferences->PutInt("Rendering Mode", m_Ui->m_RenderingMode->currentIndex()); return true; } void QmitkStdMultiWidgetEditorPreferencePage::Update() { m_Ui->m_EnableFlexibleZooming->setChecked(m_Preferences->GetBool("Use constrained zooming and padding", true)); m_Ui->m_ShowLevelWindowWidget->setChecked(m_Preferences->GetBool("Show level/window widget", true)); m_Ui->m_PACSLikeMouseMode->setChecked(m_Preferences->GetBool("PACS like mouse interaction", false)); m_FirstColor = m_Preferences->GetByteArray("first background color", "#191919"); m_SecondColor = m_Preferences->GetByteArray("second background color", "7F7F7F"); m_Widget1Color = m_Preferences->GetByteArray("widget1 color", "#FF0000"); m_Widget2Color = m_Preferences->GetByteArray("widget2 color", "#00FF00"); m_Widget3Color = m_Preferences->GetByteArray("widget3 color", "#0000FF"); m_Widget4Color = m_Preferences->GetByteArray("widget4 color", "#FFFF00"); m_Ui->m_CrosshairGapSize->setValue(m_Preferences->GetInt("crosshair gap size", 32)); m_Widget1Annotation = m_Preferences->GetByteArray("widget1 corner annotation", "Axial"); m_Widget2Annotation = m_Preferences->GetByteArray("widget2 corner annotation", "Sagittal"); m_Widget3Annotation = m_Preferences->GetByteArray("widget3 corner annotation", "Coronal"); m_Widget4Annotation = m_Preferences->GetByteArray("widget4 corner annotation", "3D"); QColor firstBackgroundColor = this->StringToColor(m_FirstColor); QColor secondBackgroundColor = this->StringToColor(m_SecondColor); QColor widgetColor = this->StringToColor(m_Widget1Color); this->SetStyleSheetToColorChooserButton(firstBackgroundColor, m_Ui->m_ColorButton1); this->SetStyleSheetToColorChooserButton(secondBackgroundColor, m_Ui->m_ColorButton2); this->SetStyleSheetToColorChooserButton(widgetColor, m_Ui->m_RenderWindowDecorationColor); m_Ui->m_RenderWindowDecorationText->setText(QString::fromStdString(m_Widget1Annotation)); int index= m_Preferences->GetInt("Rendering Mode",0); m_Ui->m_RenderingMode->setCurrentIndex(index); } QColor QmitkStdMultiWidgetEditorPreferencePage::StringToColor(std::string colorInHex) { QString colorQtString = QString::fromStdString(colorInHex); colorQtString = colorQtString.split("#").last(); QString red = colorQtString.at(0); red.append(colorQtString.at(1)); QString green = colorQtString.at(2); green.append(colorQtString.at(3)); QString blue = colorQtString.at(4); blue.append(colorQtString.at(5)); bool flag = true; unsigned int uired = red.toUInt(&flag, 16); unsigned int uigreen = green.toUInt(&flag, 16); unsigned int uiblue = blue.toUInt(&flag, 16); QColor color = QColor( uired, uigreen, uiblue); return color; } void QmitkStdMultiWidgetEditorPreferencePage::FirstColorChanged() { QColor color = QColorDialog::getColor(); this->SetStyleSheetToColorChooserButton(color, m_Ui->m_ColorButton1); QStringList firstColor; firstColor << color.name(); m_FirstColor = firstColor.replaceInStrings(";","\\;").join(";").toStdString(); } void QmitkStdMultiWidgetEditorPreferencePage::SetStyleSheetToColorChooserButton(QColor backgroundcolor, QPushButton* button) { button->setAutoFillBackground(true); QString styleSheet = "background-color:rgb("; styleSheet.append(QString::number(backgroundcolor.red())); styleSheet.append(","); styleSheet.append(QString::number(backgroundcolor.green())); styleSheet.append(","); styleSheet.append(QString::number(backgroundcolor.blue())); styleSheet.append(")"); button->setStyleSheet(styleSheet); } void QmitkStdMultiWidgetEditorPreferencePage::SecondColorChanged() { QColor color = QColorDialog::getColor(); this->SetStyleSheetToColorChooserButton(color, m_Ui->m_ColorButton2); QStringList secondColor; secondColor << color.name(); m_SecondColor = secondColor.replaceInStrings(";","\\;").join(";").toStdString(); } void QmitkStdMultiWidgetEditorPreferencePage::WidgetColorChanged() { QColor color = QColorDialog::getColor(); this->SetStyleSheetToColorChooserButton(color, m_Ui->m_RenderWindowDecorationColor); m_Ui->m_RenderWindowDecorationColor->setAutoFillBackground(true); QStringList qtColor; qtColor << color.name(); switch (m_Ui->m_RenderWindowChooser->currentIndex()) { case 0: //widget 1 m_Widget1Color = qtColor.replaceInStrings(";","\\;").join(";").toStdString(); break; case 1: //widget 1 m_Widget2Color = qtColor.replaceInStrings(";","\\;").join(";").toStdString(); break; case 2: //widget 1 m_Widget3Color = qtColor.replaceInStrings(";","\\;").join(";").toStdString(); break; case 3: //widget 1 m_Widget4Color = qtColor.replaceInStrings(";","\\;").join(";").toStdString(); break; default: MITK_INFO << "error selected wrong index."; break; } } void QmitkStdMultiWidgetEditorPreferencePage::AnnotationTextChanged(QString text) { switch (m_Ui->m_RenderWindowChooser->currentIndex()) { case 0: //widget 1 m_Widget1Annotation = text.toStdString(); break; case 1: //widget 1 m_Widget2Annotation = text.toStdString(); break; case 2: //widget 1 m_Widget3Annotation = text.toStdString(); break; case 3: //widget 1 m_Widget4Annotation = text.toStdString(); break; default: MITK_INFO << "error selected wrong index."; break; } } void QmitkStdMultiWidgetEditorPreferencePage::ResetColors() { //default gradient background values m_FirstColor = "#191919"; m_SecondColor = "#7F7F7F"; QColor firstColor = this->StringToColor(m_FirstColor); this->SetStyleSheetToColorChooserButton(firstColor, m_Ui->m_ColorButton1); QColor secondColor = this->StringToColor(m_SecondColor); this->SetStyleSheetToColorChooserButton(secondColor, m_Ui->m_ColorButton2); } void QmitkStdMultiWidgetEditorPreferencePage::OnWidgetComboBoxChanged(int i) { QColor widgetColor; switch (i) { case 0: //widget 1 widgetColor = StringToColor(m_Widget1Color); m_Ui->m_RenderWindowDecorationText->setText(QString::fromStdString(m_Widget1Annotation)); break; case 1: //widget 1 widgetColor = StringToColor(m_Widget2Color); m_Ui->m_RenderWindowDecorationText->setText(QString::fromStdString(m_Widget2Annotation)); break; case 2: //widget 1 widgetColor = StringToColor(m_Widget3Color); m_Ui->m_RenderWindowDecorationText->setText(QString::fromStdString(m_Widget3Annotation)); break; case 3: //widget 1 widgetColor = StringToColor(m_Widget4Color); m_Ui->m_RenderWindowDecorationText->setText(QString::fromStdString(m_Widget4Annotation)); break; default: MITK_INFO << "error selected wrong index."; break; } this->SetStyleSheetToColorChooserButton(widgetColor, m_Ui->m_RenderWindowDecorationColor); } void QmitkStdMultiWidgetEditorPreferencePage::ChangeRenderingMode(int i) { if( i == 0 ) { m_CurrentRenderingMode = "Standard"; } else if( i == 1 ) { - m_CurrentRenderingMode = "Multisampling"; + m_CurrentRenderingMode = "Multisampling"; } else if( i == 2 ) { m_CurrentRenderingMode = "DepthPeeling"; } } diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.h b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.h index 9b66cec1d1..1a48e00a86 100644 --- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.h +++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/internal/QmitkStdMultiWidgetEditorPreferencePage.h @@ -1,86 +1,86 @@ /*=================================================================== 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 QmitkStdMultiWidgetEditorPreferencePage_h #define QmitkStdMultiWidgetEditorPreferencePage_h #include #include #include #include #include namespace Ui { - class QmitkStdMultiWidgetEditorPreferencePage; +class QmitkStdMultiWidgetEditorPreferencePage; } class QmitkStdMultiWidgetEditorPreferencePage : public QObject, public berry::IQtPreferencePage { Q_OBJECT Q_INTERFACES(berry::IPreferencePage) public: QmitkStdMultiWidgetEditorPreferencePage(); ~QmitkStdMultiWidgetEditorPreferencePage(); void CreateQtControl(QWidget* parent); QWidget* GetQtControl() const; void Init(berry::IWorkbench::Pointer); void PerformCancel(); bool PerformOk(); void Update(); public slots: void FirstColorChanged(); void SecondColorChanged(); void ResetColors(); void ChangeRenderingMode(int i); void WidgetColorChanged(); void OnWidgetComboBoxChanged(int i); void AnnotationTextChanged(QString text); protected: std::string m_CurrentRenderingMode; std::string m_FirstColor; std::string m_SecondColor; std::string m_Widget1Color; std::string m_Widget2Color; std::string m_Widget3Color; std::string m_Widget4Color; std::string m_Widget1Annotation; std::string m_Widget2Annotation; std::string m_Widget3Annotation; std::string m_Widget4Annotation; berry::IPreferences::Pointer m_Preferences; void SetStyleSheetToColorChooserButton(QColor backgroundcolor, QPushButton* button); QColor StringToColor(std::string colorInHex); private: QScopedPointer m_Ui; QWidget* m_Control; }; #endif