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