VTK  9.1.20211230
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 =========================================================================*/
163 #ifndef vtkRenderWindowInteractor_h
164 #define vtkRenderWindowInteractor_h
165 
166 #include "vtkCommand.h" // for method sig
167 #include "vtkObject.h"
168 #include "vtkRenderingCoreModule.h" // For export macro
169 
170 class vtkTimerIdMap;
171 
172 // Timer flags for win32/X compatibility
173 #define VTKI_TIMER_FIRST 0
174 #define VTKI_TIMER_UPDATE 1
175 
176 // maximum pointers active at once
177 // for example in multitouch
178 #define VTKI_MAX_POINTERS 5
179 
180 class vtkAbstractPicker;
182 class vtkAssemblyPath;
183 class vtkHardwareWindow;
185 class vtkRenderWindow;
186 class vtkRenderer;
187 class vtkObserverMediator;
189 class vtkPickingManager;
190 
191 class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor : public vtkObject
192 {
193 
195 
196 public:
199  void PrintSelf(ostream& os, vtkIndent indent) override;
200 
202 
209  virtual void Initialize();
211  {
212  this->Initialized = 0;
213  this->Enabled = 0;
214  this->Initialize();
215  }
217 
222  void UnRegister(vtkObjectBase* o) override;
223 
229  virtual void Start();
230 
236  virtual void ProcessEvents() {}
237 
241  vtkGetMacro(Done, bool);
242  vtkSetMacro(Done, bool);
243 
253  virtual void Enable()
254  {
255  this->Enabled = 1;
256  this->Modified();
257  }
258  virtual void Disable()
259  {
260  this->Enabled = 0;
261  this->Modified();
262  }
263  vtkGetMacro(Enabled, int);
264 
266 
270  vtkBooleanMacro(EnableRender, bool);
271  vtkSetMacro(EnableRender, bool);
272  vtkGetMacro(EnableRender, bool);
274 
276 
280  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
282 
284 
290  vtkGetObjectMacro(HardwareWindow, vtkHardwareWindow);
292 
300  virtual void UpdateSize(int x, int y);
301 
318  virtual int CreateTimer(int timerType); // first group, for backward compatibility
319  virtual int DestroyTimer(); // first group, for backward compatibility
320 
325  int CreateRepeatingTimer(unsigned long duration);
326 
331  int CreateOneShotTimer(unsigned long duration);
332 
337  int IsOneShotTimer(int timerId);
338 
342  unsigned long GetTimerDuration(int timerId);
343 
347  int ResetTimer(int timerId);
348 
353  int DestroyTimer(int timerId);
354 
358  virtual int GetVTKTimerId(int platformTimerId);
359 
360  // Moved into the public section of the class so that classless timer procs
361  // can access these enum members without being "friends"...
362  enum
363  {
364  OneShotTimer = 1,
365  RepeatingTimer
366  };
367 
369 
378  vtkSetClampMacro(TimerDuration, unsigned long, 1, 100000);
379  vtkGetMacro(TimerDuration, unsigned long);
381 
383 
395  vtkSetMacro(TimerEventId, int);
396  vtkGetMacro(TimerEventId, int);
397  vtkSetMacro(TimerEventType, int);
398  vtkGetMacro(TimerEventType, int);
399  vtkSetMacro(TimerEventDuration, int);
400  vtkGetMacro(TimerEventDuration, int);
401  vtkSetMacro(TimerEventPlatformId, int);
402  vtkGetMacro(TimerEventPlatformId, int);
404 
410  virtual void TerminateApp(void) { this->Done = true; }
411 
413 
418  vtkGetObjectMacro(InteractorStyle, vtkInteractorObserver);
420 
422 
426  vtkSetMacro(LightFollowCamera, vtkTypeBool);
427  vtkGetMacro(LightFollowCamera, vtkTypeBool);
428  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
430 
432 
439  vtkSetClampMacro(DesiredUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
440  vtkGetMacro(DesiredUpdateRate, double);
442 
444 
449  vtkSetClampMacro(StillUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
450  vtkGetMacro(StillUpdateRate, double);
452 
454 
458  vtkGetMacro(Initialized, int);
460 
462 
468  virtual void SetPicker(vtkAbstractPicker*);
469  vtkGetObjectMacro(Picker, vtkAbstractPicker);
471 
477 
479 
485  vtkGetObjectMacro(PickingManager, vtkPickingManager);
487 
489 
493  virtual void ExitCallback();
494  virtual void UserCallback();
495  virtual void StartPickCallback();
496  virtual void EndPickCallback();
498 
502  virtual void GetMousePosition(int* x, int* y)
503  {
504  *x = 0;
505  *y = 0;
506  }
507 
509 
513  void HideCursor();
514  void ShowCursor();
516 
521  virtual void Render();
522 
524 
529  void FlyTo(vtkRenderer* ren, double x, double y, double z);
530  void FlyTo(vtkRenderer* ren, double* x) { this->FlyTo(ren, x[0], x[1], x[2]); }
531  void FlyToImage(vtkRenderer* ren, double x, double y);
532  void FlyToImage(vtkRenderer* ren, double* x) { this->FlyToImage(ren, x[0], x[1]); }
534 
536 
539  vtkSetClampMacro(NumberOfFlyFrames, int, 1, VTK_INT_MAX);
540  vtkGetMacro(NumberOfFlyFrames, int);
542 
544 
548  vtkSetMacro(Dolly, double);
549  vtkGetMacro(Dolly, double);
551 
553 
561  vtkGetVector2Macro(EventPosition, int);
562  vtkGetVector2Macro(LastEventPosition, int);
563  vtkSetVector2Macro(LastEventPosition, int);
564  virtual void SetEventPosition(int x, int y)
565  {
566  vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
567  << "," << y << ")");
568  if (this->EventPosition[0] != x || this->EventPosition[1] != y ||
569  this->LastEventPosition[0] != x || this->LastEventPosition[1] != y)
570  {
571  this->LastEventPosition[0] = this->EventPosition[0];
572  this->LastEventPosition[1] = this->EventPosition[1];
573  this->EventPosition[0] = x;
574  this->EventPosition[1] = y;
575  this->Modified();
576  }
577  }
578  virtual void SetEventPosition(int pos[2]) { this->SetEventPosition(pos[0], pos[1]); }
579  virtual void SetEventPositionFlipY(int x, int y)
580  {
581  this->SetEventPosition(x, this->Size[1] - y - 1);
582  }
583  virtual void SetEventPositionFlipY(int pos[2]) { this->SetEventPositionFlipY(pos[0], pos[1]); }
585 
586  virtual int* GetEventPositions(int pointerIndex)
587  {
588  if (pointerIndex >= VTKI_MAX_POINTERS)
589  {
590  return nullptr;
591  }
592  return this->EventPositions[pointerIndex];
593  }
594  virtual int* GetLastEventPositions(int pointerIndex)
595  {
596  if (pointerIndex >= VTKI_MAX_POINTERS)
597  {
598  return nullptr;
599  }
600  return this->LastEventPositions[pointerIndex];
601  }
602  virtual void SetEventPosition(int x, int y, int pointerIndex)
603  {
604  if (pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
605  {
606  return;
607  }
608  if (pointerIndex == 0)
609  {
610  this->LastEventPosition[0] = this->EventPosition[0];
611  this->LastEventPosition[1] = this->EventPosition[1];
612  this->EventPosition[0] = x;
613  this->EventPosition[1] = y;
614  }
615  vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
616  << "," << y << ") for pointerIndex number " << pointerIndex);
617  if (this->EventPositions[pointerIndex][0] != x || this->EventPositions[pointerIndex][1] != y ||
618  this->LastEventPositions[pointerIndex][0] != x ||
619  this->LastEventPositions[pointerIndex][1] != y)
620  {
621  this->LastEventPositions[pointerIndex][0] = this->EventPositions[pointerIndex][0];
622  this->LastEventPositions[pointerIndex][1] = this->EventPositions[pointerIndex][1];
623  this->EventPositions[pointerIndex][0] = x;
624  this->EventPositions[pointerIndex][1] = y;
625  this->Modified();
626  }
627  }
628  virtual void SetEventPosition(int pos[2], int pointerIndex)
629  {
630  this->SetEventPosition(pos[0], pos[1], pointerIndex);
631  }
632  virtual void SetEventPositionFlipY(int x, int y, int pointerIndex)
633  {
634  this->SetEventPosition(x, this->Size[1] - y - 1, pointerIndex);
635  }
636  virtual void SetEventPositionFlipY(int pos[2], int pointerIndex)
637  {
638  this->SetEventPositionFlipY(pos[0], pos[1], pointerIndex);
639  }
640 
642 
645  vtkSetMacro(AltKey, int);
646  vtkGetMacro(AltKey, int);
648 
650 
653  vtkSetMacro(ControlKey, int);
654  vtkGetMacro(ControlKey, int);
656 
658 
661  vtkSetMacro(ShiftKey, int);
662  vtkGetMacro(ShiftKey, int);
664 
666 
669  vtkSetMacro(KeyCode, char);
670  vtkGetMacro(KeyCode, char);
672 
674 
678  vtkSetMacro(RepeatCount, int);
679  vtkGetMacro(RepeatCount, int);
681 
683 
689  vtkSetStringMacro(KeySym);
690  vtkGetStringMacro(KeySym);
692 
694 
697  vtkSetMacro(PointerIndex, int);
698  vtkGetMacro(PointerIndex, int);
700 
702 
705  void SetRotation(double rotation);
706  vtkGetMacro(Rotation, double);
707  vtkGetMacro(LastRotation, double);
709 
711 
714  void SetScale(double scale);
715  vtkGetMacro(Scale, double);
716  vtkGetMacro(LastScale, double);
718 
720 
723  void SetTranslation(double val[2]);
724  vtkGetVector2Macro(Translation, double);
725  vtkGetVector2Macro(LastTranslation, double);
727 
729 
732  void SetEventInformation(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
733  const char* keysym, int pointerIndex)
734  {
735  this->SetEventPosition(x, y, pointerIndex);
736  this->ControlKey = ctrl;
737  this->ShiftKey = shift;
738  this->KeyCode = keycode;
739  this->RepeatCount = repeatcount;
740  this->PointerIndex = pointerIndex;
741  if (keysym)
742  {
743  this->SetKeySym(keysym);
744  }
745  this->Modified();
746  }
747  void SetEventInformation(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
748  int repeatcount = 0, const char* keysym = nullptr)
749  {
750  this->SetEventInformation(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
751  }
753 
755 
759  void SetEventInformationFlipY(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
760  const char* keysym, int pointerIndex)
761  {
762  this->SetEventInformation(
763  x, this->Size[1] - y - 1, ctrl, shift, keycode, repeatcount, keysym, pointerIndex);
764  }
765  void SetEventInformationFlipY(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
766  int repeatcount = 0, const char* keysym = nullptr)
767  {
768  this->SetEventInformationFlipY(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
769  }
771 
773 
776  void SetKeyEventInformation(int ctrl = 0, int shift = 0, char keycode = 0, int repeatcount = 0,
777  const char* keysym = nullptr)
778  {
779  this->ControlKey = ctrl;
780  this->ShiftKey = shift;
781  this->KeyCode = keycode;
782  this->RepeatCount = repeatcount;
783  if (keysym)
784  {
785  this->SetKeySym(keysym);
786  }
787  this->Modified();
788  }
790 
792 
803  vtkSetVector2Macro(Size, int);
804  vtkGetVector2Macro(Size, int);
805  vtkSetVector2Macro(EventSize, int);
806  vtkGetVector2Macro(EventSize, int);
808 
814  virtual vtkRenderer* FindPokedRenderer(int, int);
815 
824 
826 
834  vtkSetMacro(UseTDx, bool);
835  vtkGetMacro(UseTDx, bool);
837 
839 
844  virtual void MouseMoveEvent();
845  virtual void RightButtonPressEvent();
846  virtual void RightButtonReleaseEvent();
847  virtual void LeftButtonPressEvent();
848  virtual void LeftButtonReleaseEvent();
849  virtual void MiddleButtonPressEvent();
850  virtual void MiddleButtonReleaseEvent();
851  virtual void MouseWheelForwardEvent();
852  virtual void MouseWheelBackwardEvent();
853  virtual void MouseWheelLeftEvent();
854  virtual void MouseWheelRightEvent();
855  virtual void ExposeEvent();
856  virtual void ConfigureEvent();
857  virtual void EnterEvent();
858  virtual void LeaveEvent();
859  virtual void KeyPressEvent();
860  virtual void KeyReleaseEvent();
861  virtual void CharEvent();
862  virtual void ExitEvent();
863  virtual void FourthButtonPressEvent();
864  virtual void FourthButtonReleaseEvent();
865  virtual void FifthButtonPressEvent();
866  virtual void FifthButtonReleaseEvent();
868 
870 
874  virtual void StartPinchEvent();
875  virtual void PinchEvent();
876  virtual void EndPinchEvent();
877  virtual void StartRotateEvent();
878  virtual void RotateEvent();
879  virtual void EndRotateEvent();
880  virtual void StartPanEvent();
881  virtual void PanEvent();
882  virtual void EndPanEvent();
883  virtual void TapEvent();
884  virtual void LongTapEvent();
885  virtual void SwipeEvent();
887 
889 
895  vtkSetMacro(RecognizeGestures, bool);
896  vtkGetMacro(RecognizeGestures, bool);
898 
900 
905  vtkGetMacro(PointersDownCount, int);
907 
909 
916  void ClearContact(size_t contactID);
917  int GetPointerIndexForContact(size_t contactID);
918  int GetPointerIndexForExistingContact(size_t contactID);
919  bool IsPointerIndexSet(int i);
920  void ClearPointerIndex(int i);
922 
923 protected:
926 
930 
931  // Used as a helper object to pick instances of vtkProp
934 
935  bool Done; // is the event loop done running
936 
942 
944  int Enabled;
946  int Style;
951 
952  // Event information
953  int AltKey;
955  int ShiftKey;
956  char KeyCode;
957  double Rotation;
958  double LastRotation;
959  double Scale;
960  double LastScale;
961  double Translation[2];
962  double LastTranslation[2];
964  char* KeySym;
965  int EventPosition[2];
966  int LastEventPosition[2];
967  int EventSize[2];
968  int Size[2];
973 
974  int EventPositions[VTKI_MAX_POINTERS][2];
975  int LastEventPositions[VTKI_MAX_POINTERS][2];
977 
978  size_t PointerIndexLookup[VTKI_MAX_POINTERS];
979 
980  // control the fly to
982  double Dolly;
983 
992  friend class vtkInteractorObserver;
993  void GrabFocus(vtkCommand* mouseEvents, vtkCommand* keypressEvents = nullptr)
994  {
995  this->Superclass::InternalGrabFocus(mouseEvents, keypressEvents);
996  }
998 
1003 
1004  // Timer related members
1005  friend struct vtkTimerStruct;
1006  vtkTimerIdMap* TimerMap; // An internal, PIMPLd map of timers and associated attributes
1007  unsigned long TimerDuration; // in milliseconds
1009 
1015  virtual int InternalCreateTimer(int timerId, int timerType, unsigned long duration);
1016  virtual int InternalDestroyTimer(int platformTimerId);
1019 
1020  // Force the interactor to handle the Start() event loop, ignoring any
1021  // overrides. (Overrides are registered by observing StartEvent on the
1022  // interactor.)
1024 
1028  virtual void StartEventLoop() {}
1029 
1030  bool UseTDx; // 3DConnexion device.
1031 
1032  // when recognizing gestures VTK will take multitouch events
1033  // if it receives them and convert them to gestures
1036  int PointersDown[VTKI_MAX_POINTERS];
1038  int StartingEventPositions[VTKI_MAX_POINTERS][2];
1040 
1041 private:
1043  void operator=(const vtkRenderWindowInteractor&) = delete;
1044 };
1045 
1046 #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:113
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:82
void InternalReleaseFocus()
These methods allow a command to exclusively grab all events.
void InternalGrabFocus(vtkCommand *mouseEvents, vtkCommand *keypressEvents=nullptr)
These methods allow a command to exclusively grab all events.
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 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).
virtual vtkAbstractPropPicker * CreateDefaultPicker()
Create default picker.
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 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.
vtkObserverMediator * GetObserverMediator()
Return the object used to mediate between vtkInteractorObservers contending for resources.
virtual void TerminateApp(void)
This function is called on 'q','e' keypress if exitmethod is not specified and should be overridden b...
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 int * GetEventPositions(int pointerIndex)
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.
static vtkRenderWindowInteractor * New()
~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 vtkPickingManager * CreateDefaultPickingManager()
Create default pickingManager.
virtual void ConfigureEvent()
Fire various events.
virtual void FifthButtonPressEvent()
Fire various events.
virtual vtkRenderer * FindPokedRenderer(int, int)
When an event occurs, we must determine which Renderer the event occurred within, since one RenderWin...
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...
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 int * GetLastEventPositions(int pointerIndex)
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:182
@ scale
Definition: vtkX3D.h:235
@ rotation
Definition: vtkX3D.h:234
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