vtkMRMLNode.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: vtkMRMLNode.h,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.18 $

=========================================================================auto=*/

#ifndef __vtkMRMLNode_h
#define __vtkMRMLNode_h

// MRML includes
#include "vtkMRML.h"
#include "vtkObserverManager.h"
#include "vtkIdTypeArray.h"
#include "vtkIntArray.h"

class vtkMRMLScene;


// VTK includes
#include <vtkObject.h>
class vtkCallbackCommand;

// STD includes
#include <string>
#include <map>
#include <vector>

#ifndef vtkSetMRMLObjectMacro
#define vtkSetMRMLObjectMacro(node,value)  {this->MRMLObserverManager->SetObject ( vtkObjectPointer( &(node)), (value) );};
#endif

#ifndef vtkSetAndObserveMRMLObjectMacro
#define vtkSetAndObserveMRMLObjectMacro(node,value)  {this->MRMLObserverManager->SetAndObserveObject ( vtkObjectPointer( &(node)), (value) );};
#endif

#ifndef vtkSetAndObserveMRMLObjectEventsMacro
#define vtkSetAndObserveMRMLObjectEventsMacro(node,value,events)  {this->MRMLObserverManager->SetAndObserveObjectEvents ( vtkObjectPointer( &(node)), (value), (events));};
#endif

#ifndef vtkObserveMRMLObjectMacro
#define vtkObserveMRMLObjectMacro(node)  {this->MRMLObserverManager->ObserveObject ( (node) );};
#endif

#ifndef vtkObserveMRMLObjectEventsMacro
#define vtkObserveMRMLObjectEventsMacro(node, events)  {this->MRMLObserverManager->AddObjectEvents ( (node), (events) );};
#endif

#ifndef vtkUnObserveMRMLObjectMacro
#define vtkUnObserveMRMLObjectMacro(node)  {this->MRMLObserverManager->RemoveObjectEvents ( (node) );};
#endif

#ifndef vtkSetReferenceStringBodyMacro
#define vtkSetReferenceStringBodyMacro(name) \
  vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting " << #name " to " << (_arg?_arg:"(null)") ); \
  if ( this->name == NULL && _arg == NULL) { return;} \
  if ( this->name && _arg && (!strcmp(this->name,_arg))) { return;} \
  std::string oldValue; \
  if (this->name) { oldValue = this->name; delete [] this->name;  } \
  if (_arg) \
    { \
    size_t n = strlen(_arg) + 1; \
    char *cp1 =  new char[n]; \
    const char *cp2 = (_arg); \
    this->name = cp1; \
    do { *cp1++ = *cp2++; } while ( --n ); \
    } \
   else \
    { \
    this->name = NULL; \
    } \
  this->Modified(); \
  if (this->Scene && this->name) \
    { \
    if (oldValue.size() > 0) \
      { \
      this->Scene->RemoveReferencedNodeID(oldValue.c_str(), this); \
      } \
    this->Scene->AddReferencedNodeID(this->name, this); \
    }
#endif

#ifndef vtkSetReferenceStringMacro
#define vtkSetReferenceStringMacro(name) \
virtual void Set##name (const char* _arg) \
  { \
  vtkSetReferenceStringBodyMacro(name)\
  }
#endif

#ifndef vtkCxxSetReferenceStringMacro
#define vtkCxxSetReferenceStringMacro(class,name)   \
void class::Set##name (const char* _arg)            \
  {                                                 \
  vtkSetReferenceStringBodyMacro(name);             \
  }
#endif

#ifndef vtkMRMLNodeNewMacro
#define vtkMRMLNodeNewMacro(newClass) \
  vtkStandardNewMacro(newClass); \
  vtkMRMLNode* newClass::CreateNodeInstance() \
  { \
    return newClass::New(); \
  }
#endif


class VTK_MRML_EXPORT vtkMRMLNode : public vtkObject
{
    friend class vtkMRMLScene;
    friend class vtkMRMLSceneViewNode;

public:
  vtkTypeMacro(vtkMRMLNode,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
  
  virtual vtkMRMLNode* CreateNodeInstance() = 0;

  virtual void ReadXMLAttributes(const char** atts);

  virtual void UpdateReferences();

  virtual void ProcessChildNode(vtkMRMLNode *){};
  
  virtual void UpdateScene(vtkMRMLScene *) 
  {
    this->UpdateNodeReferences();
  };

  virtual void OnNodeAddedToScene() 
  {
    this->UpdateNodeReferences();
  };

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

  virtual void WriteNodeBodyXML(ostream& of, int indent);
  
  virtual void Copy(vtkMRMLNode *node);

  void CopyWithScene(vtkMRMLNode *node);
  
  virtual void Reset();

  virtual int StartModify() 
    {
    int disabledModify = this->GetDisableModifiedEvent();
    this->DisableModifiedEventOn();
    return disabledModify;
    };

  virtual int EndModify(int previousDisableModifiedEventState) 
    {
    this->SetDisableModifiedEvent(previousDisableModifiedEventState);
    if (!previousDisableModifiedEventState)
      {
      return this->InvokePendingModifiedEvent();
      }
    return this->ModifiedEventPending;
    };


  virtual const char* GetNodeTagName() = 0;

  void SetAttribute(const char* name, const char* value);

  void RemoveAttribute(const char* name);

  const char* GetAttribute(const char* name);

  std::vector< std::string > GetAttributeNames();

  vtkGetMacro(HideFromEditors, int);
  vtkSetMacro(HideFromEditors, int);
  vtkBooleanMacro(HideFromEditors, int);

  vtkGetMacro(Selectable, int);
  vtkSetMacro(Selectable, int);
  vtkBooleanMacro(Selectable, int);

  
  virtual void ProcessMRMLEvents ( vtkObject *caller, unsigned long event, void *callData );

  vtkGetMacro(InMRMLCallbackFlag, int);
  void SetInMRMLCallbackFlag (int flag) {
    this->InMRMLCallbackFlag = flag;
  }

  vtkSetStringMacro(Description);
  vtkGetStringMacro(Description);

  vtkSetStringMacro(SceneRootDir);
  vtkGetStringMacro(SceneRootDir);
  
  vtkSetStringMacro(Name);
  vtkGetStringMacro(Name);
  
  
  vtkGetMacro(Indent, int);
  
  //vtkSetStringMacro(ID);
  vtkGetStringMacro(ID);

  vtkSetStringMacro(SingletonTag);
  vtkGetStringMacro(SingletonTag);

  vtkGetMacro(SaveWithScene, int);
  vtkSetMacro(SaveWithScene, int);
  vtkBooleanMacro(SaveWithScene, int);

  vtkGetMacro(AddToScene, int);
  vtkSetMacro(AddToScene, int);
  vtkBooleanMacro(AddToScene, int);
  void SetAddToSceneNoModify(int value);

  vtkGetMacro(DisableModifiedEvent, int);
  void SetDisableModifiedEvent(int onOff)
    {
    this->DisableModifiedEvent = onOff;
    }
  void DisableModifiedEventOn()
    {
    this->SetDisableModifiedEvent(1);
    }
  void DisableModifiedEventOff()
    {
    this->SetDisableModifiedEvent(0);
    }

  vtkGetMacro(ModifiedEventPending, int);

  virtual void Modified() 
    {
    if (!this->GetDisableModifiedEvent())
      {
      Superclass::Modified();
      }
    else
      {
      ++this->ModifiedEventPending;
      }
    }

  virtual int InvokePendingModifiedEvent ()
    {
    if ( this->ModifiedEventPending )
      {
      int oldModifiedEventPending = this->ModifiedEventPending;
      this->ModifiedEventPending = 0;
      Superclass::Modified();
      return oldModifiedEventPending;
      }
    return this->ModifiedEventPending;
    }

  void CopyWithSingleModifiedEvent (vtkMRMLNode *node)
    {
    int oldMode = this->GetDisableModifiedEvent();
    this->DisableModifiedEventOn();
    this->Copy(node);
    this->InvokePendingModifiedEvent();
    this->SetDisableModifiedEvent(oldMode);
    }
    
  void CopyWithoutModifiedEvent (vtkMRMLNode *node)
    {
    int oldMode = this->GetDisableModifiedEvent();
    this->DisableModifiedEventOn();
    this->Copy(node);
    this->SetDisableModifiedEvent(oldMode);
    }

  void CopyWithSceneWithSingleModifiedEvent (vtkMRMLNode *node)
    {
    int oldMode = this->GetDisableModifiedEvent();
    this->DisableModifiedEventOn();
    this->CopyWithScene(node);
    this->InvokePendingModifiedEvent();
    this->SetDisableModifiedEvent(oldMode);
    }

  void CopyWithSceneWithoutModifiedEvent (vtkMRMLNode *node)
    {
    int oldMode = this->GetDisableModifiedEvent();
    this->DisableModifiedEventOn();
    this->CopyWithScene(node);
    this->SetDisableModifiedEvent(oldMode);
    }

  vtkGetObjectMacro(Scene, vtkMRMLScene);
  virtual void SetScene(vtkMRMLScene* scene);

  virtual void SetSceneReferences();

  virtual void UpdateReferenceID(const char *oldID, const char *newID);

  const char *URLEncodeString(const char *inString);
  const char *URLDecodeString(const char *inString);

  vtkGetMacro(Selected, int);
  vtkSetMacro(Selected, int);
  vtkBooleanMacro(Selected, int);

  void AddNodeReferenceRole(const char *referenceRole, const char *mrmlAttributeName=0);
  
  vtkMRMLNode* SetNodeReferenceID(const char* referenceRole, const char* referencedNodeID);

  vtkMRMLNode* AddNodeReferenceID(const char* referenceRole , const char* referencedNodeID);

  vtkMRMLNode* SetNthNodeReferenceID(const char* referenceRole, int n, const char* referencedNodeID);

  vtkMRMLNode* SetAndObserveNodeReferenceID(const char* referenceRole , const char* referencedNodeID, vtkIntArray *events=0);

  vtkMRMLNode* AddAndObserveNodeReferenceID(const char* referenceRole , const char* referencedNodeID, vtkIntArray *events=0);
  
  vtkMRMLNode* SetAndObserveNthNodeReferenceID(const char* referenceRole, int n, const char *nodeReferenceID, vtkIntArray *events=0);

  void RemoveNthNodeReferenceID(const char* referenceRole, int n);

  void RemoveAllNodeReferenceIDs(const char* referenceRole);

  bool HasNodeReferenceID(const char* referenceRole, const char* NodeReferenceID);

  int GetNumberOfNodeReferences(const char* referenceRole);
  const char *GetNthNodeReferenceID(const char* referenceRole, int n);

  const char *GetNodeReferenceID(const char* referenceRole);

  vtkMRMLNode* GetNthNodeReference(const char* referenceRole, int n);

  vtkMRMLNode* GetNodeReference(const char* referenceRole);

  void GetNodeReferences(const char* referenceRole, std::vector<vtkMRMLNode*> &nodes);

  enum
    {
      HierarchyModifiedEvent = 16000,
      IDChangedEvent = 16001,
      ReferenceAddedEvent,
      ReferenceModifiedEvent,
      ReferenceRemovedEvent,
      ReferencedNodeModifiedEvent
    };
protected: 
  class VTK_MRML_EXPORT vtkMRMLNodeReference : public vtkObject
  {
  public: 
    vtkTypeMacro(vtkMRMLNodeReference,vtkObject);
    static vtkMRMLNodeReference *New();
    void PrintSelf(ostream& vtkNotUsed(os), vtkIndent vtkNotUsed(indent)){};

  public:
    vtkSetStringMacro(ReferenceRole);
    vtkGetStringMacro(ReferenceRole);

    vtkSetStringMacro(ReferencedNodeID);
    vtkGetStringMacro(ReferencedNodeID);

    vtkMRMLNode*    ReferencingNode;
    vtkMRMLNode*    ReferencedNode;
    vtkIntArray*    Events;

  protected:

    vtkMRMLNodeReference()
      {
      this->ReferencedNode = 0;
      this->ReferencingNode = 0;
      this->Events = 0;
      this->ReferencedNodeID = 0;
      this->ReferenceRole = 0;
      }

    ~vtkMRMLNodeReference()
      {
      if (this->Events)
        {
        this->Events->Delete();
        this->Events = 0;
        }
      };
    vtkMRMLNodeReference(const vtkMRMLNodeReference&);
    void operator=(const vtkMRMLNodeReference&);

    char*     ReferenceRole;
    char*     ReferencedNodeID;

  };

  typedef std::map< std::string, std::vector< vtkMRMLNodeReference *> > NodeReferencesType;
  NodeReferencesType NodeReferences;

  std::map< std::string, std::string> NodeReferenceMRMLAttributeNames;

protected:
  
  vtkMRMLNode();
  virtual ~vtkMRMLNode();
  vtkMRMLNode(const vtkMRMLNode&);
  void operator=(const vtkMRMLNode&);
  
  vtkSetMacro(Indent, int);

  static void MRMLCallback( vtkObject *caller,
                            unsigned long eid, void *clientData, void *callData );

  vtkCallbackCommand *MRMLCallbackCommand;

  int InMRMLCallbackFlag;

  char *Description;
  char *SceneRootDir;
  char *Name;
  char *ID;
  int Indent;
  int HideFromEditors;
  int Selectable;
  int Selected;
  int AddToScene;

  int  SaveWithScene;

  vtkMRMLScene *Scene;

  typedef std::map< std::string, std::string > AttributesType;
  AttributesType Attributes;

  vtkObserverManager *MRMLObserverManager;

  vtkSetStringMacro( TempURLString );
  vtkGetStringMacro( TempURLString );


  void UpdateNodeReferences(const char* referenceRole);

  void UpdateNodeReferences();

  void UpdateNthNodeReference(const char* referenceRole, int n);

  void UpdateNthNodeReference(vtkMRMLNodeReference *reference, int n);

  void SetAndObserveNthNodeReference(const char* referenceRole, int n, vtkMRMLNode *referencedNode, vtkIntArray *events=0);

  void DeleteAllReferences(bool callOnNodeReferenceRemoved=true);

  void RemoveAllReferencedNodes();

  virtual void OnNodeReferenceAdded(vtkMRMLNodeReference *reference)
  {
    this->InvokeEvent(vtkMRMLNode::ReferenceAddedEvent, reference);
  }

  virtual void OnNodeReferenceModified(vtkMRMLNodeReference *reference)
  {
    this->InvokeEvent(vtkMRMLNode::ReferenceModifiedEvent, reference);
  }

  virtual void OnNodeReferenceRemoved(vtkMRMLNodeReference *reference)
  {
    this->InvokeEvent(vtkMRMLNode::ReferenceRemovedEvent, reference);
  }



private:
  void SetID(const char* newID);

  char * TempURLString;

  char *SingletonTag;

  int DisableModifiedEvent;
  int ModifiedEventPending;

};

#endif