vtkMRMLMarkupsDisplayableManager2D.h

Go to the documentation of this file.

/*==============================================================================

  Program: 3D Slicer

  Portions (c) Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.

  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

==============================================================================*/

#ifndef __vtkMRMLMarkupsDisplayableManager2D_h
#define __vtkMRMLMarkupsDisplayableManager2D_h

// MarkupsModule includes
#include "vtkSlicerMarkupsModuleMRMLDisplayableManagerExport.h"

// MarkupsModule/MRMLDisplayableManager includes
#include "vtkMRMLMarkupsClickCounter.h"
#include "vtkMRMLMarkupsDisplayableManagerHelper.h"

// MRMLDisplayableManager includes
#include <vtkMRMLAbstractSliceViewDisplayableManager.h>

// VTK includes
#include <vtkHandleWidget.h>
#include <vtkSeedWidget.h>

class vtkMRMLMarkupsNode;
class vtkSlicerViewerWidget;
class vtkMRMLMarkupsDisplayNode;
class vtkAbstractWidget;

class  VTK_SLICER_MARKUPS_MODULE_MRMLDISPLAYABLEMANAGER_EXPORT vtkMRMLMarkupsDisplayableManager2D :
    public vtkMRMLAbstractSliceViewDisplayableManager
{
public:

  static vtkMRMLMarkupsDisplayableManager2D *New();
  vtkTypeMacro(vtkMRMLMarkupsDisplayableManager2D, vtkMRMLAbstractSliceViewDisplayableManager);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  void UpdateWidgetVisibility(vtkMRMLMarkupsNode* node);

  // the following functions must be public to be accessible by the callback
  virtual void PropagateMRMLToWidget(vtkMRMLMarkupsNode* node, vtkAbstractWidget * widget);
  virtual void PropagateWidgetToMRML(vtkAbstractWidget * widget, vtkMRMLMarkupsNode* node);

  bool RestrictDisplayCoordinatesToViewport(double* displayCoordinates);

  bool GetDisplayCoordinatesChanged(double * displayCoordinates1, double * displayCoordinates2);

  bool GetWorldCoordinatesChanged(double * worldCoordinates1, double * worldCoordinates2);

  void GetDisplayToWorldCoordinates(double x, double y, double * worldCoordinates);
  void GetDisplayToWorldCoordinates(double * displayCoordinates, double * worldCoordinates);

  virtual void GetWorldToLocalCoordinates(vtkMRMLMarkupsNode *node,
                                  double *worldCoordinates, double *localCoordinates);

  virtual void SetParentTransformToWidget(vtkMRMLMarkupsNode *vtkNotUsed(node), vtkAbstractWidget *vtkNotUsed(widget)){}

  vtkSetMacro(ScaleFactor2D, double);
  vtkGetMacro(ScaleFactor2D, double);

  vtkAbstractWidget *AddWidget(vtkMRMLMarkupsNode *markupsNode);

  vtkMRMLMarkupsDisplayableManagerHelper *  GetHelper() { return this->Helper; };

  bool IsInLightboxMode();

  int GetLightboxIndex(vtkMRMLMarkupsNode *node, int markupIndex, int pointIndex);

  virtual bool UpdateNthSeedPositionFromMRML(int vtkNotUsed(n),
                 vtkAbstractWidget *vtkNotUsed(widget),
                 vtkMRMLMarkupsNode *vtkNotUsed(markupsNode))
    { return false; }

  virtual bool UpdateNthMarkupPositionFromWidget(int vtkNotUsed(n),
                 vtkMRMLMarkupsNode *vtkNotUsed(pointsNode),
                 vtkAbstractWidget *vtkNotUsed(widget))
    { return false; }

protected:

  vtkMRMLMarkupsDisplayableManager2D();
  virtual ~vtkMRMLMarkupsDisplayableManager2D();

  virtual void ProcessMRMLNodesEvents(vtkObject *caller, unsigned long event, void *callData) VTK_OVERRIDE;

  virtual void RequestRender();

  virtual void RemoveMRMLObservers() VTK_OVERRIDE;

  virtual void UpdateFromMRML() VTK_OVERRIDE;

  virtual void SetMRMLSceneInternal(vtkMRMLScene* newScene) VTK_OVERRIDE;

  virtual void UpdateFromMRMLScene() VTK_OVERRIDE;
  virtual void OnMRMLSceneEndClose() VTK_OVERRIDE;
  virtual void OnMRMLSceneNodeAdded(vtkMRMLNode* node) VTK_OVERRIDE;
  virtual void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) VTK_OVERRIDE;

  virtual void OnMRMLDisplayableNodeModifiedEvent(vtkObject* caller) VTK_OVERRIDE;

  virtual void OnMRMLSliceNodeModifiedEvent() VTK_OVERRIDE;

  virtual bool IsWidgetDisplayableOnSlice(vtkMRMLMarkupsNode* node, int markupIndex = 0);

  void SetAndObserveNode(vtkMRMLMarkupsNode *markupsNode);
  void SetAndObserveNodes();

  void AddObserversToInteractionNode();
  void RemoveObserversFromInteractionNode();

  void OnMRMLMarkupsNodeModifiedEvent(vtkMRMLNode* node);
  void OnMRMLMarkupsNodeTransformModifiedEvent(vtkMRMLNode* node);
  void OnMRMLMarkupsNodeLockModifiedEvent(vtkMRMLNode* node);
  void OnMRMLMarkupsDisplayNodeModifiedEvent(vtkMRMLNode *node);
  void OnMRMLMarkupsPointModifiedEvent(vtkMRMLNode *node, int n);
  virtual void OnMRMLMarkupsNodeMarkupAddedEvent(vtkMRMLMarkupsNode * vtkNotUsed(markupsNode), int vtkNotUsed(n)) {};
  virtual void OnMRMLMarkupsNodeMarkupRemovedEvent(vtkMRMLMarkupsNode * vtkNotUsed(markupsNode), int vtkNotUsed(n)) {};
  virtual void OnMRMLMarkupsNodeNthMarkupModifiedEvent(vtkMRMLMarkupsNode* vtkNotUsed(node), int vtkNotUsed(n)) {};

  //
  // Handling of interaction within the RenderWindow
  //

  // Get the coordinates of a click in the RenderWindow
  void OnClickInRenderWindowGetCoordinates();
  virtual void OnClickInRenderWindow(double x, double y, const char *associatedNodeID = NULL);
  vtkMRMLMarkupsClickCounter* ClickCounter;

  virtual void UpdatePosition(vtkAbstractWidget *vtkNotUsed(widget), vtkMRMLNode *vtkNotUsed(node)) {};

  //
  // Seeds for widget placement
  //

  virtual void PlaceSeed(double x, double y);
  vtkHandleWidget * GetSeed(int index);

  //
  // Coordinate Conversions
  //

  void GetWorldToDisplayCoordinates(double r, double a, double s, double * displayCoordinates);
  void GetWorldToDisplayCoordinates(double * worldCoordinates, double * displayCoordinates);

  void GetDisplayToViewportCoordinates(double x, double y, double * viewportCoordinates);
  void GetDisplayToViewportCoordinates(double *displayCoordinates, double * viewportCoordinates);

  //
  // Widget functionality
  //

  virtual vtkAbstractWidget * CreateWidget(vtkMRMLMarkupsNode* node);
  virtual void OnWidgetCreated(vtkAbstractWidget * widget, vtkMRMLMarkupsNode * node);
  vtkAbstractWidget * GetWidget(vtkMRMLMarkupsNode * node);

  virtual bool IsCorrectDisplayableManager();

  virtual bool IsManageable(vtkMRMLNode* node);
  virtual bool IsManageable(const char* nodeClassName);

  const char* Focus;

  int Updating;

  virtual void OnInteractorStyleEvent(int eventid) VTK_OVERRIDE;

  vtkGetMacro(DisableInteractorStyleEventsProcessing, int);

  vtkMRMLMarkupsDisplayableManagerHelper * Helper;

  double LastClickWorldCoordinates[4];

private:

  vtkMRMLMarkupsDisplayableManager2D(const vtkMRMLMarkupsDisplayableManager2D&); 
  void operator=(const vtkMRMLMarkupsDisplayableManager2D&); 


  int DisableInteractorStyleEventsProcessing;

  vtkMRMLSliceNode * SliceNode;

  double ScaleFactor2D;
};

#endif