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();                                                         \
  }                                                                           \
};
#define vtkSetMRMLNodeMacro(node,value)  {                                    \ …
#endif
 
//----------------------------------------------------------------------------
#ifndef vtkSetAndObserveMRMLNodeMacro
#define vtkSetAndObserveMRMLNodeMacro(node,value) {                           \
  vtkObject *_oldNode = (node);                                               \
  this->GetMRMLNodesObserverManager()->SetAndObserveObject(                   \
    vtkObjectPointer(&(node)), (value));                                      \
  vtkObject *_newNode = (node);                                               \
  if (_oldNode != _newNode)                                                   \
  {                                                                           \
    this->Modified();                                                         \
  }                                                                           \
};
#define vtkSetAndObserveMRMLNodeMacro(node,value) {                           \ …
#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();                                                         \
  }                                                                           \
};
#define vtkSetAndObserveMRMLNodeEventsMacro(node,value,events) {              \ …
#endif
 
#ifndef vtkObserveMRMLNodeMacro
#define vtkObserveMRMLNodeMacro(node)                                         \
{                                                                             \
  this->GetMRMLNodesObserverManager()->ObserveObject( (node) );               \
};
#define vtkObserveMRMLNodeMacro(node)                                         \ …
#endif
 
 
#ifndef vtkObserveMRMLNodeEventsMacro
#define vtkObserveMRMLNodeEventsMacro(node, events)                           \
{                                                                             \
  this->GetMRMLNodesObserverManager()->AddObjectEvents ( (node), (events) );  \
};
#define vtkObserveMRMLNodeEventsMacro(node, events)                           \ …
#endif
 
#ifndef vtkUnObserveMRMLNodeMacro
#define vtkUnObserveMRMLNodeMacro(node)                                       \
{                                                                             \
  this->GetMRMLNodesObserverManager()->RemoveObjectEvents ( (node) );         \
};
#define vtkUnObserveMRMLNodeMacro(node)                                       \ …
#endif
 
#ifndef vtkIsObservedMRMLNodeEventMacro
#define vtkIsObservedMRMLNodeEventMacro(node, event)                          \
  (                                                                           \
  this->GetMRMLNodesObserverManager()->GetObservationsCount(node, event) != 0 \
  )
#define vtkIsObservedMRMLNodeEventMacro(node, event)                          \ …
#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;
 
};
class VTK_MRML_LOGIC_EXPORT vtkMRMLAbstractLogic : public vtkObject {…};
 
//---------------------------------------------------------------------------
bool vtkMRMLAbstractLogic::StartModify()
{
  bool disabledModify = this->GetDisableModifiedEvent();
  this->SetDisableModifiedEvent(true);
  return disabledModify;
}
bool vtkMRMLAbstractLogic::StartModify() {…}
 
//---------------------------------------------------------------------------
int vtkMRMLAbstractLogic::EndModify(bool previousDisableModifiedEventState)
{
  this->SetDisableModifiedEvent(previousDisableModifiedEventState);
  if (!previousDisableModifiedEventState)
  {
    return this->InvokePendingModifiedEvent();
  }
  return this->GetPendingModifiedEventCount();
}
int vtkMRMLAbstractLogic::EndModify(bool previousDisableModifiedEventState) {…}
 
#endif