vtkRenderWindowInteractor.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkRenderWindowInteractor_h
#define vtkRenderWindowInteractor_h
 
#include "vtkCommand.h" // for method sig
#include "vtkObject.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkSmartPointer.h"        // For InteractorStyle
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkTimerIdMap;
 
// Timer flags for win32/X compatibility
#define VTKI_TIMER_FIRST 0
#define VTKI_TIMER_UPDATE 1
 
// maximum pointers active at once
// for example in multitouch
#define VTKI_MAX_POINTERS 5
 
class vtkAbstractPicker;
class vtkAbstractPropPicker;
class vtkAssemblyPath;
class vtkHardwareWindow;
class vtkInteractorObserver;
class vtkRenderWindow;
class vtkRenderer;
class vtkObserverMediator;
class vtkInteractorEventRecorder;
class vtkPickingManager;
 
class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkRenderWindowInteractor : public vtkObject
{
 
  friend class vtkInteractorEventRecorder;
 
public:
  static vtkRenderWindowInteractor* New();
  vtkTypeMacro(vtkRenderWindowInteractor, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  virtual void Initialize();
  void ReInitialize()
  {
    this->Initialized = 0;
    this->Enabled = 0;
    this->Initialize();
  }
 
  void UnRegister(vtkObjectBase* o) override;
 
  virtual void Start();
 
  virtual void ProcessEvents() {}
 
  vtkGetMacro(Done, bool);
  vtkSetMacro(Done, bool);
 
  virtual void Enable()
  {
    this->Enabled = 1;
    this->Modified();
  }
  virtual void Disable()
  {
    this->Enabled = 0;
    this->Modified();
  }
  vtkGetMacro(Enabled, int);
 
 
  vtkBooleanMacro(EnableRender, bool);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkSetMacro(EnableRender, bool);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkGetMacro(EnableRender, bool);
 
 
  void SetRenderWindow(vtkRenderWindow* aren);
  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
 
 
  void SetHardwareWindow(vtkHardwareWindow* aren);
  vtkGetObjectMacro(HardwareWindow, vtkHardwareWindow);
 
  virtual void UpdateSize(int x, int y);
 
  virtual int CreateTimer(int timerType); // first group, for backward compatibility
  virtual int DestroyTimer();             // first group, for backward compatibility
 
  int CreateRepeatingTimer(unsigned long duration);
 
  int CreateOneShotTimer(unsigned long duration);
 
  int IsOneShotTimer(int timerId);
 
  unsigned long GetTimerDuration(int timerId);
 
  int ResetTimer(int timerId);
 
  int DestroyTimer(int timerId);
 
  virtual int GetVTKTimerId(int platformTimerId);
 
  // Moved into the public section of the class so that classless timer procs
  // can access these enum members without being "friends"...
  enum
  {
    OneShotTimer = 1,
    RepeatingTimer
  };
 
 
  vtkSetClampMacro(TimerDuration, unsigned long, 1, 100000);
  vtkGetMacro(TimerDuration, unsigned long);
 
 
  vtkSetMacro(TimerEventId, int);
  vtkGetMacro(TimerEventId, int);
  vtkSetMacro(TimerEventType, int);
  vtkGetMacro(TimerEventType, int);
  vtkSetMacro(TimerEventDuration, int);
  vtkGetMacro(TimerEventDuration, int);
  vtkSetMacro(TimerEventPlatformId, int);
  vtkGetMacro(TimerEventPlatformId, int);
 
  virtual void TerminateApp() { this->Done = true; }
 
 
  virtual void SetInteractorStyle(vtkInteractorObserver*);
  virtual vtkInteractorObserver* GetInteractorStyle();
 
 
  vtkSetMacro(LightFollowCamera, vtkTypeBool);
  vtkGetMacro(LightFollowCamera, vtkTypeBool);
  vtkBooleanMacro(LightFollowCamera, vtkTypeBool);
 
 
  vtkSetClampMacro(DesiredUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
  vtkGetMacro(DesiredUpdateRate, double);
 
 
  vtkSetClampMacro(StillUpdateRate, double, 0.0001, VTK_FLOAT_MAX);
  vtkGetMacro(StillUpdateRate, double);
 
 
  vtkGetMacro(Initialized, int);
 
 
  virtual void SetPicker(vtkAbstractPicker*);
  vtkGetObjectMacro(Picker, vtkAbstractPicker);
 
  virtual vtkAbstractPropPicker* CreateDefaultPicker();
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void SetPickingManager(vtkPickingManager*);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  vtkGetObjectMacro(PickingManager, vtkPickingManager);
 
 
  virtual void ExitCallback();
  virtual void UserCallback();
  virtual void StartPickCallback();
  virtual void EndPickCallback();
 
  virtual void GetMousePosition(int* x, int* y)
  {
    *x = 0;
    *y = 0;
  }
 
 
  void HideCursor();
  void ShowCursor();
 
  virtual void Render();
 
 
  void FlyTo(vtkRenderer* ren, double x, double y, double z);
  void FlyTo(vtkRenderer* ren, double* x) { this->FlyTo(ren, x[0], x[1], x[2]); }
  void FlyToImage(vtkRenderer* ren, double x, double y);
  void FlyToImage(vtkRenderer* ren, double* x) { this->FlyToImage(ren, x[0], x[1]); }
 
 
  vtkSetClampMacro(NumberOfFlyFrames, int, 1, VTK_INT_MAX);
  vtkGetMacro(NumberOfFlyFrames, int);
 
 
  vtkSetMacro(Dolly, double);
  vtkGetMacro(Dolly, double);
 
 
  vtkGetVector2Macro(EventPosition, int);
  vtkGetVector2Macro(LastEventPosition, int);
  vtkSetVector2Macro(LastEventPosition, int);
  virtual void SetEventPosition(int x, int y)
  {
    vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
                  << "," << y << ")");
    if (this->EventPosition[0] != x || this->EventPosition[1] != y ||
      this->LastEventPosition[0] != x || this->LastEventPosition[1] != y)
    {
      this->LastEventPosition[0] = this->EventPosition[0];
      this->LastEventPosition[1] = this->EventPosition[1];
      this->EventPosition[0] = x;
      this->EventPosition[1] = y;
      this->Modified();
    }
  }
  virtual void SetEventPosition(int pos[2]) { this->SetEventPosition(pos[0], pos[1]); }
  virtual void SetEventPositionFlipY(int x, int y)
  {
    this->SetEventPosition(x, this->Size[1] - y - 1);
  }
  virtual void SetEventPositionFlipY(int pos[2]) { this->SetEventPositionFlipY(pos[0], pos[1]); }
 
  virtual int* GetEventPositions(int pointerIndex)
  {
    if (pointerIndex >= VTKI_MAX_POINTERS)
    {
      return nullptr;
    }
    return this->EventPositions[pointerIndex];
  }
  virtual int* GetLastEventPositions(int pointerIndex)
  {
    if (pointerIndex >= VTKI_MAX_POINTERS)
    {
      return nullptr;
    }
    return this->LastEventPositions[pointerIndex];
  }
  virtual void SetEventPosition(int x, int y, int pointerIndex)
  {
    if (pointerIndex < 0 || pointerIndex >= VTKI_MAX_POINTERS)
    {
      return;
    }
    if (pointerIndex == 0)
    {
      this->LastEventPosition[0] = this->EventPosition[0];
      this->LastEventPosition[1] = this->EventPosition[1];
      this->EventPosition[0] = x;
      this->EventPosition[1] = y;
    }
    vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting EventPosition to (" << x
                  << "," << y << ") for pointerIndex number " << pointerIndex);
    if (this->EventPositions[pointerIndex][0] != x || this->EventPositions[pointerIndex][1] != y ||
      this->LastEventPositions[pointerIndex][0] != x ||
      this->LastEventPositions[pointerIndex][1] != y)
    {
      this->LastEventPositions[pointerIndex][0] = this->EventPositions[pointerIndex][0];
      this->LastEventPositions[pointerIndex][1] = this->EventPositions[pointerIndex][1];
      this->EventPositions[pointerIndex][0] = x;
      this->EventPositions[pointerIndex][1] = y;
      this->Modified();
    }
  }
  virtual void SetEventPosition(int pos[2], int pointerIndex)
  {
    this->SetEventPosition(pos[0], pos[1], pointerIndex);
  }
  virtual void SetEventPositionFlipY(int x, int y, int pointerIndex)
  {
    this->SetEventPosition(x, this->Size[1] - y - 1, pointerIndex);
  }
  virtual void SetEventPositionFlipY(int pos[2], int pointerIndex)
  {
    this->SetEventPositionFlipY(pos[0], pos[1], pointerIndex);
  }
 
 
  vtkSetMacro(AltKey, int);
  vtkGetMacro(AltKey, int);
 
 
  vtkSetMacro(ControlKey, int);
  vtkGetMacro(ControlKey, int);
 
 
  vtkSetMacro(ShiftKey, int);
  vtkGetMacro(ShiftKey, int);
 
 
  vtkSetMacro(KeyCode, char);
  vtkGetMacro(KeyCode, char);
 
 
  vtkSetMacro(RepeatCount, int);
  vtkGetMacro(RepeatCount, int);
 
 
  vtkSetStringMacro(KeySym);
  vtkGetStringMacro(KeySym);
 
 
  vtkSetMacro(PointerIndex, int);
  vtkGetMacro(PointerIndex, int);
 
 
  void SetRotation(double rotation);
  vtkGetMacro(Rotation, double);
  vtkGetMacro(LastRotation, double);
 
 
  void SetScale(double scale);
  vtkGetMacro(Scale, double);
  vtkGetMacro(LastScale, double);
 
 
  void SetTranslation(double val[2]);
  vtkGetVector2Macro(Translation, double);
  vtkGetVector2Macro(LastTranslation, double);
 
 
  void SetEventInformation(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
    const char* keysym, int pointerIndex)
  {
    this->SetEventPosition(x, y, pointerIndex);
    this->ControlKey = ctrl;
    this->ShiftKey = shift;
    this->KeyCode = keycode;
    this->RepeatCount = repeatcount;
    this->PointerIndex = pointerIndex;
    if (keysym)
    {
      this->SetKeySym(keysym);
    }
    this->Modified();
  }
  void SetEventInformation(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
    int repeatcount = 0, const char* keysym = nullptr)
  {
    this->SetEventInformation(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
  }
 
 
  void SetEventInformationFlipY(int x, int y, int ctrl, int shift, char keycode, int repeatcount,
    const char* keysym, int pointerIndex)
  {
    this->SetEventInformation(
      x, this->Size[1] - y - 1, ctrl, shift, keycode, repeatcount, keysym, pointerIndex);
  }
  void SetEventInformationFlipY(int x, int y, int ctrl = 0, int shift = 0, char keycode = 0,
    int repeatcount = 0, const char* keysym = nullptr)
  {
    this->SetEventInformationFlipY(x, y, ctrl, shift, keycode, repeatcount, keysym, 0);
  }
 
 
  void SetKeyEventInformation(int ctrl = 0, int shift = 0, char keycode = 0, int repeatcount = 0,
    const char* keysym = nullptr)
  {
    this->ControlKey = ctrl;
    this->ShiftKey = shift;
    this->KeyCode = keycode;
    this->RepeatCount = repeatcount;
    if (keysym)
    {
      this->SetKeySym(keysym);
    }
    this->Modified();
  }
 
 
  vtkSetVector2Macro(Size, int);
  vtkGetVector2Macro(Size, int);
  vtkSetVector2Macro(EventSize, int);
  vtkGetVector2Macro(EventSize, int);
 
  virtual vtkRenderer* FindPokedRenderer(int, int);
 
  vtkObserverMediator* GetObserverMediator();
 
 
  vtkSetMacro(UseTDx, bool);
  vtkGetMacro(UseTDx, bool);
 
 
  virtual void MouseMoveEvent();
  virtual void RightButtonPressEvent();
  virtual void RightButtonReleaseEvent();
  virtual void LeftButtonPressEvent();
  virtual void LeftButtonReleaseEvent();
  virtual void MiddleButtonPressEvent();
  virtual void MiddleButtonReleaseEvent();
  virtual void MouseWheelForwardEvent();
  virtual void MouseWheelBackwardEvent();
  virtual void MouseWheelLeftEvent();
  virtual void MouseWheelRightEvent();
  virtual void ExposeEvent();
  virtual void ConfigureEvent();
  virtual void EnterEvent();
  virtual void LeaveEvent();
  virtual void KeyPressEvent();
  virtual void KeyReleaseEvent();
  virtual void CharEvent();
  virtual void ExitEvent();
  virtual void FourthButtonPressEvent();
  virtual void FourthButtonReleaseEvent();
  virtual void FifthButtonPressEvent();
  virtual void FifthButtonReleaseEvent();
 
 
  virtual void StartPinchEvent();
  virtual void PinchEvent();
  virtual void EndPinchEvent();
  virtual void StartRotateEvent();
  virtual void RotateEvent();
  virtual void EndRotateEvent();
  virtual void StartPanEvent();
  virtual void PanEvent();
  virtual void EndPanEvent();
  virtual void TapEvent();
  virtual void LongTapEvent();
  virtual void SwipeEvent();
 
 
  vtkSetMacro(RecognizeGestures, bool);
  vtkGetMacro(RecognizeGestures, bool);
 
 
  vtkGetMacro(PointersDownCount, int);
 
 
  void ClearContact(size_t contactID);
  int GetPointerIndexForContact(size_t contactID);
  int GetPointerIndexForExistingContact(size_t contactID);
  bool IsPointerIndexSet(int i);
  void ClearPointerIndex(int i);
 
  static bool InteractorManagesTheEventLoop;
 
 
  virtual vtkCommand::EventIds GetCurrentGesture() const;
  virtual void SetCurrentGesture(vtkCommand::EventIds eid);
 
protected:
  vtkRenderWindowInteractor();
  ~vtkRenderWindowInteractor() override;
 
  vtkRenderWindow* RenderWindow;
  vtkHardwareWindow* HardwareWindow;
  vtkSmartPointer<vtkInteractorObserver> InteractorStyle;
 
  // Used as a helper object to pick instances of vtkProp
  vtkAbstractPicker* Picker;
  vtkPickingManager* PickingManager;
 
  bool Done; // is the event loop done running
 
  virtual vtkPickingManager* CreateDefaultPickingManager();
 
  int Initialized;
  int Enabled;
  bool EnableRender;
  int Style;
  vtkTypeBool LightFollowCamera;
  int ActorMode;
  double DesiredUpdateRate;
  double StillUpdateRate;
 
  // Event information
  int AltKey;
  int ControlKey;
  int ShiftKey;
  char KeyCode;
  double Rotation;
  double LastRotation;
  double Scale;
  double LastScale;
  double Translation[2];
  double LastTranslation[2];
  int RepeatCount;
  char* KeySym;
  int EventPosition[2];
  int LastEventPosition[2];
  int EventSize[2];
  int Size[2];
  int TimerEventId;
  int TimerEventType;
  int TimerEventDuration;
  int TimerEventPlatformId;
 
  int EventPositions[VTKI_MAX_POINTERS][2];
  int LastEventPositions[VTKI_MAX_POINTERS][2];
  int PointerIndex;
 
  size_t PointerIndexLookup[VTKI_MAX_POINTERS];
 
  // control the fly to
  int NumberOfFlyFrames;
  double Dolly;
 
  friend class vtkInteractorObserver;
  void GrabFocus(vtkCommand* mouseEvents, vtkCommand* keypressEvents = nullptr)
  {
    this->Superclass::InternalGrabFocus(mouseEvents, keypressEvents);
  }
  void ReleaseFocus() { this->Superclass::InternalReleaseFocus(); }
 
  vtkObserverMediator* ObserverMediator;
 
  // Timer related members
  friend struct vtkTimerStruct;
  vtkTimerIdMap* TimerMap;     // An internal, PIMPLd map of timers and associated attributes
  unsigned long TimerDuration; // in milliseconds
 
  virtual int InternalCreateTimer(int timerId, int timerType, unsigned long duration);
  virtual int InternalDestroyTimer(int platformTimerId);
  int GetCurrentTimerId();
 
  // Force the interactor to handle the Start() event loop, ignoring any
  // overrides. (Overrides are registered by observing StartEvent on the
  // interactor.)
  int HandleEventLoop;
 
  virtual void StartEventLoop() {}
 
  bool UseTDx; // 3DConnexion device.
 
  // when recognizing gestures VTK will take multitouch events
  // if it receives them and convert them to gestures
  bool RecognizeGestures;
  int PointersDownCount;
  int PointersDown[VTKI_MAX_POINTERS];
  virtual void RecognizeGesture(vtkCommand::EventIds);
  int StartingEventPositions[VTKI_MAX_POINTERS][2];
  vtkCommand::EventIds CurrentGesture;
 
private:
  vtkRenderWindowInteractor(const vtkRenderWindowInteractor&) = delete;
  void operator=(const vtkRenderWindowInteractor&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif