vtkMRMLHierarchyNode.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: vtkMRMLHierarchyNode.h,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.13 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLHierarchyNode_h
#define __vtkMRMLHierarchyNode_h
 
// MRML includes
#include "vtkMRMLNode.h"
 
// VTK includes
class vtkCollection;
 
// STD includes
#include <vector>
 
class VTK_MRML_EXPORT vtkMRMLHierarchyNode : public vtkMRMLNode
{
public:
  static vtkMRMLHierarchyNode *New();
  vtkTypeMacro(vtkMRMLHierarchyNode,vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMRMLNode* CreateNodeInstance() override;
 
  void ReadXMLAttributes( const char** atts) override;
 
  void WriteXML(ostream& of, int indent) override;
 
  void Copy(vtkMRMLNode *node) override;
 
  const char* GetNodeTagName() override {return "Hierarchy";}
 
  void SetSceneReferences() override;
 
  void UpdateReferences() override;
 
  void UpdateScene(vtkMRMLScene *scene) override;
 
  void UpdateReferenceID(const char *oldID, const char *newID) override;
 
  vtkMRMLHierarchyNode* GetParentNode();
 
  vtkMRMLHierarchyNode* GetTopParentNode();
 
  virtual char* GetParentNodeID()
  {
    return GetParentNodeIDReference();
  }
 
  virtual void SetParentNodeID(const char* ref);
 
  void GetAllChildrenNodes(std::vector< vtkMRMLHierarchyNode *> &childrenNodes);
 
  std::vector< vtkMRMLHierarchyNode *> GetChildrenNodes();
 
  int GetNumberOfChildrenNodes()
  {
    return static_cast<int>(this->GetChildrenNodes().size());
  }
 
  vtkMRMLHierarchyNode *GetNthChildNode(int index);
 
  int GetIndexInParent();
 
  void SetIndexInParent(int index);
 
  void MoveInParent(int increment);
 
  void RemoveHierarchyChildrenNodes();
 
  void RemoveAllHierarchyChildrenNodes();
 
  enum
    {
      ChildNodeAddedEvent = 15550,
      ChildNodeRemovedEvent = 15551
    };
 
 
  virtual char* GetAssociatedNodeID()
  {
    return GetAssociatedNodeIDReference();
  }
 
  virtual void SetAssociatedNodeID(const char* ref);
 
 
  virtual vtkMRMLNode* GetAssociatedNode();
 
 
  virtual void GetAssociatedChildrenNodes(vtkCollection *children, const char* childClass=nullptr);
 
  static vtkMRMLHierarchyNode* GetAssociatedHierarchyNode(vtkMRMLScene *scene,
                                                          const char *associatedNodeID);
  //vtkSetMacro(SortingValue, double);
  //nodes (since the order of that associated node could have changed as well)
  void SetSortingValue(double value);
  vtkGetMacro(SortingValue, double);
 
 
  vtkGetMacro(AllowMultipleChildren, int);
  vtkSetMacro(AllowMultipleChildren, int);
  vtkBooleanMacro(AllowMultipleChildren, int);
 
protected:
  vtkMRMLHierarchyNode();
  ~vtkMRMLHierarchyNode() override;
  vtkMRMLHierarchyNode(const vtkMRMLHierarchyNode&);
  void operator=(const vtkMRMLHierarchyNode&);
 
 
  void SetParentNodeIDReference(const char* id);
  vtkGetStringMacro(ParentNodeIDReference);
 
  char *ParentNodeIDReference;
 
  static void HierarchyIsModified(vtkMRMLScene *scene);
 
 
 
  static void AssociatedHierarchyIsModified(vtkMRMLScene *scene);
  char *AssociatedNodeIDReference;
 
  void SetAssociatedNodeIDReference(const char*);
  vtkGetStringMacro(AssociatedNodeIDReference);
 
  typedef std::map<std::string, std::vector< vtkMRMLHierarchyNode *> > HierarchyChildrenNodesType;
 
  static std::map< vtkMRMLScene*, HierarchyChildrenNodesType> SceneHierarchyChildrenNodes;
  static std::map< vtkMRMLScene*, vtkMTimeType> SceneHierarchyChildrenNodesMTime;
 
  static int UpdateAssociatedToHierarchyMap(vtkMRMLScene *scene);
 
  typedef std::map<std::string, vtkMRMLHierarchyNode *> AssociatedHierarchyNodesType;
 
  static std::map< vtkMRMLScene*, AssociatedHierarchyNodesType> SceneAssociatedHierarchyNodes;
 
  static std::map< vtkMRMLScene*, vtkMTimeType> SceneAssociatedHierarchyNodesMTime;
 
  double SortingValue;
 
  static double MaximumSortingValue;
 
  void UpdateChildrenMap();
 
  int AllowMultipleChildren;
 
  void InvokeHierarchyModifiedEvent(vtkMRMLNode *node = nullptr);
};
 
#endif