VTK  9.4.20250512
vtkRenderWindowInteractor.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2// SPDX-License-Identifier: BSD-3-Clause
151#ifndef vtkRenderWindowInteractor_h
152#define vtkRenderWindowInteractor_h
153
154#include "vtkCommand.h" // for method sig
155#include "vtkObject.h"
156#include "vtkRenderingCoreModule.h" // For export macro
157#include "vtkSmartPointer.h" // For InteractorStyle
158#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
159
160VTK_ABI_NAMESPACE_BEGIN
161class vtkTimerIdMap;
162
163// Timer flags for win32/X compatibility
164#define VTKI_TIMER_FIRST 0
165#define VTKI_TIMER_UPDATE 1
166
167// maximum pointers active at once
168// for example in multitouch
169#define VTKI_MAX_POINTERS 5
170
173class vtkAssemblyPath;
176class vtkRenderWindow;
177class vtkRenderer;
181
182class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkRenderWindowInteractor : public vtkObject
183{
184
186
187public:
190 void PrintSelf(ostream& os, vtkIndent indent) override;
191
193
200 virtual void Initialize();
202 {
203 this->Initialized = 0;
204 this->Enabled = 0;
205 this->Initialize();
206 }
208
213 void UnRegister(vtkObjectBase* o) override;
214
220 virtual void Start();
221
228 virtual void ProcessEvents() {}
229
233 vtkGetMacro(Done, bool);
234 vtkSetMacro(Done, bool);
235
245 virtual void Enable()
246 {
247 this->Enabled = 1;
248 this->Modified();
249 }
250 virtual void Disable()
251 {
252 this->Enabled = 0;
253 this->Modified();
254 }
255 vtkGetMacro(Enabled, int);
256
258
262 vtkBooleanMacro(EnableRender, bool);
264 vtkSetMacro(EnableRender, bool);
266 vtkGetMacro(EnableRender, bool);
268
270
273 void SetRenderWindow(vtkRenderWindow* aren);
274 vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
276
278
283 void SetHardwareWindow(vtkHardwareWindow* aren);
284 vtkGetObjectMacro(HardwareWindow, vtkHardwareWindow);
286
295 virtual void UpdateSize(int x, int y);
296
314 virtual int CreateTimer(int timerType); // first group, for backward compatibility
315 virtual int DestroyTimer(); // first group, for backward compatibility
316
321 int CreateRepeatingTimer(unsigned long duration);
322
327 int CreateOneShotTimer(unsigned long duration);
328
333 int IsOneShotTimer(int timerId);
334
338 unsigned long GetTimerDuration(int timerId);
339
343 int ResetTimer(int timerId);
344
349 int DestroyTimer(int timerId);
350
354 virtual int GetVTKTimerId(int platformTimerId);
355
356 // Moved into the public section of the class so that classless timer procs
357 // can access these enum members without being "friends"...
358 enum
359 {
360 OneShotTimer = 1,
361 RepeatingTimer
362 };
363
365
374 vtkSetClampMacro(TimerDuration, unsigned long, 1, 100000);
375 vtkGetMacro(TimerDuration, unsigned long);
377
379
391 vtkSetMacro(TimerEventId, int);
392 vtkGetMacro(TimerEventId, int);
393 vtkSetMacro(TimerEventType, int);
394 vtkGetMacro(TimerEventType, int);
395 vtkSetMacro(TimerEventDuration, int);
396 vtkGetMacro(TimerEventDuration, int);
397 vtkSetMacro(TimerEventPlatformId, int);
398 vtkGetMacro(TimerEventPlatformId, int);
400
406 virtual void TerminateApp() { this->Done = true; }
407
409
416
418
422 vtkSetMacro(LightFollowCamera, vtkTypeBool);
423 vtkGetMacro(LightFollowCamera, vtkTypeBool);
424 vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
426
428
435 vtkSetClampMacro(DesiredUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
436 vtkGetMacro(DesiredUpdateRate, double);
438
440
445 vtkSetClampMacro(StillUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
446 vtkGetMacro(StillUpdateRate, double);
448
450
454 vtkGetMacro(Initialized, int);
456
458
465 vtkGetObjectMacro(Picker, vtkAbstractPicker);
467
473
475
481 virtual void SetPickingManager(vtkPickingManager*);
483 vtkGetObjectMacro(PickingManager, vtkPickingManager);
485
487
491 virtual void ExitCallback();
492 virtual void UserCallback();
493 virtual void StartPickCallback();
494 virtual void EndPickCallback();
496
500 virtual void GetMousePosition(int* x, int* y)
501 {
502 *x = 0;
503 *y = 0;
504 }
505
507
514
519 virtual void Render();
520
522
527 void FlyTo(vtkRenderer* ren, double x, double y, double z);
528 void FlyTo(vtkRenderer* ren, double* x) { this->FlyTo(ren, x[0], x[1], x[2]); }
529 void FlyToImage(vtkRenderer* ren, double x, double y);
530 void FlyToImage(vtkRenderer* ren, double* x) { this->FlyToImage(ren, x[0], x[1]); }
532
534
537 vtkSetClampMacro(NumberOfFlyFrames, int, 1, VTK_INT_MAX);
538 vtkGetMacro(NumberOfFlyFrames, int);
540
542
546 vtkSetMacro(Dolly, double);
547 vtkGetMacro(Dolly, double);
549
551
559 vtkGetVector2Macro(EventPosition, int);
560 vtkGetVector2Macro(LastEventPosition, int);
561 vtkSetVector2Macro(LastEventPosition, int);
562 virtual void SetEventPosition(int x, int y)
563 {
564 vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
565 << "," << y << ")");
566 if (this->EventPosition[0] != x || this->EventPosition[1] != y ||
567 this->LastEventPosition[0] != x || this->LastEventPosition[1] != y)
568 {
569 this->LastEventPosition[0] = this->EventPosition[0];
570 this->LastEventPosition[1] = this->EventPosition[1];
571 this->EventPosition[0] = x;
572 this->EventPosition[1] = y;
573 this->Modified();
574 }
575 }
576 virtual void SetEventPosition(int pos[2]) { this->SetEventPosition(pos[0], pos[1]); }
577 virtual void SetEventPositionFlipY(int x, int y)
578 {
579 this->SetEventPosition(x, this->Size[1] - y - 1);
580 }
581 virtual void SetEventPositionFlipY(int pos[2]) { this->SetEventPositionFlipY(pos[0], pos[1]); }
583
584 virtual int* GetEventPositions(int pointerIndex)
585 {
586 if (pointerIndex >= VTKI_MAX_POINTERS)
587 {
588 return nullptr;
589 }
590 return this->EventPositions[pointerIndex];
591 }
592 virtual int* GetLastEventPositions(int pointerIndex)
593 {
594 if (pointerIndex >= VTKI_MAX_POINTERS)
595 {
596 return nullptr;
597 }
598 return this->LastEventPositions[pointerIndex];
599 }
600 virtual void SetEventPosition(int x, int y, int pointerIndex)
601 {
602 if (pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
603 {
604 return;
605 }
606 if (pointerIndex == 0)
607 {
608 this->LastEventPosition[0] = this->EventPosition[0];
609 this->LastEventPosition[1] = this->EventPosition[1];
610 this->EventPosition[0] = x;
611 this->EventPosition[1] = y;
612 }
613 vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
614 << "," << y << ") for pointerIndex number " << pointerIndex);
615 if (this->EventPositions[pointerIndex][0] != x || this->EventPositions[pointerIndex][1] != y ||
616 this->LastEventPositions[pointerIndex][0] != x ||
617 this->LastEventPositions[pointerIndex][1] != y)
618 {
619 this->LastEventPositions[pointerIndex][0] = this->EventPositions[pointerIndex][0];
620 this->LastEventPositions[pointerIndex][1] = this->EventPositions[pointerIndex][1];
621 this->EventPositions[pointerIndex][0] = x;
622 this->EventPositions[pointerIndex][1] = y;
623 this->Modified();
624 }
625 }
626 virtual void SetEventPosition(int pos[2], int pointerIndex)
627 {
628 this->SetEventPosition(pos[0], pos[1], pointerIndex);
629 }
630 virtual void SetEventPositionFlipY(int x, int y, int pointerIndex)
631 {
632 this->SetEventPosition(x, this->Size[1] - y - 1, pointerIndex);
633 }
634 virtual void SetEventPositionFlipY(int pos[2], int pointerIndex)
635 {
636 this->SetEventPositionFlipY(pos[0], pos[1], pointerIndex);
637 }
638
640
647 vtkSetMacro(AltKey, int);
648 vtkGetMacro(AltKey, int);
650
652
657 vtkSetMacro(ControlKey, int);
658 vtkGetMacro(ControlKey, int);
660
662
665 vtkSetMacro(ShiftKey, int);
666 vtkGetMacro(ShiftKey, int);
668
670
693 vtkSetMacro(KeyCode, char);
694 vtkGetMacro(KeyCode, char);
696
698
702 vtkSetMacro(RepeatCount, int);
703 vtkGetMacro(RepeatCount, int);
705
707
727 vtkSetStringMacro(KeySym);
728 vtkGetStringMacro(KeySym);
730
732
735 vtkSetMacro(PointerIndex, int);
736 vtkGetMacro(PointerIndex, int);
738
740
743 void SetRotation(double rotation);
744 vtkGetMacro(Rotation, double);
745 vtkGetMacro(LastRotation, double);
747
749
752 void SetScale(double scale);
753 vtkGetMacro(Scale, double);
754 vtkGetMacro(LastScale, double);
756
758
761 void SetTranslation(double val[2]);
762 vtkGetVector2Macro(Translation, double);
763 vtkGetVector2Macro(LastTranslation, double);
765
767
770 void SetEventInformation(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
771 const char* keysym, int pointerIndex)
772 {
773 this->SetEventPosition(x, y, pointerIndex);
774 this->ControlKey = ctrl;
775 this->ShiftKey = shift;
776 this->KeyCode = keycode;
777 this->RepeatCount = repeatcount;
778 this->PointerIndex = pointerIndex;
779 if (keysym)
780 {
781 this->SetKeySym(keysym);
782 }
783 this->Modified();
784 }
785 void SetEventInformation(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
786 int repeatcount = 0, const char* keysym = nullptr)
787 {
788 this->SetEventInformation(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
789 }
791
793
797 void SetEventInformationFlipY(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
798 const char* keysym, int pointerIndex)
799 {
800 this->SetEventInformation(
801 x, this->Size[1] - y - 1, ctrl, shift, keycode, repeatcount, keysym, pointerIndex);
802 }
803 void SetEventInformationFlipY(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
804 int repeatcount = 0, const char* keysym = nullptr)
805 {
806 this->SetEventInformationFlipY(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
807 }
809
811
814 void SetKeyEventInformation(int ctrl = 0, int shift = 0, char keycode = 0, int repeatcount = 0,
815 const char* keysym = nullptr)
816 {
817 this->ControlKey = ctrl;
818 this->ShiftKey = shift;
819 this->KeyCode = keycode;
820 this->RepeatCount = repeatcount;
821 if (keysym)
822 {
823 this->SetKeySym(keysym);
824 }
825 this->Modified();
826 }
828
830
841 vtkSetVector2Macro(Size, int);
842 vtkGetVector2Macro(Size, int);
843 vtkSetVector2Macro(EventSize, int);
844 vtkGetVector2Macro(EventSize, int);
846
852 virtual vtkRenderer* FindPokedRenderer(int, int);
853
862
864
872 vtkSetMacro(UseTDx, bool);
873 vtkGetMacro(UseTDx, bool);
875
877
882 virtual void MouseMoveEvent();
883 virtual void RightButtonPressEvent();
885 virtual void LeftButtonPressEvent();
891 virtual void MouseWheelLeftEvent();
892 virtual void MouseWheelRightEvent();
893 virtual void ExposeEvent();
894 virtual void ConfigureEvent();
895 virtual void EnterEvent();
896 virtual void LeaveEvent();
897 virtual void KeyPressEvent();
898 virtual void KeyReleaseEvent();
899 virtual void CharEvent();
900 virtual void ExitEvent();
903 virtual void FifthButtonPressEvent();
906
908
912 virtual void StartPinchEvent();
913 virtual void PinchEvent();
914 virtual void EndPinchEvent();
915 virtual void StartRotateEvent();
916 virtual void RotateEvent();
917 virtual void EndRotateEvent();
918 virtual void StartPanEvent();
919 virtual void PanEvent();
920 virtual void EndPanEvent();
921 virtual void TapEvent();
922 virtual void LongTapEvent();
923 virtual void SwipeEvent();
925
927
933 vtkSetMacro(RecognizeGestures, bool);
934 vtkGetMacro(RecognizeGestures, bool);
936
938
943 vtkGetMacro(PointersDownCount, int);
945
947
954 void ClearContact(size_t contactID);
955 int GetPointerIndexForContact(size_t contactID);
957 bool IsPointerIndexSet(int i);
958 void ClearPointerIndex(int i);
960
980
982
991
992protected:
995
999
1000 // Used as a helper object to pick instances of vtkProp
1003
1004 bool Done; // is the event loop done running
1005
1011
1020
1021 // Event information
1026 double Rotation;
1028 double Scale;
1030 double Translation[2];
1031 double LastTranslation[2];
1033 char* KeySym;
1034 int EventPosition[2];
1035 int LastEventPosition[2];
1036 int EventSize[2];
1037 int Size[2];
1042
1043 int EventPositions[VTKI_MAX_POINTERS][2];
1044 int LastEventPositions[VTKI_MAX_POINTERS][2];
1046
1047 size_t PointerIndexLookup[VTKI_MAX_POINTERS];
1048
1049 // control the fly to
1051 double Dolly;
1052
1062 void GrabFocus(vtkCommand* mouseEvents, vtkCommand* keypressEvents = nullptr)
1063 {
1064 this->Superclass::InternalGrabFocus(mouseEvents, keypressEvents);
1065 }
1066 void ReleaseFocus() { this->Superclass::InternalReleaseFocus(); }
1067
1072
1073 // Timer related members
1074 friend struct vtkTimerStruct;
1075 vtkTimerIdMap* TimerMap; // An internal, PIMPLd map of timers and associated attributes
1076 unsigned long TimerDuration; // in milliseconds
1078
1084 virtual int InternalCreateTimer(int timerId, int timerType, unsigned long duration);
1085 virtual int InternalDestroyTimer(int platformTimerId);
1088
1089 // Force the interactor to handle the Start() event loop, ignoring any
1090 // overrides. (Overrides are registered by observing StartEvent on the
1091 // interactor.)
1093
1097 virtual void StartEventLoop() {}
1098
1099 bool UseTDx; // 3DConnexion device.
1100
1101 // when recognizing gestures VTK will take multitouch events
1102 // if it receives them and convert them to gestures
1105 int PointersDown[VTKI_MAX_POINTERS];
1107 int StartingEventPositions[VTKI_MAX_POINTERS][2];
1109
1110private:
1112 void operator=(const vtkRenderWindowInteractor&) = delete;
1113};
1114
1115VTK_ABI_NAMESPACE_END
1116#endif
define API for picking subclasses
abstract API for pickers that can pick an instance of vtkProp
a list of nodes that form an assembly path
superclass for callback/observer methods
Definition vtkCommand.h:384
create a window for renderers to draw into
a simple class to control print indentation
Definition vtkIndent.h:108
record and play VTK events passing through a vtkRenderWindowInteractor
an abstract superclass for classes observing events invoked by vtkRenderWindowInteractor
abstract base class for most VTK objects
const char * GetClassName() const
Return the class name as a string.
abstract base class for most VTK objects
Definition vtkObject.h:162
virtual void Modified()
Update the modification time for this object.
manage contention for cursors and other resources
Class defines API to manage the picking process.
platform-independent render window interaction including picking and frame rate control.
void HideCursor()
Hide or show the mouse cursor, it is nice to be able to hide the default cursor if you want VTK to di...
virtual void StartEventLoop()
Run the event loop (does not return until TerminateApp is called).
virtual void FourthButtonReleaseEvent()
Fire various events.
virtual void PinchEvent()
Fire various gesture based events.
virtual void SwipeEvent()
Fire various gesture based events.
virtual void StartRotateEvent()
Fire various gesture based events.
void SetKeyEventInformation(int ctrl=0, int shift=0, char keycode=0, int repeatcount=0, const char *keysym=nullptr)
Set all the keyboard-related event information in one call.
void UnRegister(vtkObjectBase *o) override
This Method detects loops of RenderWindow-Interactor, so objects are freed properly.
virtual void SetEventPositionFlipY(int pos[2], int pointerIndex)
virtual void EndPinchEvent()
Fire various gesture based events.
virtual void KeyReleaseEvent()
Fire various events.
virtual int * GetLastEventPositions(int pointerIndex)
virtual void Enable()
Enable/Disable interactions.
virtual int InternalDestroyTimer(int platformTimerId)
Internal methods for creating and destroying timers that must be implemented by subclasses.
vtkObserverMediator * ObserverMediator
Widget mediators are used to resolve contention for cursors and other resources.
virtual void EndRotateEvent()
Fire various gesture based events.
virtual void ExitEvent()
Fire various events.
void FlyToImage(vtkRenderer *ren, double x, double y)
Given a position x, move the current camera's focal point to x.
void SetRotation(double rotation)
Set/get the rotation for the gesture in degrees, update LastRotation.
virtual void ExposeEvent()
Fire various events.
virtual void EndPanEvent()
Fire various gesture based events.
virtual void Render()
Render the scene.
virtual vtkRenderer * FindPokedRenderer(int, int)
When an event occurs, we must determine which Renderer the event occurred within, since one RenderWin...
virtual vtkAbstractPropPicker * CreateDefaultPicker()
Create default picker.
virtual void MouseWheelLeftEvent()
Fire various events.
virtual void MouseWheelForwardEvent()
Fire various events.
virtual void SetEventPosition(int x, int y)
Set/Get information about the current event.
virtual void TerminateApp()
This function is called on 'q','e' keypress if exitmethod is not specified and should be overridden b...
virtual void LeftButtonReleaseEvent()
Fire various events.
virtual void CharEvent()
Fire various events.
void SetEventInformation(int x, int y, int ctrl, int shift, char keycode, int repeatcount, const char *keysym, int pointerIndex)
Set all the event information in one call.
vtkObserverMediator * GetObserverMediator()
Return the object used to mediate between vtkInteractorObservers contending for resources.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual vtkPickingManager * CreateDefaultPickingManager()
Create default pickingManager.
virtual void LeaveEvent()
Fire various events.
static bool InteractorManagesTheEventLoop
This flag is useful when you are integrating VTK in a larger system.
virtual vtkInteractorObserver * GetInteractorStyle()
External switching between joystick/trackball/new? modes.
virtual void FourthButtonPressEvent()
Fire various events.
virtual void MouseWheelRightEvent()
Fire various events.
virtual void EnterEvent()
Fire various events.
virtual int InternalCreateTimer(int timerId, int timerType, unsigned long duration)
Internal methods for creating and destroying timers that must be implemented by subclasses.
~vtkRenderWindowInteractor() override
virtual void RightButtonPressEvent()
Fire various events.
virtual void Start()
Start the event loop.
void SetEventInformation(int x, int y, int ctrl=0, int shift=0, char keycode=0, int repeatcount=0, const char *keysym=nullptr)
Set all the event information in one call.
void ShowCursor()
Hide or show the mouse cursor, it is nice to be able to hide the default cursor if you want VTK to di...
virtual void ConfigureEvent()
Fire various events.
virtual void FifthButtonPressEvent()
Fire various events.
virtual int * GetEventPositions(int pointerIndex)
virtual void StartPanEvent()
Fire various gesture based events.
int GetCurrentTimerId()
Internal methods for creating and destroying timers that must be implemented by subclasses.
virtual void MouseWheelBackwardEvent()
Fire various events.
virtual void SetInteractorStyle(vtkInteractorObserver *)
External switching between joystick/trackball/new? modes.
void ClearContact(size_t contactID)
Most multitouch systems use persistent contact/pointer ids to track events/motion during multitouch e...
void FlyTo(vtkRenderer *ren, double x, double y, double z)
Given a position x, move the current camera's focal point to x.
void ReInitialize()
Prepare for handling events and set the Enabled flag to true.
void SetEventInformationFlipY(int x, int y, int ctrl=0, int shift=0, char keycode=0, int repeatcount=0, const char *keysym=nullptr)
Calls SetEventInformation, but flips the Y based on the current Size[1] value (i.e.
vtkSmartPointer< vtkInteractorObserver > InteractorStyle
void SetTranslation(double val[2])
Set/get the translation for pan/swipe gestures, update LastTranslation.
virtual void SetCurrentGesture(vtkCommand::EventIds eid)
Get the current gesture that was recognized when handling multitouch and VR events.
void FlyToImage(vtkRenderer *ren, double *x)
Given a position x, move the current camera's focal point to x.
virtual void PanEvent()
Fire various gesture based events.
virtual void ProcessEvents()
Process all user-interaction, timer events and return.
virtual void RightButtonReleaseEvent()
Fire various events.
virtual void SetEventPositionFlipY(int x, int y, int pointerIndex)
void SetEventInformationFlipY(int x, int y, int ctrl, int shift, char keycode, int repeatcount, const char *keysym, int pointerIndex)
Calls SetEventInformation, but flips the Y based on the current Size[1] value (i.e.
virtual void SetEventPositionFlipY(int x, int y)
Set/Get information about the current event.
int GetPointerIndexForContact(size_t contactID)
Most multitouch systems use persistent contact/pointer ids to track events/motion during multitouch e...
static vtkRenderWindowInteractor * New()
virtual void FifthButtonReleaseEvent()
Fire various events.
bool IsPointerIndexSet(int i)
Most multitouch systems use persistent contact/pointer ids to track events/motion during multitouch e...
virtual void LeftButtonPressEvent()
Fire various events.
void GrabFocus(vtkCommand *mouseEvents, vtkCommand *keypressEvents=nullptr)
virtual vtkCommand::EventIds GetCurrentGesture() const
Get the current gesture that was recognized when handling multitouch and VR events.
virtual void MiddleButtonPressEvent()
Fire various events.
int GetPointerIndexForExistingContact(size_t contactID)
Most multitouch systems use persistent contact/pointer ids to track events/motion during multitouch e...
virtual void MouseMoveEvent()
Fire various events.
void FlyTo(vtkRenderer *ren, double *x)
Given a position x, move the current camera's focal point to x.
virtual void StartPinchEvent()
Fire various gesture based events.
virtual void SetEventPosition(int pos[2])
Set/Get information about the current event.
virtual void SetPicker(vtkAbstractPicker *)
Set/Get the object used to perform pick operations.
void SetScale(double scale)
Set/get the scale for the gesture, updates LastScale.
virtual void Initialize()
Prepare for handling events and set the Enabled flag to true.
virtual void RotateEvent()
Fire various gesture based events.
virtual void TapEvent()
Fire various gesture based events.
virtual void SetEventPositionFlipY(int pos[2])
Set/Get information about the current event.
virtual void SetEventPosition(int x, int y, int pointerIndex)
void ClearPointerIndex(int i)
Most multitouch systems use persistent contact/pointer ids to track events/motion during multitouch e...
virtual void LongTapEvent()
Fire various gesture based events.
virtual void MiddleButtonReleaseEvent()
Fire various events.
virtual void RecognizeGesture(vtkCommand::EventIds)
virtual void SetEventPosition(int pos[2], int pointerIndex)
virtual void KeyPressEvent()
Fire various events.
create a window for renderers to draw into
abstract specification for renderers
Hold a reference to a vtkObjectBase instance.
int vtkTypeBool
Definition vtkABI.h:64
#define VTKI_MAX_POINTERS
#define VTK_INT_MAX
Definition vtkType.h:161
#define VTK_FLOAT_MAX
Definition vtkType.h:169
#define VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL
#define VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED
#define VTK_MARSHALAUTO
#define VTK_MARSHALEXCLUDE(reason)