VTK  9.1.0
vtkRenderWindowInteractor.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkRenderWindowInteractor.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=========================================================================*/
54#ifndef vtkRenderWindowInteractor_h
55#define vtkRenderWindowInteractor_h
56
57#include "vtkCommand.h" // for method sig
58#include "vtkObject.h"
59#include "vtkRenderingCoreModule.h" // For export macro
60
61class vtkTimerIdMap;
62
63// Timer flags for win32/X compatibility
64#define VTKI_TIMER_FIRST 0
65#define VTKI_TIMER_UPDATE 1
66
67// maximum pointers active at once
68// for example in multitouch
69#define VTKI_MAX_POINTERS 5
70
73class vtkAssemblyPath;
76class vtkRenderWindow;
77class vtkRenderer;
81
82class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor : public vtkObject
83{
84
86
87public:
90 void PrintSelf(ostream& os, vtkIndent indent) override;
91
93
100 virtual void Initialize();
102 {
103 this->Initialized = 0;
104 this->Enabled = 0;
105 this->Initialize();
106 }
108
113 void UnRegister(vtkObjectBase* o) override;
114
120 virtual void Start();
121
127 virtual void ProcessEvents() {}
128
132 vtkGetMacro(Done, bool);
133 vtkSetMacro(Done, bool);
134
144 virtual void Enable()
145 {
146 this->Enabled = 1;
147 this->Modified();
148 }
149 virtual void Disable()
150 {
151 this->Enabled = 0;
152 this->Modified();
153 }
154 vtkGetMacro(Enabled, int);
155
157
161 vtkBooleanMacro(EnableRender, bool);
162 vtkSetMacro(EnableRender, bool);
163 vtkGetMacro(EnableRender, bool);
165
167
171 vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
173
175
181 vtkGetObjectMacro(HardwareWindow, vtkHardwareWindow);
183
191 virtual void UpdateSize(int x, int y);
192
209 virtual int CreateTimer(int timerType); // first group, for backward compatibility
210 virtual int DestroyTimer(); // first group, for backward compatibility
211
216 int CreateRepeatingTimer(unsigned long duration);
217
222 int CreateOneShotTimer(unsigned long duration);
223
228 int IsOneShotTimer(int timerId);
229
233 unsigned long GetTimerDuration(int timerId);
234
238 int ResetTimer(int timerId);
239
244 int DestroyTimer(int timerId);
245
249 virtual int GetVTKTimerId(int platformTimerId);
250
251 // Moved into the public section of the class so that classless timer procs
252 // can access these enum members without being "friends"...
253 enum
254 {
255 OneShotTimer = 1,
256 RepeatingTimer
257 };
258
260
269 vtkSetClampMacro(TimerDuration, unsigned long, 1, 100000);
270 vtkGetMacro(TimerDuration, unsigned long);
272
274
286 vtkSetMacro(TimerEventId, int);
287 vtkGetMacro(TimerEventId, int);
288 vtkSetMacro(TimerEventType, int);
289 vtkGetMacro(TimerEventType, int);
290 vtkSetMacro(TimerEventDuration, int);
291 vtkGetMacro(TimerEventDuration, int);
292 vtkSetMacro(TimerEventPlatformId, int);
293 vtkGetMacro(TimerEventPlatformId, int);
295
301 virtual void TerminateApp(void) { this->Done = true; }
302
304
309 vtkGetObjectMacro(InteractorStyle, vtkInteractorObserver);
311
313
317 vtkSetMacro(LightFollowCamera, vtkTypeBool);
318 vtkGetMacro(LightFollowCamera, vtkTypeBool);
319 vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
321
323
330 vtkSetClampMacro(DesiredUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
331 vtkGetMacro(DesiredUpdateRate, double);
333
335
340 vtkSetClampMacro(StillUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
341 vtkGetMacro(StillUpdateRate, double);
343
345
349 vtkGetMacro(Initialized, int);
351
353
360 vtkGetObjectMacro(Picker, vtkAbstractPicker);
362
368
370
376 vtkGetObjectMacro(PickingManager, vtkPickingManager);
378
380
384 virtual void ExitCallback();
385 virtual void UserCallback();
386 virtual void StartPickCallback();
387 virtual void EndPickCallback();
389
393 virtual void GetMousePosition(int* x, int* y)
394 {
395 *x = 0;
396 *y = 0;
397 }
398
400
407
412 virtual void Render();
413
415
420 void FlyTo(vtkRenderer* ren, double x, double y, double z);
421 void FlyTo(vtkRenderer* ren, double* x) { this->FlyTo(ren, x[0], x[1], x[2]); }
422 void FlyToImage(vtkRenderer* ren, double x, double y);
423 void FlyToImage(vtkRenderer* ren, double* x) { this->FlyToImage(ren, x[0], x[1]); }
425
427
430 vtkSetClampMacro(NumberOfFlyFrames, int, 1, VTK_INT_MAX);
431 vtkGetMacro(NumberOfFlyFrames, int);
433
435
439 vtkSetMacro(Dolly, double);
440 vtkGetMacro(Dolly, double);
442
444
452 vtkGetVector2Macro(EventPosition, int);
453 vtkGetVector2Macro(LastEventPosition, int);
454 vtkSetVector2Macro(LastEventPosition, int);
455 virtual void SetEventPosition(int x, int y)
456 {
457 vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
458 << "," << y << ")");
459 if (this->EventPosition[0] != x || this->EventPosition[1] != y ||
460 this->LastEventPosition[0] != x || this->LastEventPosition[1] != y)
461 {
462 this->LastEventPosition[0] = this->EventPosition[0];
463 this->LastEventPosition[1] = this->EventPosition[1];
464 this->EventPosition[0] = x;
465 this->EventPosition[1] = y;
466 this->Modified();
467 }
468 }
469 virtual void SetEventPosition(int pos[2]) { this->SetEventPosition(pos[0], pos[1]); }
470 virtual void SetEventPositionFlipY(int x, int y)
471 {
472 this->SetEventPosition(x, this->Size[1] - y - 1);
473 }
474 virtual void SetEventPositionFlipY(int pos[2]) { this->SetEventPositionFlipY(pos[0], pos[1]); }
476
477 virtual int* GetEventPositions(int pointerIndex)
478 {
479 if (pointerIndex >= VTKI_MAX_POINTERS)
480 {
481 return nullptr;
482 }
483 return this->EventPositions[pointerIndex];
484 }
485 virtual int* GetLastEventPositions(int pointerIndex)
486 {
487 if (pointerIndex >= VTKI_MAX_POINTERS)
488 {
489 return nullptr;
490 }
491 return this->LastEventPositions[pointerIndex];
492 }
493 virtual void SetEventPosition(int x, int y, int pointerIndex)
494 {
495 if (pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
496 {
497 return;
498 }
499 if (pointerIndex == 0)
500 {
501 this->LastEventPosition[0] = this->EventPosition[0];
502 this->LastEventPosition[1] = this->EventPosition[1];
503 this->EventPosition[0] = x;
504 this->EventPosition[1] = y;
505 }
506 vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
507 << "," << y << ") for pointerIndex number " << pointerIndex);
508 if (this->EventPositions[pointerIndex][0] != x || this->EventPositions[pointerIndex][1] != y ||
509 this->LastEventPositions[pointerIndex][0] != x ||
510 this->LastEventPositions[pointerIndex][1] != y)
511 {
512 this->LastEventPositions[pointerIndex][0] = this->EventPositions[pointerIndex][0];
513 this->LastEventPositions[pointerIndex][1] = this->EventPositions[pointerIndex][1];
514 this->EventPositions[pointerIndex][0] = x;
515 this->EventPositions[pointerIndex][1] = y;
516 this->Modified();
517 }
518 }
519 virtual void SetEventPosition(int pos[2], int pointerIndex)
520 {
521 this->SetEventPosition(pos[0], pos[1], pointerIndex);
522 }
523 virtual void SetEventPositionFlipY(int x, int y, int pointerIndex)
524 {
525 this->SetEventPosition(x, this->Size[1] - y - 1, pointerIndex);
526 }
527 virtual void SetEventPositionFlipY(int pos[2], int pointerIndex)
528 {
529 this->SetEventPositionFlipY(pos[0], pos[1], pointerIndex);
530 }
531
533
536 vtkSetMacro(AltKey, int);
537 vtkGetMacro(AltKey, int);
539
541
544 vtkSetMacro(ControlKey, int);
545 vtkGetMacro(ControlKey, int);
547
549
552 vtkSetMacro(ShiftKey, int);
553 vtkGetMacro(ShiftKey, int);
555
557
560 vtkSetMacro(KeyCode, char);
561 vtkGetMacro(KeyCode, char);
563
565
569 vtkSetMacro(RepeatCount, int);
570 vtkGetMacro(RepeatCount, int);
572
574
580 vtkSetStringMacro(KeySym);
581 vtkGetStringMacro(KeySym);
583
585
588 vtkSetMacro(PointerIndex, int);
589 vtkGetMacro(PointerIndex, int);
591
593
596 void SetRotation(double rotation);
597 vtkGetMacro(Rotation, double);
598 vtkGetMacro(LastRotation, double);
600
602
605 void SetScale(double scale);
606 vtkGetMacro(Scale, double);
607 vtkGetMacro(LastScale, double);
609
611
614 void SetTranslation(double val[2]);
615 vtkGetVector2Macro(Translation, double);
616 vtkGetVector2Macro(LastTranslation, double);
618
620
623 void SetEventInformation(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
624 const char* keysym, int pointerIndex)
625 {
626 this->SetEventPosition(x, y, pointerIndex);
627 this->ControlKey = ctrl;
628 this->ShiftKey = shift;
629 this->KeyCode = keycode;
630 this->RepeatCount = repeatcount;
631 this->PointerIndex = pointerIndex;
632 if (keysym)
633 {
634 this->SetKeySym(keysym);
635 }
636 this->Modified();
637 }
638 void SetEventInformation(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
639 int repeatcount = 0, const char* keysym = nullptr)
640 {
641 this->SetEventInformation(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
642 }
644
646
650 void SetEventInformationFlipY(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
651 const char* keysym, int pointerIndex)
652 {
653 this->SetEventInformation(
654 x, this->Size[1] - y - 1, ctrl, shift, keycode, repeatcount, keysym, pointerIndex);
655 }
656 void SetEventInformationFlipY(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
657 int repeatcount = 0, const char* keysym = nullptr)
658 {
659 this->SetEventInformationFlipY(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
660 }
662
664
667 void SetKeyEventInformation(int ctrl = 0, int shift = 0, char keycode = 0, int repeatcount = 0,
668 const char* keysym = nullptr)
669 {
670 this->ControlKey = ctrl;
671 this->ShiftKey = shift;
672 this->KeyCode = keycode;
673 this->RepeatCount = repeatcount;
674 if (keysym)
675 {
676 this->SetKeySym(keysym);
677 }
678 this->Modified();
679 }
681
683
694 vtkSetVector2Macro(Size, int);
695 vtkGetVector2Macro(Size, int);
696 vtkSetVector2Macro(EventSize, int);
697 vtkGetVector2Macro(EventSize, int);
699
705 virtual vtkRenderer* FindPokedRenderer(int, int);
706
715
717
725 vtkSetMacro(UseTDx, bool);
726 vtkGetMacro(UseTDx, bool);
728
730
735 virtual void MouseMoveEvent();
736 virtual void RightButtonPressEvent();
738 virtual void LeftButtonPressEvent();
744 virtual void MouseWheelLeftEvent();
745 virtual void MouseWheelRightEvent();
746 virtual void ExposeEvent();
747 virtual void ConfigureEvent();
748 virtual void EnterEvent();
749 virtual void LeaveEvent();
750 virtual void KeyPressEvent();
751 virtual void KeyReleaseEvent();
752 virtual void CharEvent();
753 virtual void ExitEvent();
756 virtual void FifthButtonPressEvent();
759
761
765 virtual void StartPinchEvent();
766 virtual void PinchEvent();
767 virtual void EndPinchEvent();
768 virtual void StartRotateEvent();
769 virtual void RotateEvent();
770 virtual void EndRotateEvent();
771 virtual void StartPanEvent();
772 virtual void PanEvent();
773 virtual void EndPanEvent();
774 virtual void TapEvent();
775 virtual void LongTapEvent();
776 virtual void SwipeEvent();
778
780
786 vtkSetMacro(RecognizeGestures, bool);
787 vtkGetMacro(RecognizeGestures, bool);
789
791
796 vtkGetMacro(PointersDownCount, int);
798
800
807 void ClearContact(size_t contactID);
808 int GetPointerIndexForContact(size_t contactID);
810 bool IsPointerIndexSet(int i);
811 void ClearPointerIndex(int i);
813
814protected:
817
821
822 // Used as a helper object to pick instances of vtkProp
825
826 bool Done; // is the event loop done running
827
833
837 int Style;
842
843 // Event information
848 double Rotation;
850 double Scale;
851 double LastScale;
852 double Translation[2];
853 double LastTranslation[2];
855 char* KeySym;
856 int EventPosition[2];
857 int LastEventPosition[2];
858 int EventSize[2];
859 int Size[2];
864
865 int EventPositions[VTKI_MAX_POINTERS][2];
866 int LastEventPositions[VTKI_MAX_POINTERS][2];
868
869 size_t PointerIndexLookup[VTKI_MAX_POINTERS];
870
871 // control the fly to
873 double Dolly;
874
884 void GrabFocus(vtkCommand* mouseEvents, vtkCommand* keypressEvents = nullptr)
885 {
886 this->Superclass::InternalGrabFocus(mouseEvents, keypressEvents);
887 }
888 void ReleaseFocus() { this->Superclass::InternalReleaseFocus(); }
889
894
895 // Timer related members
896 friend struct vtkTimerStruct;
897 vtkTimerIdMap* TimerMap; // An internal, PIMPLd map of timers and associated attributes
898 unsigned long TimerDuration; // in milliseconds
900
906 virtual int InternalCreateTimer(int timerId, int timerType, unsigned long duration);
907 virtual int InternalDestroyTimer(int platformTimerId);
910
911 // Force the interactor to handle the Start() event loop, ignoring any
912 // overrides. (Overrides are registered by observing StartEvent on the
913 // interactor.)
915
919 virtual void StartEventLoop() {}
920
921 bool UseTDx; // 3DConnexion device.
922
923 // when recognizing gestures VTK will take multitouch events
924 // if it receives them and convert them to gestures
927 int PointersDown[VTKI_MAX_POINTERS];
929 int StartingEventPositions[VTKI_MAX_POINTERS][2];
931
932private:
934 void operator=(const vtkRenderWindowInteractor&) = delete;
935};
936
937#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:394
create a window for renderers to draw into
a simple class to control print indentation
Definition: vtkIndent.h:34
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
Definition: vtkObjectBase.h:70
const char * GetClassName() const
Return the class name as a string.
abstract base class for most VTK objects
Definition: vtkObject.h:63
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.
unsigned long GetTimerDuration(int timerId)
Get the duration (in milliseconds) for the specified timerId.
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 SetRenderWindow(vtkRenderWindow *aren)
Set/Get the rendering window being controlled by this object.
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 EndPickCallback()
These methods correspond to the Exit, User and Pick callbacks.
virtual void Enable()
Enable/Disable interactions.
virtual int InternalDestroyTimer(int platformTimerId)
Internal methods for creating and destroying timers that must be implemented by subclasses.
int CreateRepeatingTimer(unsigned long duration)
Create a repeating timer, with the specified duration (in milliseconds).
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 UserCallback()
These methods correspond to the Exit, User and Pick callbacks.
void SetHardwareWindow(vtkHardwareWindow *aren)
Set/Get the hardware window being controlled by this object.
virtual void LeftButtonReleaseEvent()
Fire various events.
virtual void CharEvent()
Fire various events.
virtual int DestroyTimer()
int IsOneShotTimer(int timerId)
Query whether the specified timerId is a one shot timer.
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.
virtual void TerminateApp(void)
This function is called on 'q','e' keypress if exitmethod is not specified and should be overridden b...
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 void UpdateSize(int x, int y)
Event loop notification member for window size change.
virtual vtkPickingManager * CreateDefaultPickingManager()
Create default pickingManager.
virtual void LeaveEvent()
Fire various events.
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.
virtual int CreateTimer(int timerType)
This class provides two groups of methods for manipulating timers.
int ResetTimer(int timerId)
Reset the specified timer.
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.
int CreateOneShotTimer(unsigned long duration)
Create a one shot timer, with the specified duration (in milliseconds).
void ReInitialize()
Prepare for handling events and set the Enabled flag to true.
virtual void ExitCallback()
These methods correspond to the Exit, User and Pick callbacks.
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.
int DestroyTimer(int timerId)
Destroy the timer specified by timerId.
void SetTranslation(double val[2])
Set/get the translation for pan/swipe gestures, update LastTranslation.
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()
Run the event loop 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 GetMousePosition(int *x, int *y)
Get the current position of the mouse.
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 void MiddleButtonPressEvent()
Fire various events.
virtual void StartPickCallback()
These methods correspond to the Exit, User and Pick callbacks.
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.
vtkInteractorObserver * InteractorStyle
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.
virtual int GetVTKTimerId(int platformTimerId)
Get the VTK timer ID that corresponds to the supplied platform ID.
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 SetPickingManager(vtkPickingManager *)
Set the picking manager.
virtual void KeyPressEvent()
Fire various events.
create a window for renderers to draw into
abstract specification for renderers
Definition: vtkRenderer.h:73
int vtkTypeBool
Definition: vtkABI.h:69
#define VTKI_MAX_POINTERS
#define VTK_INT_MAX
Definition: vtkType.h:155
#define VTK_FLOAT_MAX
Definition: vtkType.h:163