VTK  9.1.0
vtkObject.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkObject.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
50#ifndef vtkObject_h
51#define vtkObject_h
52
53#include "vtkCommonCoreModule.h" // For export macro
54#include "vtkObjectBase.h"
55#include "vtkSetGet.h"
56#include "vtkTimeStamp.h"
57#include "vtkWeakPointerBase.h" // needed for vtkWeakPointer
58
59class vtkSubjectHelper;
60class vtkCommand;
61
62class VTKCOMMONCORE_EXPORT vtkObject : public vtkObjectBase
63{
64public:
66
71 static vtkObject* New();
72
73#ifdef _WIN32
74 // avoid dll boundary problems
75 void* operator new(size_t tSize);
76 void operator delete(void* p);
77#endif
78
82 virtual void DebugOn();
83
87 virtual void DebugOff();
88
92 bool GetDebug();
93
97 void SetDebug(bool debugFlag);
98
103 static void BreakOnError();
104
111 virtual void Modified();
112
117
124 void PrintSelf(ostream& os, vtkIndent indent) override;
125
127
131 static void SetGlobalWarningDisplay(int val);
136
138
150 unsigned long AddObserver(unsigned long event, vtkCommand*, float priority = 0.0f);
151 unsigned long AddObserver(const char* event, vtkCommand*, float priority = 0.0f);
152 vtkCommand* GetCommand(unsigned long tag);
154 void RemoveObservers(unsigned long event, vtkCommand*);
155 void RemoveObservers(const char* event, vtkCommand*);
156 vtkTypeBool HasObserver(unsigned long event, vtkCommand*);
157 vtkTypeBool HasObserver(const char* event, vtkCommand*);
159
160 void RemoveObserver(unsigned long tag);
161 void RemoveObservers(unsigned long event);
162 void RemoveObservers(const char* event);
163 void RemoveAllObservers(); // remove every last one of them
164 vtkTypeBool HasObserver(unsigned long event);
165 vtkTypeBool HasObserver(const char* event);
166
168
193 template <class U, class T>
194 unsigned long AddObserver(
195 unsigned long event, U observer, void (T::*callback)(), float priority = 0.0f)
196 {
197 vtkClassMemberCallback<T>* callable = new vtkClassMemberCallback<T>(observer, callback);
198 // callable is deleted when the observer is cleaned up (look at
199 // vtkObjectCommandInternal)
200 return this->AddTemplatedObserver(event, callable, priority);
201 }
202 template <class U, class T>
203 unsigned long AddObserver(unsigned long event, U observer,
204 void (T::*callback)(vtkObject*, unsigned long, void*), float priority = 0.0f)
205 {
206 vtkClassMemberCallback<T>* callable = new vtkClassMemberCallback<T>(observer, callback);
207 // callable is deleted when the observer is cleaned up (look at
208 // vtkObjectCommandInternal)
209 return this->AddTemplatedObserver(event, callable, priority);
210 }
212
214
218 template <class U, class T>
219 unsigned long AddObserver(unsigned long event, U observer,
220 bool (T::*callback)(vtkObject*, unsigned long, void*), float priority = 0.0f)
221 {
222 vtkClassMemberCallback<T>* callable = new vtkClassMemberCallback<T>(observer, callback);
223 // callable is deleted when the observer is cleaned up (look at
224 // vtkObjectCommandInternal)
225 return this->AddTemplatedObserver(event, callable, priority);
226 }
228
230
235 int InvokeEvent(unsigned long event, void* callData);
236 int InvokeEvent(const char* event, void* callData);
238
239 int InvokeEvent(unsigned long event) { return this->InvokeEvent(event, nullptr); }
240 int InvokeEvent(const char* event) { return this->InvokeEvent(event, nullptr); }
241
242protected:
244 ~vtkObject() override;
245
246 // See vtkObjectBase.h.
249
250 bool Debug; // Enable debug messages
251 vtkTimeStamp MTime; // Keep track of modification time
252 vtkSubjectHelper* SubjectHelper; // List of observers on this object
253
255
263 void InternalGrabFocus(vtkCommand* mouseEvents, vtkCommand* keypressEvents = nullptr);
266
267private:
268 vtkObject(const vtkObject&) = delete;
269 void operator=(const vtkObject&) = delete;
270
278 class vtkClassMemberCallbackBase
279 {
280 public:
282
285 virtual bool operator()(vtkObject*, unsigned long, void*) = 0;
286 virtual ~vtkClassMemberCallbackBase() = default;
288 };
289
291
295 template <class T>
296 class vtkClassMemberHandlerPointer
297 {
298 public:
299 void operator=(vtkObjectBase* o)
300 {
301 // The cast is needed in case "o" has multi-inheritance,
302 // to offset the pointer to get the vtkObjectBase.
303 if ((this->VoidPointer = dynamic_cast<T*>(o)) == nullptr)
304 {
305 // fallback to just using its vtkObjectBase as-is.
306 this->VoidPointer = o;
307 }
308 this->WeakPointer = o;
309 this->UseWeakPointer = true;
310 }
311 void operator=(void* o)
312 {
313 this->VoidPointer = o;
314 this->WeakPointer = nullptr;
315 this->UseWeakPointer = false;
316 }
317 T* GetPointer()
318 {
319 if (this->UseWeakPointer && !this->WeakPointer.GetPointer())
320 {
321 return nullptr;
322 }
323 return static_cast<T*>(this->VoidPointer);
324 }
325
326 private:
327 vtkWeakPointerBase WeakPointer;
328 void* VoidPointer;
329 bool UseWeakPointer;
330 };
332
334
337 template <class T>
338 class vtkClassMemberCallback : public vtkClassMemberCallbackBase
339 {
340 vtkClassMemberHandlerPointer<T> Handler;
341 void (T::*Method1)();
342 void (T::*Method2)(vtkObject*, unsigned long, void*);
343 bool (T::*Method3)(vtkObject*, unsigned long, void*);
344
345 public:
346 vtkClassMemberCallback(T* handler, void (T::*method)())
347 {
348 this->Handler = handler;
349 this->Method1 = method;
350 this->Method2 = nullptr;
351 this->Method3 = nullptr;
352 }
353
354 vtkClassMemberCallback(T* handler, void (T::*method)(vtkObject*, unsigned long, void*))
355 {
356 this->Handler = handler;
357 this->Method1 = nullptr;
358 this->Method2 = method;
359 this->Method3 = nullptr;
360 }
361
362 vtkClassMemberCallback(T* handler, bool (T::*method)(vtkObject*, unsigned long, void*))
363 {
364 this->Handler = handler;
365 this->Method1 = nullptr;
366 this->Method2 = nullptr;
367 this->Method3 = method;
368 }
369 ~vtkClassMemberCallback() override = default;
370
371 // Called when the event is invoked
372 bool operator()(vtkObject* caller, unsigned long event, void* calldata) override
373 {
374 T* handler = this->Handler.GetPointer();
375 if (handler)
376 {
377 if (this->Method1)
378 {
379 (handler->*this->Method1)();
380 }
381 else if (this->Method2)
382 {
383 (handler->*this->Method2)(caller, event, calldata);
384 }
385 else if (this->Method3)
386 {
387 return (handler->*this->Method3)(caller, event, calldata);
388 }
389 }
390 return false;
391 }
392 };
394
396
399 unsigned long AddTemplatedObserver(
400 unsigned long event, vtkClassMemberCallbackBase* callable, float priority);
401 // Friend to access AddTemplatedObserver().
402 friend class vtkObjectCommandInternal;
404};
405
406#endif
407// VTK-HeaderTest-Exclude: vtkObject.h
superclass for callback/observer methods
Definition: vtkCommand.h:394
a simple class to control print indentation
Definition: vtkIndent.h:34
abstract base class for most VTK objects
Definition: vtkObjectBase.h:70
void operator=(const vtkObjectBase &)
abstract base class for most VTK objects
Definition: vtkObject.h:63
vtkBaseTypeMacro(vtkObject, vtkObjectBase)
void InternalReleaseFocus()
These methods allow a command to exclusively grab all events.
virtual void DebugOn()
Turn debugging output on.
vtkTypeBool HasObserver(unsigned long event)
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void RemoveObservers(const char *event)
vtkSubjectHelper * SubjectHelper
Definition: vtkObject.h:252
unsigned long AddObserver(unsigned long event, U observer, bool(T::*callback)(vtkObject *, unsigned long, void *), float priority=0.0f)
Allow user to set the AbortFlagOn() with the return value of the callback method.
Definition: vtkObject.h:219
vtkTypeBool HasObserver(const char *event, vtkCommand *)
Allow people to add/remove/invoke observers (callbacks) to any VTK object.
virtual void DebugOff()
Turn debugging output off.
unsigned long AddObserver(unsigned long event, U observer, void(T::*callback)(vtkObject *, unsigned long, void *), float priority=0.0f)
Overloads to AddObserver that allow developers to add class member functions as callbacks for events.
Definition: vtkObject.h:203
~vtkObject() override
vtkTimeStamp MTime
Definition: vtkObject.h:251
void InternalGrabFocus(vtkCommand *mouseEvents, vtkCommand *keypressEvents=nullptr)
These methods allow a command to exclusively grab all events.
static void SetGlobalWarningDisplay(int val)
This is a global flag that controls whether any debug, warning or error messages are displayed.
void RemoveObserver(vtkCommand *)
Allow people to add/remove/invoke observers (callbacks) to any VTK object.
void RemoveObservers(unsigned long event, vtkCommand *)
Allow people to add/remove/invoke observers (callbacks) to any VTK object.
int InvokeEvent(unsigned long event)
Definition: vtkObject.h:239
void UnRegisterInternal(vtkObjectBase *, vtkTypeBool check) override
void RemoveAllObservers()
void RegisterInternal(vtkObjectBase *, vtkTypeBool check) override
static void GlobalWarningDisplayOff()
This is a global flag that controls whether any debug, warning or error messages are displayed.
Definition: vtkObject.h:133
int InvokeEvent(const char *event, void *callData)
This method invokes an event and return whether the event was aborted or not.
virtual void Modified()
Update the modification time for this object.
vtkTypeBool HasObserver(unsigned long event, vtkCommand *)
Allow people to add/remove/invoke observers (callbacks) to any VTK object.
int InvokeEvent(unsigned long event, void *callData)
This method invokes an event and return whether the event was aborted or not.
bool Debug
Definition: vtkObject.h:250
static int GetGlobalWarningDisplay()
This is a global flag that controls whether any debug, warning or error messages are displayed.
unsigned long AddObserver(unsigned long event, vtkCommand *, float priority=0.0f)
Allow people to add/remove/invoke observers (callbacks) to any VTK object.
void RemoveObservers(const char *event, vtkCommand *)
Allow people to add/remove/invoke observers (callbacks) to any VTK object.
unsigned long AddObserver(const char *event, vtkCommand *, float priority=0.0f)
Allow people to add/remove/invoke observers (callbacks) to any VTK object.
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on.
void SetDebug(bool debugFlag)
Set the value of the debug flag.
vtkTypeBool HasObserver(const char *event)
static void BreakOnError()
This method is called when vtkErrorMacro executes.
static void GlobalWarningDisplayOn()
This is a global flag that controls whether any debug, warning or error messages are displayed.
Definition: vtkObject.h:132
bool GetDebug()
Get the value of the debug flag.
virtual vtkMTimeType GetMTime()
Return this object's modified time.
void RemoveObservers(unsigned long event)
int InvokeEvent(const char *event)
Definition: vtkObject.h:240
void RemoveObserver(unsigned long tag)
unsigned long AddObserver(unsigned long event, U observer, void(T::*callback)(), float priority=0.0f)
Overloads to AddObserver that allow developers to add class member functions as callbacks for events.
Definition: vtkObject.h:194
vtkCommand * GetCommand(unsigned long tag)
Allow people to add/remove/invoke observers (callbacks) to any VTK object.
record modification and/or execution time
Definition: vtkTimeStamp.h:33
Non-templated superclass for vtkWeakPointer.
int vtkTypeBool
Definition: vtkABI.h:69
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:287