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