vtkMRMLLayerDMNodeReferenceObserver.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware SAS
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Thibault Pelletier, Kitware SAS,
  and was partially funded by ANR grants ANR-22-CE45-0034 and ANR-18-RHUS-005.
 
==============================================================================*/
 
#ifndef __vtkMRMLLayerDMNodeReferenceObserver_h
#define __vtkMRMLLayerDMNodeReferenceObserver_h
 
// LayerDM includes
#include "vtkSlicerLayerDMModuleMRMLExport.h"
 
// VTK includes
#include <vtkObject.h>
#include <vtkSmartPointer.h>
#include <vtkWeakPointer.h>
 
// STL includes
#include <functional>
#include <map>
#include <set>
#include <vector>
 
class vtkMRMLNode;
class vtkMRMLLayerDMObjectEventObserver;
class vtkMRMLScene;

class VTK_SLICER_LAYERDM_MODULE_MRML_EXPORT vtkMRMLLayerDMNodeReferenceObserver : public vtkObject
{
public:
  using RefT = std::tuple<vtkWeakPointer<vtkMRMLNode>, std::string>;
 
  enum Event
  {
    ReferenceAddedEvent = 0,
    ReferenceRemovedEvent
  };
 
  static vtkMRMLLayerDMNodeReferenceObserver* New();
  vtkTypeMacro(vtkMRMLLayerDMNodeReferenceObserver, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  std::vector<RefT> GetNodeToReferences(vtkMRMLNode* node) const;
  std::vector<RefT> GetNodeFromReferences(vtkMRMLNode* node) const;

  int GetReferenceToSize() const;
  int GetReferenceFromSize() const;
  int GetNumberOfNodes() const;

  using CallBackT = std::function<void(vtkMRMLNode*, vtkMRMLNode*, const std::string&, int eventType)>;
  void SetReferenceModifiedCallBack(const CallBackT& modifiedCallback);

  void SetScene(vtkMRMLScene* scene);
 
protected:
  vtkMRMLLayerDMNodeReferenceObserver();
  ~vtkMRMLLayerDMNodeReferenceObserver() override;
 
private:
  vtkMRMLLayerDMNodeReferenceObserver(const vtkMRMLLayerDMNodeReferenceObserver&);
  void operator=(const vtkMRMLLayerDMNodeReferenceObserver&);
 
  void UpdateFromScene();
  void OnNodeRemoved(vtkMRMLNode* node);
  void OnNodeAdded(vtkMRMLNode* node);
  void OnReferenceAdded(vtkMRMLNode* fromNode, vtkMRMLNode* toNode, const std::string& role);
  void OnReferenceRemoved(vtkMRMLNode* fromNode, vtkMRMLNode* toNode, const std::string& role);
  void RemoveOutdatedReferences(vtkMRMLNode* fromNode);
  void OnReferenceModified(vtkMRMLNode* fromNode, vtkMRMLNode* toNode, const std::string& role);
 
  static std::vector<RefT> GetNodeReferencesFromScene(vtkMRMLNode* node);
  void TriggerReferenceAdded(vtkMRMLNode* fromNode, vtkMRMLNode* toNode, const std::string& role) const;
  void TriggerReferenceRemoved(vtkMRMLNode* fromNode, vtkMRMLNode* toNode, const std::string& role) const;
  static void TriggerCallback(const CallBackT& callback, vtkMRMLNode* fromNode, vtkMRMLNode* toNode, const std::string& role, int eventType);
 
  vtkWeakPointer<vtkMRMLScene> Scene;
  vtkSmartPointer<vtkMRMLLayerDMObjectEventObserver> Observer;

  std::map<vtkSmartPointer<vtkMRMLNode>, std::vector<RefT>> NodeToReferences;
  std::map<vtkSmartPointer<vtkMRMLNode>, std::vector<RefT>> NodeFromReferences;
 
  std::set<vtkSmartPointer<vtkMRMLNode>> Nodes;
 
  CallBackT ReferenceModifiedCallback;
};
 
#endif