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