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