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) VTK_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);

protected:

  vtkMRMLAnnotationDisplayableManager();
  virtual ~vtkMRMLAnnotationDisplayableManager();

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

  virtual void Create() 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(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 = NULL);
  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;

  virtual void OnInteractorStyleEvent(int eventid) VTK_OVERRIDE;

  vtkGetMacro(DisableInteractorStyleEventsProcessing, int);

  vtkMRMLAnnotationDisplayableManagerHelper * Helper;

  double LastClickWorldCoordinates[4];

private:

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


  int DisableInteractorStyleEventsProcessing;

  double ScaleFactor2D;
};

#endif