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 char* GetParentNodeID() {…}
 
  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());
  }
  int GetNumberOfChildrenNodes() {…}

  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 char* GetAssociatedNodeID() {…}
 
  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);
};
class VTK_MRML_EXPORT vtkMRMLHierarchyNode : public vtkMRMLNode {…};
 
#endif