vtkEventBroker.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.
 
  Program:   3D Slicer
  Module:    $RCSfile: vtkEventBroker.h,v $
  Date:      $Date: 2006/01/08 04:48:05 $
  Version:   $Revision: 1.45 $
 
=========================================================================auto=*/
 
#ifndef __vtkEventBroker_h
#define __vtkEventBroker_h
 
// MRML includes
#include "vtkMRML.h"
 
// VTK includes
#include <vtkObject.h>
class vtkTimerLog;
 
// STD includes
#include <deque>
#include <vector>
#include <set>
#include <map>
#include <fstream>
 
class vtkCollection;
class vtkCallbackCommand;
class vtkObservation;

//
class VTK_MRML_EXPORT vtkEventBroker : public vtkObject
{
public:
  vtkTypeMacro(vtkEventBroker, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  typedef std::set<vtkObservation*> ObservationVector;

  static vtkEventBroker* GetInstance();

  static vtkEventBroker* New();

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

  vtkObservation* AddObservation(vtkObject* subject, unsigned long event, vtkObject* observer, vtkCallbackCommand* notify, float priority = 0.0f);

  vtkObservation* AddObservation(vtkObject* subject, const char* event, const char* script);

  void RemoveObservation(vtkObservation* observation);

  void RemoveObservations(ObservationVector observations);
  void RemoveObservations(vtkObject* observer);
  void RemoveObservations(vtkObject* subject, vtkObject* observer);
  void RemoveObservations(vtkObject* subject, unsigned long event, vtkObject* observer);
  void RemoveObservations(vtkObject* subject, unsigned long event, vtkObject* observer, vtkCallbackCommand* notify);
  void RemoveObservationsForSubjectByTag(vtkObject* subject, unsigned long tag);
  ObservationVector GetSubjectObservations(vtkObject* subject);
  ObservationVector GetObservations(vtkObject* subject,
                                    unsigned long event = 0,
                                    vtkObject* observer = nullptr,
                                    vtkCallbackCommand* notify = nullptr,
                                    unsigned int maxReturnedObservations = 0);
  bool GetObservationExist(vtkObject* subject, unsigned long event = 0, vtkObject* observer = nullptr, vtkCallbackCommand* notify = nullptr);
  ObservationVector GetObservationsForSubjectByTag(vtkObject* subject, unsigned long tag);

  vtkCollection* GetObservationsForSubject(vtkObject* subject);
  vtkCollection* GetObservationsForObserver(vtkObject* observer);
  vtkCollection* GetObservationsForCallback(vtkCallbackCommand* callback);

  int GetNumberOfObservations();
  vtkObservation* GetNthObservation(int n);

  void ProcessEvent(vtkObservation* observation, vtkObject* caller, unsigned long eid, void* callData);

  vtkBooleanMacro(EventLogging, int);
  vtkSetMacro(EventLogging, int);
  vtkGetMacro(EventLogging, int);

  vtkSetMacro(EventNestingLevel, int);
  vtkGetMacro(EventNestingLevel, int);

  vtkSetStringMacro(LogFileName);
  vtkGetStringMacro(LogFileName);

  virtual void SetTimerLog(vtkTimerLog* timerLog);
  vtkGetObjectMacro(TimerLog, vtkTimerLog);

  void OpenLogFile();
  void CloseLogFile();

  void LogEvent(vtkObservation* observation);

  int GenerateGraphFile(const char* graphFile);

  enum EventMode
  {
    Synchronous,
    Asynchronous
  };
  vtkGetMacro(EventMode, int);
  void SetEventMode(int eventMode)
  {
    if (eventMode != this->EventMode)
    {
      this->EventMode = eventMode;
      this->ProcessEventQueue();
      this->Modified();
    }
  };
 
  void SetEventModeToSynchronous() { this->SetEventMode(vtkEventBroker::Synchronous); };
  void SetEventModeToAsynchronous() { this->SetEventMode(vtkEventBroker::Asynchronous); };
  const char* GetEventModeAsString()
  {
    if (this->EventMode == vtkEventBroker::Synchronous)
    {
      return ("Synchronous");
    }
    if (this->EventMode == vtkEventBroker::Asynchronous)
    {
      return ("Asynchronous");
    }
    return "Undefined";
  }


  void QueueObservation(vtkObservation* observation, unsigned long eid, void* callData);
  int GetNumberOfQueuedObservations();
  vtkObservation* GetNthQueuedObservation(int n);
  vtkObservation* DequeueObservation();
  void InvokeObservation(vtkObservation* observation, unsigned long eid, void* callData);
  void ProcessEventQueue();

  vtkBooleanMacro(CompressCallData, int);
  vtkGetMacro(CompressCallData, int);
  vtkSetMacro(CompressCallData, int);

  void SetScriptHandler(void (*scriptHandler)(const char* script, void* clientData), void* clientData)
  {
    this->ScriptHandler = scriptHandler;
    this->ScriptHandlerClientData = clientData;
  }

  virtual bool RequestModified(vtkObject* object);

  virtual void SetRequestModifiedCallback(vtkCallbackCommand* callback);
  vtkGetObjectMacro(RequestModifiedCallback, vtkCallbackCommand);
 
protected:
  vtkEventBroker();
  ~vtkEventBroker() override;
  vtkEventBroker(const vtkEventBroker&);
  void operator=(const vtkEventBroker&);

  static void classInitialize();
  static void classFinalize();

  void AttachObservation(vtkObservation* observation);
  void DetachObservation(vtkObservation* observation);
 
  friend class vtkEventBrokerInitialize;
  typedef vtkEventBroker Self;

  typedef std::map<vtkObject*, ObservationVector> ObjectToObservationVectorMap;

  ObjectToObservationVectorMap SubjectMap;
  ObjectToObservationVectorMap ObserverMap;

  std::deque<vtkObservation*> EventQueue;
 
  void (*ScriptHandler)(const char* script, void* clientData);
  void* ScriptHandlerClientData;
 
  int EventLogging;
  int EventNestingLevel;
  char* LogFileName;
  vtkTimerLog* TimerLog;
 
  int EventMode;
  int CompressCallData;
 
  std::ofstream LogFile;
 
  vtkCallbackCommand* RequestModifiedCallback;
 
private:
  void DetachObservations();
  friend class vtkObservation;
};

class VTK_MRML_EXPORT vtkEventBrokerInitialize
{
public:
  typedef vtkEventBrokerInitialize Self;
 
  vtkEventBrokerInitialize();
  ~vtkEventBrokerInitialize();
 
private:
  static unsigned int Count;
};

static vtkEventBrokerInitialize vtkEventBrokerInitializer;
 
#endif