vtkMRMLAbstractViewNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware Inc.
 
  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.
 
  This file was originally developed by Julien Finet, Kitware Inc.
  and was partially funded by NIH grant 3P41RR013218-12S1
 
==============================================================================*/
 
#ifndef __vtkMRMLAbstractViewNode_h
#define __vtkMRMLAbstractViewNode_h
 
// VTK includes
#include <vtkSmartPointer.h>
 
// MRML includes
#include "vtkMRMLNode.h"
 
class vtkMRMLInteractionNode;
class vtkMRMLLayoutNode;
class vtkMRMLModelNode;
class vtkStringArray;

class VTK_MRML_EXPORT vtkMRMLAbstractViewNode
  : public vtkMRMLNode
{
public:
  vtkTypeMacro(vtkMRMLAbstractViewNode,vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  void ReadXMLAttributes( const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  vtkMRMLCopyContentMacro(vtkMRMLAbstractViewNode);

  void Reset(vtkMRMLNode* defaultNode) override;

  inline void SetLayoutName(const char *layoutName);
  inline const char *GetLayoutName();

  vtkSetMacro(ViewGroup, int);
  vtkGetMacro(ViewGroup, int);

  vtkSetStringMacro(LayoutLabel);
  vtkGetStringMacro(LayoutLabel);

  vtkGetMacro(Active, int );
  vtkSetMacro(Active, int );

  vtkGetMacro(Visibility, int);
  vtkSetMacro(Visibility, int);

  vtkMRMLInteractionNode* GetInteractionNode();
  bool SetInteractionNodeID(const char *interactionNodeId);
  bool SetInteractionNode(vtkMRMLNode* node);

  virtual int IsMappedInLayout();
  virtual void SetMappedInLayout(int value);

  vtkMRMLNode* GetParentLayoutNode();
  bool SetAndObserveParentLayoutNodeID(const char *layoutNodeId);
  bool SetAndObserveParentLayoutNode(vtkMRMLNode* node);

  bool IsViewVisibleInLayout();

  vtkGetVector3Macro(BackgroundColor, double);
  vtkSetVector3Macro(BackgroundColor, double);

  vtkGetVector3Macro(BackgroundColor2, double);
  vtkSetVector3Macro(BackgroundColor2, double);
 

  vtkSetVector3Macro(LayoutColor, double);
  vtkGetVector3Macro(LayoutColor, double);
 
  static double* GetRedColor() VTK_SIZEHINT(3);
  static double* GetYellowColor() VTK_SIZEHINT(3);
  static double* GetGreenColor() VTK_SIZEHINT(3);
  static double* GetCompareColor() VTK_SIZEHINT(3);
  static double* GetGrayColor() VTK_SIZEHINT(3);
  static double* GetThreeDViewBlueColor() VTK_SIZEHINT(3);

  vtkGetMacro(OrientationMarkerEnabled, bool);

  vtkSetMacro(OrientationMarkerType, int);
  vtkGetMacro(OrientationMarkerType, int);

  void SetOrientationMarkerHumanModelNodeID(const char* modelNodeId);
  const char* GetOrientationMarkerHumanModelNodeID();
  vtkMRMLModelNode* GetOrientationMarkerHumanModelNode();

  static const char* GetOrientationMarkerTypeAsString(int id);
  static int GetOrientationMarkerTypeFromString(const char* name);

  vtkSetMacro(OrientationMarkerSize, int);
  vtkGetMacro(OrientationMarkerSize, int);

  static const char* GetOrientationMarkerSizeAsString(int id);
  static int GetOrientationMarkerSizeFromString(const char* name);

  enum OrientationMarkerTypeType
  {
    OrientationMarkerTypeNone=0,
    OrientationMarkerTypeCube,
    OrientationMarkerTypeHuman,
    OrientationMarkerTypeAxes,
    OrientationMarkerType_Last // insert valid types above this line
  };
  enum OrientationMarkerTypeType {…};
 
  enum OrientationMarkerSizeType
  {
    OrientationMarkerSizeSmall=0,
    OrientationMarkerSizeMedium,
    OrientationMarkerSizeLarge,
    OrientationMarkerSize_Last // insert valid types above this line
  };
  enum OrientationMarkerSizeType {…};

  vtkGetMacro(RulerEnabled, bool);

  vtkSetMacro(RulerType, int);
  vtkGetMacro(RulerType, int);

  static const char* GetRulerTypeAsString(int id);
  static int GetRulerTypeFromString(const char* name);

  enum RulerTypeType
  {
    RulerTypeNone=0,
    RulerTypeThin,
    RulerTypeThick,
    RulerType_Last // insert valid types above this line
  };
  enum RulerTypeType {…};

  vtkSetMacro(RulerColor, int);
  vtkGetMacro(RulerColor, int);

  static const char* GetRulerColorAsString(int id);
  static int GetRulerColorFromString(const char* name);

  enum RulerColorType
  {
    RulerColorWhite=0,
    RulerColorBlack,
    RulerColorYellow,
    RulerColor_Last // insert valid types above this line
  };
  enum RulerColorType {…};

  const char* GetAxisLabel(int labelIndex);
  void SetAxisLabel(int labelIndex, const char* label);

  std::string GetDirectionLabel(double direction[3], bool positive=true, double toleranceDeg=1.0);

  static const int AxisLabelsCount;

  vtkMRMLLayoutNode* GetMaximizedState(bool& maximized, bool& canBeMaximized);


  vtkGetMacro(ScreenScaleFactor, double);
  vtkSetMacro(ScreenScaleFactor, double);
 
protected:
  vtkMRMLAbstractViewNode();
  ~vtkMRMLAbstractViewNode() override;
 
  vtkMRMLAbstractViewNode(const vtkMRMLAbstractViewNode&);
  void operator=(const vtkMRMLAbstractViewNode&);

  int ViewGroup{0};

  char* LayoutLabel{nullptr};

  int Visibility{1};

  int Active{0};

  double BackgroundColor[3];
  double BackgroundColor2[3];

  double LayoutColor[3];

  bool OrientationMarkerEnabled{false};
  int OrientationMarkerType{OrientationMarkerTypeNone};
  int OrientationMarkerSize{OrientationMarkerSizeMedium};
 
  static const char* OrientationMarkerHumanModelReferenceRole;

  bool RulerEnabled{false};
  int RulerType{RulerTypeNone};
  int RulerColor{RulerColorWhite};

  double ScreenScaleFactor{ 0.2 };

  vtkSmartPointer<vtkStringArray> AxisLabels;
 
  static const char* ParentLayoutNodeReferenceRole;
  static const char* InteractionNodeReferenceRole;
};
class VTK_MRML_EXPORT vtkMRMLAbstractViewNode {…};
 
//------------------------------------------------------------------------------
void vtkMRMLAbstractViewNode::SetLayoutName(const char *layoutName)
{
  this->SetSingletonTag(layoutName);
}
void vtkMRMLAbstractViewNode::SetLayoutName(const char *layoutName) {…}
 
//------------------------------------------------------------------------------
const char *vtkMRMLAbstractViewNode::GetLayoutName()
{
  return this->GetSingletonTag();
}
const char *vtkMRMLAbstractViewNode::GetLayoutName() {…}
 
#endif