vtkMRMLAnnotationDisplayableManager.h

Go to the documentation of this file.

/*=auto=========================================================================

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

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

 Program:   3D Slicer

 Module:    $RCSfile: vtkMRMLAnnotationDisplayableManager.h,v $
 Date:      $Date: 2010/07/26 04:48:05 $
 Version:   $Revision: 1.2 $

 =========================================================================auto=*/

#ifndef __vtkMRMLAnnotationDisplayableManager_h
#define __vtkMRMLAnnotationDisplayableManager_h

// Annotations includes
#include "vtkSlicerAnnotationsModuleMRMLDisplayableManagerExport.h"
class vtkMRMLAnnotationClickCounter;
class vtkMRMLAnnotationDisplayNode;
class vtkMRMLAnnotationDisplayableManagerHelper;
class vtkMRMLAnnotationLineDisplayNode;
class vtkMRMLAnnotationNode;
class vtkMRMLAnnotationPointDisplayNode;
class vtkSlicerViewerWidget;

// MRMLDisplayableManager includes
#include <vtkMRMLAbstractDisplayableManager.h>

// MRML includes
class vtkMRMLSliceNode;

// VTK includes
class vtkAbstractWidget;
class vtkHandleWidget;
class vtkSeedWidget;

class VTK_SLICER_ANNOTATIONS_MODULE_MRMLDISPLAYABLEMANAGER_EXPORT
vtkMRMLAnnotationDisplayableManager
  : public vtkMRMLAbstractDisplayableManager
{
public:

  static vtkMRMLAnnotationDisplayableManager *New();
  vtkTypeMacro(vtkMRMLAnnotationDisplayableManager, vtkMRMLAbstractDisplayableManager);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  // the following functions must be public to be accessible by the callback
  virtual void PropagateMRMLToWidget(vtkMRMLAnnotationNode* node, vtkAbstractWidget * widget);
  virtual void PropagateWidgetToMRML(vtkAbstractWidget * widget, vtkMRMLAnnotationNode* node);
  virtual bool Is2DDisplayableManager();
  vtkMRMLSliceNode * GetSliceNode();

  void 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(vtkMRMLAnnotationNode *node,
                                  double *worldCoordinates, double *localCoordinates);

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

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

  bool IsInLightboxMode();

  int GetLightboxIndex(vtkMRMLAnnotationNode *node, int controlPointIndex = 0);

  bool AddAnnotation(vtkMRMLAnnotationNode *node);

  bool CanProcessInteractionEvent(vtkMRMLInteractionEventData* eventData, double &closestDistance2) override;
  bool ProcessInteractionEvent(vtkMRMLInteractionEventData* eventData) override;

protected:

  vtkMRMLAnnotationDisplayableManager();
  ~vtkMRMLAnnotationDisplayableManager() override;

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

  void Create() override;

  virtual void RequestRender();

  void RemoveMRMLObservers() override;

  void UpdateFromMRML() override;

  void SetMRMLSceneInternal(vtkMRMLScene* newScene) override;

  void UpdateFromMRMLScene() override;
  void OnMRMLSceneEndClose() override;
  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
  void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) override;

  void OnMRMLDisplayableNodeModifiedEvent(vtkObject* caller) override;

  virtual void OnMRMLSliceNodeModifiedEvent(vtkMRMLSliceNode * sliceNode);

  virtual bool IsWidgetDisplayable(vtkMRMLSliceNode * sliceNode, vtkMRMLAnnotationNode* node);

  void SetAndObserveNode(vtkMRMLAnnotationNode *annotationNode);
  void SetAndObserveNodes();

  void AddObserversToInteractionNode();
  void RemoveObserversFromInteractionNode();

  void AddObserversToSelectionNode();
  void RemoveObserversFromSelectionNode();

  virtual void OnMRMLAnnotationNodeModifiedEvent(vtkMRMLNode* node);
  virtual void OnMRMLAnnotationNodeTransformModifiedEvent(vtkMRMLNode* node);
  virtual void OnMRMLAnnotationNodeLockModifiedEvent(vtkMRMLNode* node);
  virtual void OnMRMLAnnotationDisplayNodeModifiedEvent(vtkMRMLNode *node);
  virtual void OnMRMLAnnotationControlPointModifiedEvent(vtkMRMLNode *node);
  virtual void OnMRMLSelectionNodeUnitModifiedEvent(vtkMRMLSelectionNode*) {}

  //
  // 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 = nullptr);
  vtkMRMLAnnotationClickCounter* m_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 GetDisplayToWorldCoordinates(double x, double y, double * worldCoordinates);
//  void GetDisplayToWorldCoordinates(double * displayCoordinates, double * worldCoordinates);

  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(vtkMRMLAnnotationNode* node);
  virtual void OnWidgetCreated(vtkAbstractWidget * widget, vtkMRMLAnnotationNode * node);
  vtkAbstractWidget * GetWidget(vtkMRMLAnnotationNode * node);

  bool IsCorrectDisplayableManager();

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

  const char* m_Focus;

  int m_Updating;

  void OnInteractorStyleEvent(int eventid) override;

  vtkGetMacro(DisableInteractorStyleEventsProcessing, int);

  vtkMRMLAnnotationDisplayableManagerHelper * Helper;

  double LastClickWorldCoordinates[4];

private:

  vtkMRMLAnnotationDisplayableManager(const vtkMRMLAnnotationDisplayableManager&) = delete;
  void operator=(const vtkMRMLAnnotationDisplayableManager&) = delete;


  int DisableInteractorStyleEventsProcessing;

  double ScaleFactor2D;
};

#endif