vtkOrientationMarkerWidget.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 vtkOrientationMarkerWidget_h
#define vtkOrientationMarkerWidget_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkInteractorObserver.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor2D;
class vtkPolyData;
class vtkProp;
class vtkOrientationMarkerWidgetObserver;
class vtkRenderer;
 
class VTKINTERACTIONWIDGETS_EXPORT VTK_MARSHALAUTO vtkOrientationMarkerWidget
  : public vtkInteractorObserver
{
public:
  static vtkOrientationMarkerWidget* New();
  vtkTypeMacro(vtkOrientationMarkerWidget, vtkInteractorObserver);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void SetRenderer(vtkRenderer* renderer);
  vtkRenderer* GetRenderer();


  virtual void SetOrientationMarker(vtkProp* prop);
  vtkGetObjectMacro(OrientationMarker, vtkProp);

  void SetEnabled(int) override;

  void ExecuteCameraUpdateEvent(vtkObject* o, unsigned long event, void* calldata);


  void SetInteractive(vtkTypeBool interact);
  vtkGetMacro(Interactive, vtkTypeBool);
  vtkBooleanMacro(Interactive, vtkTypeBool);


  void SetOutlineColor(double r, double g, double b);
  double* GetOutlineColor() VTK_SIZEHINT(3);


  vtkSetVector4Macro(Viewport, double);
  vtkGetVector4Macro(Viewport, double);


  vtkSetClampMacro(Tolerance, int, 1, 10);
  vtkGetMacro(Tolerance, int);


  vtkSetClampMacro(Zoom, double, 0.1, 10.0);
  vtkGetMacro(Zoom, double);


  void Modified() override;


  void EndInteraction() override;


  void SetShouldConstrainSize(vtkTypeBool shouldConstrainSize);
  vtkGetMacro(ShouldConstrainSize, vtkTypeBool);


  bool SetSizeConstraintDimensionSizes(int minDimensionSize, int maxDimensionSize);


  vtkGetMacro(MinDimensionSize, int);


  vtkGetMacro(MaxDimensionSize, int);
 
protected:
  vtkOrientationMarkerWidget();
  ~vtkOrientationMarkerWidget() override;
 
  vtkRenderer* Renderer;
  vtkProp* OrientationMarker;
  vtkPolyData* Outline;
  vtkActor2D* OutlineActor;
 
  unsigned long StartEventObserverId;
 
  static void ProcessEvents(
    vtkObject* object, unsigned long event, void* clientdata, void* calldata);
 
  // ProcessEvents() dispatches to these methods.
  virtual void OnLeftButtonDown();
  virtual void OnLeftButtonUp();
  virtual void OnMouseMove();
 
  // observer to update the renderer's camera
  vtkOrientationMarkerWidgetObserver* Observer;
 
  vtkTypeBool Interactive;
  int Tolerance;
  int Moving;
  double Zoom = 1.0;
 
  // viewport to position/size this widget
  double Viewport[4];
 
  // used to compute relative movements
  int StartPosition[2];
 
  // Manage the state of the widget
  int State;
  enum WidgetState
  {
    Outside = 0,
    Inside,
    Translating,
    AdjustingP1,
    AdjustingP2,
    AdjustingP3,
    AdjustingP4
  };
 
  // Whether the min/max size constraints should be applied.
  vtkTypeBool ShouldConstrainSize = 0;
  // The minimum dimension size to be allowed for width and height.
  int MinDimensionSize = 20;
  // The maximum dimension size to be allowed for width and height.
  int MaxDimensionSize = 500;
 
  bool OrientationMarkerBound = false;
  bool RendererBound = false;
  bool EventsBound = false;
 
  // use to determine what state the mouse is over, edge1 p1, etc.
  // returns a state from the WidgetState enum above
  virtual int ComputeStateBasedOnPosition(int X, int Y, int* pos1, int* pos2);
 
  // set the cursor to the correct shape based on State argument
  virtual void SetCursor(int state);
 
  // adjust the viewport depending on state
  void MoveWidget(int X, int Y);
  void ResizeTopLeft(int X, int Y);
  void ResizeTopRight(int X, int Y);
  void ResizeBottomLeft(int X, int Y);
  void ResizeBottomRight(int X, int Y);
 
  void SquareRenderer();
  void UpdateOutline();
 
  // Used to reverse compute the Viewport ivar with respect to the current
  // renderer viewport
  void UpdateViewport();
  // Used to compute and set the viewport on the internal renderer based on the
  // Viewport ivar. The computed viewport will be with respect to the whole
  // render window
  void UpdateInternalViewport();
 
  // Resize the widget if it is outside of the current size constraints,
  // or if the widget is not square.
  void ResizeToFitSizeConstraints();
 
  void BindOrientationMarker();
  void UnBindOrientationMarker();
  void BindRenderer();
  void UnBindRenderer();
  void BindEvents();
  void UnBindEvents();
 
private:
  vtkOrientationMarkerWidget(const vtkOrientationMarkerWidget&) = delete;
  void operator=(const vtkOrientationMarkerWidget&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif