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