vtkMRMLAbstractLogic.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.
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLAbstractLogic_h
#define __vtkMRMLAbstractLogic_h
 
// MRMLLogic includes
class vtkMRMLApplicationLogic;
 
// MRML includes
#include <vtkObserverManager.h>
class vtkMRMLNode;
class vtkMRMLScene;
 
// VTK includes
#include <vtkCommand.h>
#include <vtkObject.h>
class vtkIntArray;
class vtkFloatArray;
 
#include "vtkMRMLLogicExport.h"
 
//----------------------------------------------------------------------------
// Convenient macros
 
//----------------------------------------------------------------------------
// It removes all the event observations associated with the old value.
#ifndef vtkSetMRMLNodeMacro
# define vtkSetMRMLNodeMacro(node, value)                                                \
   {                                                                                     \
     vtkObject* _oldNode = (node);                                                       \
     this->GetMRMLNodesObserverManager()->SetObject(vtkObjectPointer(&(node)), (value)); \
     vtkObject* _newNode = (node);                                                       \
     if (_oldNode != _newNode)                                                           \
     {                                                                                   \
       this->Modified();                                                                 \
     }                                                                                   \
   };
#endif
 
//----------------------------------------------------------------------------
#ifndef vtkSetAndObserveMRMLNodeMacro
# define vtkSetAndObserveMRMLNodeMacro(node, value)                                                \
   {                                                                                               \
     vtkObject* _oldNode = (node);                                                                 \
     this->GetMRMLNodesObserverManager()->SetAndObserveObject(vtkObjectPointer(&(node)), (value)); \
     vtkObject* _newNode = (node);                                                                 \
     if (_oldNode != _newNode)                                                                     \
     {                                                                                             \
       this->Modified();                                                                           \
     }                                                                                             \
   };
#endif
 
//----------------------------------------------------------------------------
#ifndef vtkSetAndObserveMRMLNodeEventsMacro
# define vtkSetAndObserveMRMLNodeEventsMacro(node, value, events)                                                  \
   {                                                                                                               \
     vtkObject* _oldNode = (node);                                                                                 \
     this->GetMRMLNodesObserverManager()->SetAndObserveObjectEvents(vtkObjectPointer(&(node)), (value), (events)); \
     vtkObject* _newNode = (node);                                                                                 \
     if (_oldNode != _newNode)                                                                                     \
     {                                                                                                             \
       this->Modified();                                                                                           \
     }                                                                                                             \
   };
#endif
 
#ifndef vtkObserveMRMLNodeMacro
# define vtkObserveMRMLNodeMacro(node)                           \
   {                                                             \
     this->GetMRMLNodesObserverManager()->ObserveObject((node)); \
   };
#endif
 
#ifndef vtkObserveMRMLNodeEventsMacro
# define vtkObserveMRMLNodeEventsMacro(node, events)                         \
   {                                                                         \
     this->GetMRMLNodesObserverManager()->AddObjectEvents((node), (events)); \
   };
#endif
 
#ifndef vtkUnObserveMRMLNodeMacro
# define vtkUnObserveMRMLNodeMacro(node)                              \
   {                                                                  \
     this->GetMRMLNodesObserverManager()->RemoveObjectEvents((node)); \
   };
#endif
 
#ifndef vtkIsObservedMRMLNodeEventMacro
# define vtkIsObservedMRMLNodeEventMacro(node, event) (this->GetMRMLNodesObserverManager()->GetObservationsCount(node, event) != 0)
#endif

class VTK_MRML_LOGIC_EXPORT vtkMRMLAbstractLogic : public vtkObject
{
public:
  typedef void (vtkMRMLAbstractLogic::*TaskFunctionPointer)(void* clientdata);
 
  static vtkMRMLAbstractLogic* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
  vtkTypeMacro(vtkMRMLAbstractLogic, vtkObject);

  virtual vtkMRMLApplicationLogic* GetMRMLApplicationLogic() const;
  virtual void SetMRMLApplicationLogic(vtkMRMLApplicationLogic* logic);

  vtkMRMLScene* GetMRMLScene() const;

  void SetMRMLScene(vtkMRMLScene* newScene);

  void SetAndObserveMRMLScene(vtkMRMLScene* newScene);
  void SetAndObserveMRMLSceneEvents(vtkMRMLScene* newScene, vtkIntArray* events, vtkFloatArray* priorities = nullptr);
 
protected:
  vtkMRMLAbstractLogic();
  ~vtkMRMLAbstractLogic() override;

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

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

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

  vtkCallbackCommand* GetMRMLSceneCallbackCommand();

  vtkCallbackCommand* GetMRMLNodesCallbackCommand();

  vtkCallbackCommand* GetMRMLLogicsCallbackCommand();

  vtkObserverManager* GetMRMLSceneObserverManager() const;

  vtkObserverManager* GetMRMLNodesObserverManager() const;

  vtkObserverManager* GetMRMLLogicsObserverManager() const;

  int GetProcessingMRMLSceneEvent() const;

  virtual void UnobserveMRMLScene();
  virtual void ObserveMRMLScene();
  virtual void UpdateFromMRMLScene();

  virtual void OnMRMLSceneStartBatchProcess() {}
  virtual void OnMRMLSceneEndBatchProcess();
  virtual void OnMRMLSceneStartClose() {}
  virtual void OnMRMLSceneEndClose() {}
  virtual void OnMRMLSceneStartImport() {}
  virtual void OnMRMLSceneEndImport() {}
  virtual void OnMRMLSceneStartRestore() {}
  virtual void OnMRMLSceneEndRestore() {}
  virtual void OnMRMLSceneNew() {}
  virtual void OnMRMLSceneNodeAdded(vtkMRMLNode* /*node*/) {}
  virtual void OnMRMLSceneNodeRemoved(vtkMRMLNode* /*node*/) {}

  virtual void OnMRMLNodeModified(vtkMRMLNode* /*node*/) {}

  virtual void SetMRMLSceneInternal(vtkMRMLScene* newScene);

  void SetAndObserveMRMLSceneInternal(vtkMRMLScene* newScene);

  void SetAndObserveMRMLSceneEventsInternal(vtkMRMLScene* newScene, vtkIntArray* events, vtkFloatArray* priorities = nullptr);

  virtual void RegisterNodes() {}

  void SetInMRMLSceneCallbackFlag(int flag);

  int GetInMRMLSceneCallbackFlag() const;

  virtual bool EnterMRMLSceneCallback() const;

  void SetProcessingMRMLSceneEvent(int event);

  void SetInMRMLNodesCallbackFlag(int flag);

  int GetInMRMLNodesCallbackFlag() const;

  virtual bool EnterMRMLNodesCallback() const;

  void SetInMRMLLogicsCallbackFlag(int flag);

  int GetInMRMLLogicsCallbackFlag() const;

  virtual bool EnterMRMLLogicsCallback() const;

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

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

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

  inline bool StartModify();

  inline int EndModify(bool wasModifying);
 
  bool GetDisableModifiedEvent() const;
  void SetDisableModifiedEvent(bool onOff);

  void Modified() override;

  int InvokePendingModifiedEvent();
 
  int GetPendingModifiedEventCount() const;
 
private:
  vtkMRMLAbstractLogic(const vtkMRMLAbstractLogic&) = delete;
  void operator=(const vtkMRMLAbstractLogic&) = delete;
 
  class vtkInternal;
  vtkInternal* Internal;
};
 
//---------------------------------------------------------------------------
bool vtkMRMLAbstractLogic::StartModify()
{
  bool disabledModify = this->GetDisableModifiedEvent();
  this->SetDisableModifiedEvent(true);
  return disabledModify;
}
 
//---------------------------------------------------------------------------
int vtkMRMLAbstractLogic::EndModify(bool previousDisableModifiedEventState)
{
  this->SetDisableModifiedEvent(previousDisableModifiedEventState);
  if (!previousDisableModifiedEventState)
  {
    return this->InvokePendingModifiedEvent();
  }
  return this->GetPendingModifiedEventCount();
}
 
#endif