vtkMRMLScene.h

Go to the documentation of this file.

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

Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.

See Doc/copyright/copyright.txt
or http://www.slicer.org/copyright/copyright.txt for details.

Program:   3D Slicer
Module:    $RCSfile: vtkMRMLScene.h,v $
Date:      $Date: 2006/03/17 15:10:09 $
Version:   $Revision: 1.18 $

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

#ifndef __vtkMRMLScene_h
#define __vtkMRMLScene_h

#include <list>
#include <map>
#include <vector>
#include <string>

#include "vtkCollection.h"
#include "vtkObjectFactory.h"

#include "vtkMRML.h"
//#include "vtkMRMLNode.h"
class vtkMRMLNode;
#include "vtkCacheManager.h"
#include "vtkDataIOManager.h"
#include "vtkTagTable.h"

class vtkCallbackCommand;
class vtkGeneralTransform;
class vtkURIHandler;

class VTK_MRML_EXPORT vtkMRMLScene : public vtkCollection
{
public:
  static vtkMRMLScene *New();
  vtkTypeMacro(vtkMRMLScene,vtkCollection);
  void PrintSelf(ostream& os, vtkIndent indent);

  void SetURL(const char *url) {
    this->URL = std::string(url); 
  };
  
  const char *GetURL() {
    return this->URL.c_str();
  };
  
  void SetRootDirectory(const char *dir) {
    this->RootDirectory = std::string(dir); 
  };
  
  const char *GetRootDirectory() {
    return this->RootDirectory.c_str();
  };
  
  int Connect();
  
  int Import();

  int Commit(const char* url=NULL);

  void Clear(int removeSingletons);

  void ResetNodes();
  
  vtkMRMLNode* CreateNodeByClass(const char* className);

  void RegisterNodeClass(vtkMRMLNode* node);
  
  const char* GetClassNameByTag(const char *tagName);

  const char* GetTagByClassName(const char *className);

  vtkCollection* GetCurrentScene()
    {
    return this->CurrentScene;
    };

  void RequestNodeID(vtkMRMLNode *node, const char *ID);
  
  vtkMRMLNode* AddNode(vtkMRMLNode *n);

  vtkMRMLNode* CopyNode(vtkMRMLNode *n);

  vtkMRMLNode* AddNodeNoNotify(vtkMRMLNode *n);

  void NodeAdded(vtkMRMLNode *n);
  void NodeAdded() {this->NodeAdded(NULL);};
  
  void RemoveNode(vtkMRMLNode *n); 

  void RemoveNodeNoNotify(vtkMRMLNode *n); 
  
  int IsNodePresent(vtkMRMLNode *n) {
    return this->CurrentScene->vtkCollection::IsItemPresent((vtkObject *)n);};

  void InitTraversal() { 
    if (this && this->CurrentScene) 
      {
      this->CurrentScene->InitTraversal(); 
      }
  };
  
  vtkMRMLNode *GetNextNode() {
    return (vtkMRMLNode *)(this->CurrentScene->GetNextItemAsObject());};
  
  vtkMRMLNode *GetNextNodeByClass(const char* className);

  vtkCollection *GetNodesByName(const char* name);

  vtkMRMLNode *GetNodeByID(const char* name);
  //BTX
  vtkMRMLNode *GetNodeByID(std::string name);
  //ETX
  
  vtkCollection *GetNodesByClassByName(const char* className, const char* name);
  
  int GetNumberOfNodes () { return this->CurrentScene->GetNumberOfItems(); };

  vtkMRMLNode* GetNthNode(int n);
  
  vtkMRMLNode* GetNthNodeByClass(int n, const char* className );
  
  int GetNumberOfNodesByClass(const char* className);
  
  //BTX
  int GetNodesByClass(const char *className, std::vector<vtkMRMLNode *> &nodes);
  //ETX
  
  //BTX
  std::list<std::string> GetNodeClassesList();
  //ETX
  
  const char* GetNodeClasses();
  
  int GetNumberOfRegisteredNodeClasses();
  vtkMRMLNode * GetNthRegisteredNodeClass(int n);

  const char* GetUniqueNameByString(const char* className);
  int GetUniqueIDIndexByClass(const char* className);
  int GetUniqueIDIndexByClassFromIndex(const char* className, int hint);
  
  void InsertAfterNode( vtkMRMLNode *item, vtkMRMLNode *newItem);
  void InsertBeforeNode( vtkMRMLNode *item, vtkMRMLNode *newItem);
  
  int GetTransformBetweenNodes( vtkMRMLNode *node1, vtkMRMLNode *node2, 
                                vtkGeneralTransform *xform );

  void SetUndoOn() {UndoFlag=true;};
  void SetUndoOff() {UndoFlag=false;};
  bool GetUndoFlag() {return UndoFlag;};
  void SetUndoFlag(bool flag) {UndoFlag = flag;};

  void Undo();
  
  void Redo();

  void ClearUndoStack();
  
  void ClearRedoStack();

  int GetNumberOfUndoLevels() { return (int)this->UndoStack.size();};
  
  int GetNumberOfRedoLevels() { return (int)this->RedoStack.size();};

  void SaveStateForUndo();
  void SaveStateForUndo(vtkMRMLNode *node);
  void SaveStateForUndo(vtkCollection *nodes);
  //BTX
  void SaveStateForUndo(std::vector<vtkMRMLNode *> nodes);
  //ETX

  void AddReferencedNodeID(const char *id, vtkMRMLNode *refrencingNode)
  {
    if (id && refrencingNode && refrencingNode->GetScene() && refrencingNode->GetID()) 
      {
      this->ReferencedIDs.push_back(id);
      this->ReferencingNodes.push_back(refrencingNode);
      }
  };

  void ClearReferencedNodeID()
  {
    this->ReferencedIDs.clear();
    this->ReferencingNodes.clear();
    this->ReferencedIDChanges.clear();
  };

  void RemoveReferencedNodeID(const char *id, vtkMRMLNode *refrencingNode);

  void RemoveNodeReferences(vtkMRMLNode *node);

  void RemoveReferencesToNode(vtkMRMLNode *node);

  void UpdateNodeReferences();

  void UpdateNodeReferences(vtkCollection* chekNodes);

  void CopyNodeReferences(vtkMRMLScene *scene);

  void UpdateNodeChangedIDs();

  void RemoveUnusedNodeReferences();

  void AddReservedID(const char *id);

  void RemoveReservedIDs() {
    this->ReservedIDs.clear();
  };

  const char* GetChangedID(const char* id);

  vtkCollection* GetReferencedNodes(vtkMRMLNode *node);

  void GetReferencedSubScene(vtkMRMLNode *node, vtkMRMLScene* newScene);


//BTX
  static void SetActiveScene(vtkMRMLScene *);
  static vtkMRMLScene *GetActiveScene();
//ETX

//BTX
  enum
    {
      NodeAddedEvent = 66000,
      NodeRemovedEvent = 66001,
      NewSceneEvent = 66002,
      SceneCloseEvent = 66003,
      SceneClosingEvent = 66004,
      SceneLoadingErrorEvent = 66005,
      SceneEditedEvent = 66006,
      MetadataAddedEvent = 66007,
      LoadProgressFeedbackEvent = 66008,
      SaveProgressFeedbackEvent = 66009,
      SceneLoadStartEvent = 66010,
      SceneLoadEndEvent = 66011,
      SceneRestoredEvent = 66008,
      NodeAboutToBeAddedEvent = 66012,
      NodeAboutToBeRemovedEvent = 66013
    };
//ETX

  int IsFilePathRelative(const char * filepath);

  vtkSetMacro(ErrorCode,unsigned long);
  vtkGetMacro(ErrorCode,unsigned long);

  vtkSetMacro(LoadFromXMLString,int);
  vtkGetMacro(LoadFromXMLString,int);

  vtkSetMacro(SaveToXMLString,int);
  vtkGetMacro(SaveToXMLString,int);

//BTX
  void SetSceneXMLString(const std::string &xmlString) {
    this->SceneXMLString = xmlString;
  };

  std::string GetSceneXMLString() {
    return this->SceneXMLString;
  };
//ETX

  vtkSetMacro(ReadDataOnLoad,int);
  vtkGetMacro(ReadDataOnLoad,int);

//BTX
  void SetErrorMessage(const std::string &error) {
    this->ErrorMessage = error;
  };

  std::string GetErrorMessage() {
    return this->ErrorMessage;
  };
//ETX

  void SetErrorMessage(const char * message)
    {
    this->SetErrorMessage(std::string(message));
    }

  const char *GetErrorMessagePointer()
    {
    return (this->GetErrorMessage().c_str());
    }

  unsigned long GetSceneModifiedTime()
    {
    if (this->CurrentScene && this->CurrentScene->GetMTime() > this->SceneModifiedTime)
      {
      this->SceneModifiedTime = this->CurrentScene->GetMTime();
      }
    return this->SceneModifiedTime;
    };
    
  void IncrementSceneModifiedTime()
    {
    this->SceneModifiedTime ++;
    };

  void Edited()
    {
    this->InvokeEvent( vtkMRMLScene::SceneEditedEvent );
    }


  vtkGetObjectMacro ( CacheManager, vtkCacheManager );
  vtkSetObjectMacro ( CacheManager, vtkCacheManager );
  vtkGetObjectMacro ( DataIOManager, vtkDataIOManager );
  vtkSetObjectMacro ( DataIOManager, vtkDataIOManager );
  vtkGetObjectMacro ( URIHandlerCollection, vtkCollection );
  vtkSetObjectMacro ( URIHandlerCollection, vtkCollection );
  vtkGetObjectMacro ( UserTagTable, vtkTagTable);
  vtkSetObjectMacro ( UserTagTable, vtkTagTable);  

  vtkURIHandler *FindURIHandler(const char *URI);
  vtkURIHandler *FindURIHandlerByName ( const char *name );
  void AddURIHandler(vtkURIHandler *handler);

  vtkGetMacro( IsClosed, int );
  vtkSetMacro( IsClosed, int );
  
  vtkGetStringMacro(LastLoadedVersion);
  vtkSetStringMacro(LastLoadedVersion);

  vtkGetStringMacro(Version);
  vtkSetStringMacro(Version);

  int IsModifiedSinceRead();

  void CopyRegisteredNodesToScene(vtkMRMLScene *scene);

protected:
  vtkMRMLScene();
  ~vtkMRMLScene();
  vtkMRMLScene(const vtkMRMLScene&);
  void operator=(const vtkMRMLScene&);
  
  void PushIntoUndoStack();
  void PushIntoRedoStack();

  void CopyNodeInUndoStack(vtkMRMLNode *node);
  void CopyNodeInRedoStack(vtkMRMLNode *node);

  void AddReferencedNodes(vtkMRMLNode *node, vtkCollection *refNodes);

  static void SceneCallback( vtkObject *caller, unsigned long eid, 
                             void *clientData, void *callData );
  vtkCollection* CurrentScene;
  
  vtkCacheManager *CacheManager;
  vtkDataIOManager *DataIOManager;
  vtkCollection *URIHandlerCollection;
  vtkTagTable *UserTagTable;

  unsigned long SceneModifiedTime;
  
  int UndoStackSize;
  bool UndoFlag;
  
  bool InUndo;

  //BTX
  std::list< vtkCollection* >  UndoStack;
  std::list< vtkCollection* >  RedoStack;
  //ETX
  
  //BTX
  std::string         URL;
  std::map< std::string, int> UniqueIDByClass;
  std::vector< std::string >  UniqueIDs;
  std::vector< vtkMRMLNode* > RegisteredNodeClasses;
  std::vector< std::string >  RegisteredNodeTags;
  std::string          RootDirectory;

  std::vector< std::string > ReferencedIDs;
  std::vector< vtkMRMLNode* > ReferencingNodes;
  std::map< std::string, std::string> ReferencedIDChanges;
  
  //vtksys::hash_map<const char*, vtkMRMLNode*> NodeIDs;
  std::map<std::string, vtkMRMLNode*> NodeIDs;
  std::map<std::string, int> ReservedIDs;

  std::string ErrorMessage;

  std::string SceneXMLString;
  //ETX
  
  int LoadFromXMLString;

  int SaveToXMLString;

  int ReadDataOnLoad;

  void UpdateNodeIDs();

  unsigned long NodeIDsMTime;

  void RemoveAllNodesExceptSingletons();

  vtkSetStringMacro(ClassNameList);
  vtkGetStringMacro(ClassNameList);

  char *Version;

  char *LastLoadedVersion;
  vtkCallbackCommand *DeleteEventCallback;
  
private:
  void AddItem(vtkObject *o) { this->CurrentScene->vtkCollection::AddItem(o); this->Modified();};
  void RemoveItem(vtkObject *o) { this->CurrentScene->vtkCollection::RemoveItem(o); this->Modified();};
  void RemoveItem(int i) { this->CurrentScene->vtkCollection::RemoveItem(i); this->Modified();};
  int  IsItemPresent(vtkObject *o) { return this->CurrentScene->vtkCollection::IsItemPresent(o);};
  
  int LoadIntoScene(vtkCollection* scene);

  unsigned long ErrorCode;

  char* ClassNameList;

  static vtkMRMLScene *ActiveScene;

  int IsClosed;
};

#endif