vtkObject.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkObject.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkObject_h
#define vtkObject_h
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkObjectBase.h"
#include "vtkSetGet.h"
#include "vtkTimeStamp.h"
#include "vtkWeakPointerBase.h" // needed for vtkWeakPointer
 
class vtkSubjectHelper;
class vtkCommand;
 
class VTKCOMMONCORE_EXPORT vtkObject : public vtkObjectBase
{
public:
  vtkTypeMacro(vtkObject,vtkObjectBase);
 
  static vtkObject *New();
 
#ifdef _WIN32
  // avoid dll boundary problems
  void* operator new( size_t tSize );
  void operator delete( void* p );
#endif
 
  virtual void DebugOn();
 
  virtual void DebugOff();
 
  bool GetDebug();
 
  void SetDebug(bool debugFlag);
 
  static void BreakOnError();
 
  virtual void Modified();
 
  virtual unsigned long GetMTime();
 
  virtual void PrintSelf(ostream& os, vtkIndent indent);
 
 
  static void SetGlobalWarningDisplay(int val);
  static void GlobalWarningDisplayOn(){vtkObject::SetGlobalWarningDisplay(1);};
  static void GlobalWarningDisplayOff()
    {vtkObject::SetGlobalWarningDisplay(0);};
  static int  GetGlobalWarningDisplay();
 
//BTX
 
  unsigned long AddObserver(unsigned long event, vtkCommand *,
                            float priority=0.0f);
  unsigned long AddObserver(const char *event, vtkCommand *,
                            float priority=0.0f);
  vtkCommand *GetCommand(unsigned long tag);
  void RemoveObserver(vtkCommand*);
  void RemoveObservers(unsigned long event, vtkCommand *);
  void RemoveObservers(const char *event, vtkCommand *);
  int HasObserver(unsigned long event, vtkCommand *);
  int HasObserver(const char *event, vtkCommand *);
//ETX
  void RemoveObserver(unsigned long tag);
  void RemoveObservers(unsigned long event);
  void RemoveObservers(const char *event);
  void RemoveAllObservers(); //remove every last one of them
  int HasObserver(unsigned long event);
  int HasObserver(const char *event);
 
//BTX
 
  template <class U, class T>
  unsigned long AddObserver(unsigned long event,
    U observer, void (T::*callback)(), float priority=0.0f)
    {
    vtkClassMemberCallback<T> *callable =
      new vtkClassMemberCallback<T>(observer, callback);
    // callable is deleted when the observer is cleaned up (look at
    // vtkObjectCommandInternal)
    return this->AddTemplatedObserver(event, callable, priority);
    }
  template <class U, class T>
  unsigned long AddObserver(unsigned long event,
    U observer, void (T::*callback)(vtkObject*, unsigned long, void*),
    float priority=0.0f)
    {
    vtkClassMemberCallback<T> *callable =
      new vtkClassMemberCallback<T>(observer, callback);
    // callable is deleted when the observer is cleaned up (look at
    // vtkObjectCommandInternal)
    return this->AddTemplatedObserver(event, callable, priority);
    }
 
 
  template <class U, class T>
  unsigned long AddObserver(unsigned long event,
    U observer, bool (T::*callback)(vtkObject*, unsigned long, void*),
    float priority=0.0f)
    {
    vtkClassMemberCallback<T> *callable =
      new vtkClassMemberCallback<T>(observer, callback);
    // callable is deleted when the observer is cleaned up (look at
    // vtkObjectCommandInternal)
    return this->AddTemplatedObserver(event, callable, priority);
    }
//ETX
 
//BTX
 
  int InvokeEvent(unsigned long event, void *callData);
  int InvokeEvent(const char *event, void *callData);
//ETX
  int InvokeEvent(unsigned long event) { return this->InvokeEvent(event, NULL); };
  int InvokeEvent(const char *event) { return this->InvokeEvent(event, NULL); };
 
protected:
  vtkObject();
  virtual ~vtkObject();
 
  // See vtkObjectBase.h.
  virtual void RegisterInternal(vtkObjectBase*, int check);
  virtual void UnRegisterInternal(vtkObjectBase*, int check);
 
  bool     Debug;      // Enable debug messages
  vtkTimeStamp      MTime;      // Keep track of modification time
  vtkSubjectHelper *SubjectHelper; // List of observers on this object
 
//BTX
 
  void InternalGrabFocus(vtkCommand *mouseEvents, vtkCommand *keypressEvents=NULL);
  void InternalReleaseFocus();
//ETX
//BTX
private:
  vtkObject(const vtkObject&);  // Not implemented.
  void operator=(const vtkObject&);  // Not implemented.
 
 
  class vtkClassMemberCallbackBase
    {
  public:
 
 
    virtual bool operator()(vtkObject*, unsigned long, void*) = 0;
    virtual ~vtkClassMemberCallbackBase(){}
    };
 
 
  template<class T>
    class vtkClassMemberHandlerPointer
      {
    public:
      void operator=(vtkObjectBase *o)
        {
        // The cast is needed in case "o" has multi-inheritance,
        // to offset the pointer to get the vtkObjectBase.
        if ((this->VoidPointer = dynamic_cast<T*>(o)) == 0)
          {
          // fallback to just using its vtkObjectBase as-is.
          this->VoidPointer = o;
          }
        this->WeakPointer = o;
        this->UseWeakPointer = true;
        }
      void operator=(void *o)
        {
        this->VoidPointer = o;
        this->WeakPointer = 0;
        this->UseWeakPointer = false;
        }
      T *GetPointer()
        {
        if (this->UseWeakPointer && !this->WeakPointer.GetPointer())
          {
          return 0;
          }
        return static_cast<T*>(this->VoidPointer);
        }
    private:
      vtkWeakPointerBase WeakPointer;
      void *VoidPointer;
      bool UseWeakPointer;
      };
 
 
  template <class T>
    class vtkClassMemberCallback : public vtkClassMemberCallbackBase
      {
      vtkClassMemberHandlerPointer<T> Handler;
      void (T::*Method1)();
      void (T::*Method2)(vtkObject*, unsigned long, void*);
      bool (T::*Method3)(vtkObject*, unsigned long, void*);
 
    public:
      vtkClassMemberCallback(T* handler, void (T::*method)())
        {
        this->Handler = handler;
        this->Method1 = method;
        this->Method2 = NULL;
        this->Method3 = NULL;
        }
 
      vtkClassMemberCallback(
        T* handler, void (T::*method)(vtkObject*, unsigned long, void*))
        {
        this->Handler = handler;
        this->Method1 = NULL;
        this->Method2 = method;
        this->Method3 = NULL;
        }
 
      vtkClassMemberCallback(
        T* handler, bool (T::*method)(vtkObject*, unsigned long, void*))
        {
        this->Handler = handler;
        this->Method1 = NULL;
        this->Method2 = NULL;
        this->Method3 = method;
        }
      virtual ~vtkClassMemberCallback() { }
 
      // Called when the event is invoked
      virtual bool operator()(
        vtkObject* caller, unsigned long event, void* calldata)
        {
        T *handler = this->Handler.GetPointer();
        if (handler)
          {
          if (this->Method1)
            {
            (handler->*this->Method1)();
            }
          else if (this->Method2)
            {
            (handler->*this->Method2)(caller, event, calldata);
            }
          else if (this->Method3)
            {
            return (handler->*this->Method3)(caller, event, calldata);
            }
          }
        return false;
        }
      };
 
 
  unsigned long AddTemplatedObserver(
    unsigned long event, vtkClassMemberCallbackBase* callable, float priority);
  // Friend to access AddTemplatedObserver().
  friend class vtkObjectCommandInternal;
//ETX
};
 
#endif
// VTK-HeaderTest-Exclude: vtkObject.h