VTK  9.3.1
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
42 #ifndef vtkRenderWindowInteractor_h
43 #define vtkRenderWindowInteractor_h
44 
45 #include "vtkCommand.h" // for method sig
46 #include "vtkObject.h"
47 #include "vtkRenderingCoreModule.h" // For export macro
48 #include "vtkSmartPointer.h" // For InteractorStyle
49 
50 VTK_ABI_NAMESPACE_BEGIN
51 class vtkTimerIdMap;
52 
53 // Timer flags for win32/X compatibility
54 #define VTKI_TIMER_FIRST 0
55 #define VTKI_TIMER_UPDATE 1
56 
57 // maximum pointers active at once
58 // for example in multitouch
59 #define VTKI_MAX_POINTERS 5
60 
61 class vtkAbstractPicker;
63 class vtkAssemblyPath;
64 class vtkHardwareWindow;
66 class vtkRenderWindow;
67 class vtkRenderer;
70 class vtkPickingManager;
71 
72 class VTKRENDERINGCORE_EXPORT vtkRenderWindowInteractor : public vtkObject
73 {
74 
76 
77 public:
80  void PrintSelf(ostream& os, vtkIndent indent) override;
81 
83 
90  virtual void Initialize();
91  void ReInitialize()
92  {
93  this->Initialized = 0;
94  this->Enabled = 0;
95  this->Initialize();
96  }
98 
103  void UnRegister(vtkObjectBase* o) override;
104 
110  virtual void Start();
111 
118  virtual void ProcessEvents() {}
119 
123  vtkGetMacro(Done, bool);
124  vtkSetMacro(Done, bool);
125 
135  virtual void Enable()
136  {
137  this->Enabled = 1;
138  this->Modified();
139  }
140  virtual void Disable()
141  {
142  this->Enabled = 0;
143  this->Modified();
144  }
145  vtkGetMacro(Enabled, int);
146 
148 
152  vtkBooleanMacro(EnableRender, bool);
153  vtkSetMacro(EnableRender, bool);
154  vtkGetMacro(EnableRender, bool);
156 
158 
161  void SetRenderWindow(vtkRenderWindow* aren);
162  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
164 
166 
171  void SetHardwareWindow(vtkHardwareWindow* aren);
172  vtkGetObjectMacro(HardwareWindow, vtkHardwareWindow);
174 
182  virtual void UpdateSize(int x, int y);
183 
200  virtual int CreateTimer(int timerType); // first group, for backward compatibility
201  virtual int DestroyTimer(); // first group, for backward compatibility
202 
207  int CreateRepeatingTimer(unsigned long duration);
208 
213  int CreateOneShotTimer(unsigned long duration);
214 
219  int IsOneShotTimer(int timerId);
220 
224  unsigned long GetTimerDuration(int timerId);
225 
229  int ResetTimer(int timerId);
230 
235  int DestroyTimer(int timerId);
236 
240  virtual int GetVTKTimerId(int platformTimerId);
241 
242  // Moved into the public section of the class so that classless timer procs
243  // can access these enum members without being "friends"...
244  enum
245  {
246  OneShotTimer = 1,
247  RepeatingTimer
248  };
249 
251 
260  vtkSetClampMacro(TimerDuration, unsigned long, 1, 100000);
261  vtkGetMacro(TimerDuration, unsigned long);
263 
265 
277  vtkSetMacro(TimerEventId, int);
278  vtkGetMacro(TimerEventId, int);
279  vtkSetMacro(TimerEventType, int);
280  vtkGetMacro(TimerEventType, int);
281  vtkSetMacro(TimerEventDuration, int);
282  vtkGetMacro(TimerEventDuration, int);
283  vtkSetMacro(TimerEventPlatformId, int);
284  vtkGetMacro(TimerEventPlatformId, int);
286 
292  virtual void TerminateApp() { this->Done = true; }
293 
295 
299  virtual void SetInteractorStyle(vtkInteractorObserver*);
300  virtual vtkInteractorObserver* GetInteractorStyle();
302 
304 
308  vtkSetMacro(LightFollowCamera, vtkTypeBool);
309  vtkGetMacro(LightFollowCamera, vtkTypeBool);
310  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
312 
314 
321  vtkSetClampMacro(DesiredUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
322  vtkGetMacro(DesiredUpdateRate, double);
324 
326 
331  vtkSetClampMacro(StillUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
332  vtkGetMacro(StillUpdateRate, double);
334 
336 
340  vtkGetMacro(Initialized, int);
342 
344 
350  virtual void SetPicker(vtkAbstractPicker*);
351  vtkGetObjectMacro(Picker, vtkAbstractPicker);
353 
358  virtual vtkAbstractPropPicker* CreateDefaultPicker();
359 
361 
366  virtual void SetPickingManager(vtkPickingManager*);
367  vtkGetObjectMacro(PickingManager, vtkPickingManager);
369 
371 
375  virtual void ExitCallback();
376  virtual void UserCallback();
377  virtual void StartPickCallback();
378  virtual void EndPickCallback();
380 
384  virtual void GetMousePosition(int* x, int* y)
385  {
386  *x = 0;
387  *y = 0;
388  }
389 
391 
395  void HideCursor();
396  void ShowCursor();
398 
403  virtual void Render();
404 
406 
411  void FlyTo(vtkRenderer* ren, double x, double y, double z);
412  void FlyTo(vtkRenderer* ren, double* x) { this->FlyTo(ren, x[0], x[1], x[2]); }
413  void FlyToImage(vtkRenderer* ren, double x, double y);
414  void FlyToImage(vtkRenderer* ren, double* x) { this->FlyToImage(ren, x[0], x[1]); }
416 
418 
421  vtkSetClampMacro(NumberOfFlyFrames, int, 1, VTK_INT_MAX);
422  vtkGetMacro(NumberOfFlyFrames, int);
424 
426 
430  vtkSetMacro(Dolly, double);
431  vtkGetMacro(Dolly, double);
433 
435 
443  vtkGetVector2Macro(EventPosition, int);
444  vtkGetVector2Macro(LastEventPosition, int);
445  vtkSetVector2Macro(LastEventPosition, int);
446  virtual void SetEventPosition(int x, int y)
447  {
448  vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
449  << "," << y << ")");
450  if (this->EventPosition[0] != x || this->EventPosition[1] != y ||
451  this->LastEventPosition[0] != x || this->LastEventPosition[1] != y)
452  {
453  this->LastEventPosition[0] = this->EventPosition[0];
454  this->LastEventPosition[1] = this->EventPosition[1];
455  this->EventPosition[0] = x;
456  this->EventPosition[1] = y;
457  this->Modified();
458  }
459  }
460  virtual void SetEventPosition(int pos[2]) { this->SetEventPosition(pos[0], pos[1]); }
461  virtual void SetEventPositionFlipY(int x, int y)
462  {
463  this->SetEventPosition(x, this->Size[1] - y - 1);
464  }
465  virtual void SetEventPositionFlipY(int pos[2]) { this->SetEventPositionFlipY(pos[0], pos[1]); }
467 
468  virtual int* GetEventPositions(int pointerIndex)
469  {
470  if (pointerIndex >= VTKI_MAX_POINTERS)
471  {
472  return nullptr;
473  }
474  return this->EventPositions[pointerIndex];
475  }
476  virtual int* GetLastEventPositions(int pointerIndex)
477  {
478  if (pointerIndex >= VTKI_MAX_POINTERS)
479  {
480  return nullptr;
481  }
482  return this->LastEventPositions[pointerIndex];
483  }
484  virtual void SetEventPosition(int x, int y, int pointerIndex)
485  {
486  if (pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
487  {
488  return;
489  }
490  if (pointerIndex == 0)
491  {
492  this->LastEventPosition[0] = this->EventPosition[0];
493  this->LastEventPosition[1] = this->EventPosition[1];
494  this->EventPosition[0] = x;
495  this->EventPosition[1] = y;
496  }
497  vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
498  << "," << y << ") for pointerIndex number " << pointerIndex);
499  if (this->EventPositions[pointerIndex][0] != x || this->EventPositions[pointerIndex][1] != y ||
500  this->LastEventPositions[pointerIndex][0] != x ||
501  this->LastEventPositions[pointerIndex][1] != y)
502  {
503  this->LastEventPositions[pointerIndex][0] = this->EventPositions[pointerIndex][0];
504  this->LastEventPositions[pointerIndex][1] = this->EventPositions[pointerIndex][1];
505  this->EventPositions[pointerIndex][0] = x;
506  this->EventPositions[pointerIndex][1] = y;
507  this->Modified();
508  }
509  }
510  virtual void SetEventPosition(int pos[2], int pointerIndex)
511  {
512  this->SetEventPosition(pos[0], pos[1], pointerIndex);
513  }
514  virtual void SetEventPositionFlipY(int x, int y, int pointerIndex)
515  {
516  this->SetEventPosition(x, this->Size[1] - y - 1, pointerIndex);
517  }
518  virtual void SetEventPositionFlipY(int pos[2], int pointerIndex)
519  {
520  this->SetEventPositionFlipY(pos[0], pos[1], pointerIndex);
521  }
522 
524 
527  vtkSetMacro(AltKey, int);
528  vtkGetMacro(AltKey, int);
530 
532 
535  vtkSetMacro(ControlKey, int);
536  vtkGetMacro(ControlKey, int);
538 
540 
543  vtkSetMacro(ShiftKey, int);
544  vtkGetMacro(ShiftKey, int);
546 
548 
551  vtkSetMacro(KeyCode, char);
552  vtkGetMacro(KeyCode, char);
554 
556 
560  vtkSetMacro(RepeatCount, int);
561  vtkGetMacro(RepeatCount, int);
563 
565 
571  vtkSetStringMacro(KeySym);
572  vtkGetStringMacro(KeySym);
574 
576 
579  vtkSetMacro(PointerIndex, int);
580  vtkGetMacro(PointerIndex, int);
582 
584 
587  void SetRotation(double rotation);
588  vtkGetMacro(Rotation, double);
589  vtkGetMacro(LastRotation, double);
591 
593 
596  void SetScale(double scale);
597  vtkGetMacro(Scale, double);
598  vtkGetMacro(LastScale, double);
600 
602 
605  void SetTranslation(double val[2]);
606  vtkGetVector2Macro(Translation, double);
607  vtkGetVector2Macro(LastTranslation, double);
609 
611 
614  void SetEventInformation(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
615  const char* keysym, int pointerIndex)
616  {
617  this->SetEventPosition(x, y, pointerIndex);
618  this->ControlKey = ctrl;
619  this->ShiftKey = shift;
620  this->KeyCode = keycode;
621  this->RepeatCount = repeatcount;
622  this->PointerIndex = pointerIndex;
623  if (keysym)
624  {
625  this->SetKeySym(keysym);
626  }
627  this->Modified();
628  }
629  void SetEventInformation(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
630  int repeatcount = 0, const char* keysym = nullptr)
631  {
632  this->SetEventInformation(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
633  }
635 
637 
641  void SetEventInformationFlipY(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
642  const char* keysym, int pointerIndex)
643  {
644  this->SetEventInformation(
645  x, this->Size[1] - y - 1, ctrl, shift, keycode, repeatcount, keysym, pointerIndex);
646  }
647  void SetEventInformationFlipY(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
648  int repeatcount = 0, const char* keysym = nullptr)
649  {
650  this->SetEventInformationFlipY(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
651  }
653 
655 
658  void SetKeyEventInformation(int ctrl = 0, int shift = 0, char keycode = 0, int repeatcount = 0,
659  const char* keysym = nullptr)
660  {
661  this->ControlKey = ctrl;
662  this->ShiftKey = shift;
663  this->KeyCode = keycode;
664  this->RepeatCount = repeatcount;
665  if (keysym)
666  {
667  this->SetKeySym(keysym);
668  }
669  this->Modified();
670  }
672 
674 
685  vtkSetVector2Macro(Size, int);
686  vtkGetVector2Macro(Size, int);
687  vtkSetVector2Macro(EventSize, int);
688  vtkGetVector2Macro(EventSize, int);
690 
696  virtual vtkRenderer* FindPokedRenderer(int, int);
697 
705  vtkObserverMediator* GetObserverMediator();
706 
708 
716  vtkSetMacro(UseTDx, bool);
717  vtkGetMacro(UseTDx, bool);
719 
721 
726  virtual void MouseMoveEvent();
727  virtual void RightButtonPressEvent();
728  virtual void RightButtonReleaseEvent();
729  virtual void LeftButtonPressEvent();
730  virtual void LeftButtonReleaseEvent();
731  virtual void MiddleButtonPressEvent();
732  virtual void MiddleButtonReleaseEvent();
733  virtual void MouseWheelForwardEvent();
734  virtual void MouseWheelBackwardEvent();
735  virtual void MouseWheelLeftEvent();
736  virtual void MouseWheelRightEvent();
737  virtual void ExposeEvent();
738  virtual void ConfigureEvent();
739  virtual void EnterEvent();
740  virtual void LeaveEvent();
741  virtual void KeyPressEvent();
742  virtual void KeyReleaseEvent();
743  virtual void CharEvent();
744  virtual void ExitEvent();
745  virtual void FourthButtonPressEvent();
746  virtual void FourthButtonReleaseEvent();
747  virtual void FifthButtonPressEvent();
748  virtual void FifthButtonReleaseEvent();
750 
752 
756  virtual void StartPinchEvent();
757  virtual void PinchEvent();
758  virtual void EndPinchEvent();
759  virtual void StartRotateEvent();
760  virtual void RotateEvent();
761  virtual void EndRotateEvent();
762  virtual void StartPanEvent();
763  virtual void PanEvent();
764  virtual void EndPanEvent();
765  virtual void TapEvent();
766  virtual void LongTapEvent();
767  virtual void SwipeEvent();
769 
771 
777  vtkSetMacro(RecognizeGestures, bool);
778  vtkGetMacro(RecognizeGestures, bool);
780 
782 
787  vtkGetMacro(PointersDownCount, int);
789 
791 
798  void ClearContact(size_t contactID);
799  int GetPointerIndexForContact(size_t contactID);
800  int GetPointerIndexForExistingContact(size_t contactID);
801  bool IsPointerIndexSet(int i);
802  void ClearPointerIndex(int i);
804 
805 protected:
807  ~vtkRenderWindowInteractor() override;
808 
812 
813  // Used as a helper object to pick instances of vtkProp
816 
817  bool Done; // is the event loop done running
818 
823  virtual vtkPickingManager* CreateDefaultPickingManager();
824 
826  int Enabled;
828  int Style;
833 
834  // Event information
835  int AltKey;
837  int ShiftKey;
838  char KeyCode;
839  double Rotation;
840  double LastRotation;
841  double Scale;
842  double LastScale;
843  double Translation[2];
844  double LastTranslation[2];
846  char* KeySym;
847  int EventPosition[2];
848  int LastEventPosition[2];
849  int EventSize[2];
850  int Size[2];
855 
856  int EventPositions[VTKI_MAX_POINTERS][2];
857  int LastEventPositions[VTKI_MAX_POINTERS][2];
859 
860  size_t PointerIndexLookup[VTKI_MAX_POINTERS];
861 
862  // control the fly to
864  double Dolly;
865 
874  friend class vtkInteractorObserver;
875  void GrabFocus(vtkCommand* mouseEvents, vtkCommand* keypressEvents = nullptr)
876  {
877  this->Superclass::InternalGrabFocus(mouseEvents, keypressEvents);
878  }
880 
885 
886  // Timer related members
887  friend struct vtkTimerStruct;
888  vtkTimerIdMap* TimerMap; // An internal, PIMPLd map of timers and associated attributes
889  unsigned long TimerDuration; // in milliseconds
891 
897  virtual int InternalCreateTimer(int timerId, int timerType, unsigned long duration);
898  virtual int InternalDestroyTimer(int platformTimerId);
899  int GetCurrentTimerId();
901 
902  // Force the interactor to handle the Start() event loop, ignoring any
903  // overrides. (Overrides are registered by observing StartEvent on the
904  // interactor.)
906 
910  virtual void StartEventLoop() {}
911 
912  bool UseTDx; // 3DConnexion device.
913 
914  // when recognizing gestures VTK will take multitouch events
915  // if it receives them and convert them to gestures
918  int PointersDown[VTKI_MAX_POINTERS];
919  virtual void RecognizeGesture(vtkCommand::EventIds);
920  int StartingEventPositions[VTKI_MAX_POINTERS][2];
922 
923 private:
925  void operator=(const vtkRenderWindowInteractor&) = delete;
926 };
927 
928 VTK_ABI_NAMESPACE_END
929 #endif
create a window for renderers to draw into
virtual void SetEventPositionFlipY(int pos[2])
Set/Get information about the current event.
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.
virtual void GetMousePosition(int *x, int *y)
Get the current position of the mouse.
void InternalGrabFocus(vtkCommand *mouseEvents, vtkCommand *keypressEvents=nullptr)
These methods allow a command to exclusively grab all events.
abstract base class for most VTK objects
Definition: vtkObject.h:51
Class defines API to manage the picking process.
virtual void Enable()
Enable/Disable interactions.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
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 SetEventPosition(int pos[2], int pointerIndex)
#define VTK_INT_MAX
Definition: vtkType.h:144
virtual void SetEventPositionFlipY(int pos[2], int pointerIndex)
abstract specification for renderers
Definition: vtkRenderer.h:61
void GrabFocus(vtkCommand *mouseEvents, vtkCommand *keypressEvents=nullptr)
virtual int * GetLastEventPositions(int pointerIndex)
virtual void SetEventPosition(int pos[2])
Set/Get information about the current event.
virtual int * GetEventPositions(int pointerIndex)
an abstract superclass for classes observing events invoked by vtkRenderWindowInteractor ...
void FlyTo(vtkRenderer *ren, double *x)
Given a position x, move the current camera's focal point to x.
int vtkTypeBool
Definition: vtkABI.h:64
platform-independent render window interaction including picking and frame rate control.
void InternalReleaseFocus()
These methods allow a command to exclusively grab all events.
void ReInitialize()
Prepare for handling events and set the Enabled flag to true.
superclass for callback/observer methods
Definition: vtkCommand.h:383
#define VTK_FLOAT_MAX
Definition: vtkType.h:152
virtual void UnRegister(vtkObjectBase *o)
Decrease the reference count (release by another object).
a list of nodes that form an assembly path
vtkObserverMediator * ObserverMediator
Widget mediators are used to resolve contention for cursors and other resources.
a simple class to control print indentation
Definition: vtkIndent.h:28
const char * GetClassName() const
Return the class name as a string.
virtual void StartEventLoop()
Run the event loop (does not return until TerminateApp is called).
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 Modified()
Update the modification time for this object.
record and play VTK events passing through a vtkRenderWindowInteractor
virtual void SetEventPosition(int x, int y, int pointerIndex)
vtkSmartPointer< vtkInteractorObserver > InteractorStyle
abstract base class for most VTK objects
Definition: vtkObjectBase.h:62
virtual void SetEventPosition(int x, int y)
Set/Get information about the current event.
virtual void ProcessEvents()
Process all user-interaction, timer events and return.
virtual void SetEventPositionFlipY(int x, int y, int pointerIndex)
abstract API for pickers that can pick an instance of vtkProp
create a window for renderers to draw into
#define VTKI_MAX_POINTERS
virtual void TerminateApp()
This function is called on 'q','e' keypress if exitmethod is not specified and should be overridden b...
define API for picking subclasses
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on...
void FlyToImage(vtkRenderer *ren, double *x)
Given a position x, move the current camera's focal point to x.
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.
manage contention for cursors and other resources
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.
virtual void SetEventPositionFlipY(int x, int y)
Set/Get information about the current event.