9.1/html/vtkInteractorStyle_8h_source.html

/*=========================================================================


  Program:   Visualization Toolkit

  Module:    vtkInteractorStyle.h


  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen

  All rights reserved.

  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.


     This software is distributed WITHOUT ANY WARRANTY; without even

     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

     PURPOSE.  See the above copyright notice for more information.


=========================================================================*/

#ifndef vtkInteractorStyle_h

#define vtkInteractorStyle_h


#include "vtkInteractorObserver.h"

#include "vtkRenderingCoreModule.h" // For export macro


// Motion flags


#define VTKIS_START 0

#define VTKIS_NONE 0


#define VTKIS_ROTATE 1

#define VTKIS_PAN 2

#define VTKIS_SPIN 3

#define VTKIS_DOLLY 4

#define VTKIS_ZOOM 5

#define VTKIS_USCALE 6

#define VTKIS_TIMER 7

#define VTKIS_FORWARDFLY 8

#define VTKIS_REVERSEFLY 9

#define VTKIS_TWO_POINTER 10

#define VTKIS_CLIP 11

#define VTKIS_PICK 12                 // perform a pick at the last location

#define VTKIS_LOAD_CAMERA_POSE 13     // iterate through saved camera poses

#define VTKIS_POSITION_PROP 14        // adjust the position, orientation of a prop

#define VTKIS_EXIT 15                 // call exit callback

#define VTKIS_TOGGLE_DRAW_CONTROLS 16 // draw device controls helpers

#define VTKIS_MENU 17                 // invoke an application menu

#define VTKIS_GESTURE 18              // touch interaction in progress

#define VTKIS_ENV_ROTATE 19           // rotate the renderer environment texture


#define VTKIS_ANIM_OFF 0

#define VTKIS_ANIM_ON 1


class vtkActor2D;

class vtkActor;

class vtkCallbackCommand;

class vtkEventData;

class vtkEventForwarderCommand;

class vtkOutlineSource;

class vtkPolyDataMapper;

class vtkProp3D;

class vtkProp;

class vtkStringArray;

class vtkTDxInteractorStyle;


class VTKRENDERINGCORE_EXPORT vtkInteractorStyle : public vtkInteractorObserver

{

public:

  static vtkInteractorStyle* New();


  vtkTypeMacro(vtkInteractorStyle, vtkInteractorObserver);

  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetInteractor(vtkRenderWindowInteractor* interactor) override;


  void SetEnabled(int) override;


  vtkSetClampMacro(AutoAdjustCameraClippingRange, vtkTypeBool, 0, 1);

  vtkGetMacro(AutoAdjustCameraClippingRange, vtkTypeBool);

  vtkBooleanMacro(AutoAdjustCameraClippingRange, vtkTypeBool);


  void FindPokedRenderer(int, int);


  vtkGetMacro(State, int);


  vtkGetMacro(UseTimers, vtkTypeBool);

  vtkSetMacro(UseTimers, vtkTypeBool);

  vtkBooleanMacro(UseTimers, vtkTypeBool);


  vtkSetClampMacro(TimerDuration, unsigned long, 1, 100000);

  vtkGetMacro(TimerDuration, unsigned long);


  vtkSetMacro(HandleObservers, vtkTypeBool);

  vtkGetMacro(HandleObservers, vtkTypeBool);

  vtkBooleanMacro(HandleObservers, vtkTypeBool);


  virtual void OnMouseMove() {}

  virtual void OnLeftButtonDown() {}

  virtual void OnLeftButtonUp() {}

  virtual void OnMiddleButtonDown() {}

  virtual void OnMiddleButtonUp() {}

  virtual void OnRightButtonDown() {}

  virtual void OnRightButtonUp() {}

  virtual void OnLeftButtonDoubleClick() {}

  virtual void OnMiddleButtonDoubleClick() {}

  virtual void OnRightButtonDoubleClick() {}

  virtual void OnMouseWheelForward() {}

  virtual void OnMouseWheelBackward() {}

  virtual void OnMouseWheelLeft() {}

  virtual void OnMouseWheelRight() {}

  virtual void OnFourthButtonDown() {}

  virtual void OnFourthButtonUp() {}

  virtual void OnFifthButtonDown() {}

  virtual void OnFifthButtonUp() {}


  virtual void OnMove3D(vtkEventData*) {}

  virtual void OnButton3D(vtkEventData*) {}

  virtual void OnPick3D(vtkEventData*) {}

  virtual void OnClip3D(vtkEventData*) {}

  virtual void OnSelect3D(vtkEventData*) {}

  virtual void OnMenu3D(vtkEventData*) {}

  virtual void OnNextPose3D(vtkEventData*) {}

  virtual void OnPositionProp3D(vtkEventData*) {}

  virtual void OnViewerMovement3D(vtkEventData*) {}


  void OnChar() override;


  // OnKeyDown is triggered by pressing any key (identical to OnKeyPress()).

  // An empty implementation is provided. The behavior of this function should

  // be specified in the subclass.

  virtual void OnKeyDown() {}


  // OnKeyUp is triggered by releaseing any key (identical to OnKeyRelease()).

  // An empty implementation is provided. The behavior of this function should

  // be specified in the subclass.

  virtual void OnKeyUp() {}


  // OnKeyPress is triggered by pressing any key (identical to OnKeyDown()).

  // An empty implementation is provided. The behavior of this function should

  // be specified in the subclass.

  virtual void OnKeyPress() {}


  // OnKeyRelease is triggered by pressing any key (identical to OnKeyUp()).

  // An empty implementation is provided. The behavior of this function should

  // be specified in the subclass.

  virtual void OnKeyRelease() {}


  virtual void OnExpose() {}

  virtual void OnConfigure() {}

  virtual void OnEnter() {}

  virtual void OnLeave() {}


  virtual void OnTimer();


  virtual void Rotate() {}

  virtual void Spin() {}

  virtual void Pan() {}

  virtual void Dolly() {}

  virtual void Zoom() {}

  virtual void UniformScale() {}

  virtual void EnvironmentRotate() {}


  virtual void OnStartSwipe() {}

  virtual void OnSwipe() {}

  virtual void OnEndSwipe() {}

  virtual void OnStartPinch() {}

  virtual void OnPinch() {}

  virtual void OnEndPinch() {}

  virtual void OnStartRotate() {}

  virtual void OnRotate() {}

  virtual void OnEndRotate() {}

  virtual void OnStartPan() {}

  virtual void OnPan() {}

  virtual void OnEndPan() {}

  virtual void OnTap() {}

  virtual void OnLongTap() {}


  virtual void StartState(int newstate);

  virtual void StopState();


  virtual void StartAnimate();

  virtual void StopAnimate();

  virtual void StartRotate();

  virtual void EndRotate();

  virtual void StartZoom();

  virtual void EndZoom();

  virtual void StartPan();

  virtual void EndPan();

  virtual void StartSpin();

  virtual void EndSpin();

  virtual void StartDolly();

  virtual void EndDolly();

  virtual void StartUniformScale();

  virtual void EndUniformScale();

  virtual void StartTimer();

  virtual void EndTimer();

  virtual void StartTwoPointer();

  virtual void EndTwoPointer();

  virtual void StartGesture();

  virtual void EndGesture();

  virtual void StartEnvRotate();

  virtual void EndEnvRotate();


  virtual void OnDropLocation(double* vtkNotUsed(position)) {}


  virtual void OnDropFiles(vtkStringArray* vtkNotUsed(filePaths)) {}


  virtual void HighlightProp(vtkProp* prop);

  virtual void HighlightActor2D(vtkActor2D* actor2D);

  virtual void HighlightProp3D(vtkProp3D* prop3D);


  vtkSetVector3Macro(PickColor, double);

  vtkGetVectorMacro(PickColor, double, 3);


  vtkSetMacro(MouseWheelMotionFactor, double);

  vtkGetMacro(MouseWheelMotionFactor, double);


  vtkGetObjectMacro(TDxStyle, vtkTDxInteractorStyle);

  virtual void SetTDxStyle(vtkTDxInteractorStyle* tdxStyle);


  void DelegateTDxEvent(unsigned long event, void* calldata);


protected:

  vtkInteractorStyle();

  ~vtkInteractorStyle() override;


  static void ProcessEvents(

    vtkObject* object, unsigned long event, void* clientdata, void* calldata);


  // Keep track of current state

  int State;

  int AnimState;


  // Should observers be handled here, should we fire timers

  vtkTypeBool HandleObservers;

  vtkTypeBool UseTimers;

  int TimerId; // keep track of the timers that are created/destroyed


  vtkTypeBool AutoAdjustCameraClippingRange;


  // For picking and highlighting props

  vtkOutlineSource* Outline;

  vtkPolyDataMapper* OutlineMapper;

  vtkActor* OutlineActor;

  vtkRenderer* PickedRenderer;

  vtkProp* CurrentProp;

  vtkActor2D* PickedActor2D;

  int PropPicked;      // bool: prop picked?

  double PickColor[3]; // support 2D picking

  double MouseWheelMotionFactor;


  // Control the timer duration

  unsigned long TimerDuration; // in milliseconds


  // Forward events to the RenderWindowInteractor

  vtkEventForwarderCommand* EventForwarder;


  vtkTDxInteractorStyle* TDxStyle;


private:

  vtkInteractorStyle(const vtkInteractorStyle&) = delete;

  void operator=(const vtkInteractorStyle&) = delete;

};


#endif