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) VTK_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=0);

protected:

  vtkMRMLAbstractLogic();
  virtual ~vtkMRMLAbstractLogic();

  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=0);

  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);

  virtual void Modified() VTK_OVERRIDE;

  int InvokePendingModifiedEvent();

  int GetPendingModifiedEventCount()const;

private:

  vtkMRMLAbstractLogic(const vtkMRMLAbstractLogic&); // Not implemented
  void operator=(const vtkMRMLAbstractLogic&);       // Not implemented

  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