vtkHandleRepresentation.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 vtkHandleRepresentation_h
#define vtkHandleRepresentation_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkWidgetRepresentation.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCoordinate;
class vtkRenderer;
class vtkPointPlacer;
 
class VTKINTERACTIONWIDGETS_EXPORT VTK_MARSHALAUTO vtkHandleRepresentation
  : public vtkWidgetRepresentation
{
public:
 
  vtkTypeMacro(vtkHandleRepresentation, vtkWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  virtual void SetDisplayPosition(double pos[2]);
  virtual void GetDisplayPosition(double pos[2]);
  virtual double* GetDisplayPosition() VTK_SIZEHINT(2);
  virtual void SetWorldPosition(double pos[3]);
  virtual void GetWorldPosition(double pos[3]);
  virtual double* GetWorldPosition() VTK_SIZEHINT(3);
 
 
  vtkSetClampMacro(Tolerance, int, 1, 100);
  vtkGetMacro(Tolerance, int);
 
 
  vtkSetMacro(ActiveRepresentation, vtkTypeBool);
  vtkGetMacro(ActiveRepresentation, vtkTypeBool);
  vtkBooleanMacro(ActiveRepresentation, vtkTypeBool);
 
  // Enums define the state of the representation relative to the mouse pointer
  // position. Used by ComputeInteractionState() to communicate with the
  // widget. Note that ComputeInteractionState() and several other methods
  // must be implemented by subclasses.
  enum InteractionStateType
  {
    Outside = 0,
    Nearby,
    Selecting,
    Translating,
    Scaling
  };
 
 
  vtkSetClampMacro(InteractionState, int, Outside, Scaling);
 
 
  vtkSetMacro(Constrained, vtkTypeBool);
  vtkGetMacro(Constrained, vtkTypeBool);
  vtkBooleanMacro(Constrained, vtkTypeBool);
 
  virtual int CheckConstraint(vtkRenderer* renderer, double pos[2]);
 
 
  void ShallowCopy(vtkProp* prop) override;
  virtual void DeepCopy(vtkProp* prop);
  void SetRenderer(vtkRenderer* ren) override;
 
  vtkMTimeType GetMTime() override;
 
 
  virtual void SetPointPlacer(vtkPointPlacer*);
  vtkGetObjectMacro(PointPlacer, vtkPointPlacer);
 
 
  virtual void GetTranslationVector(const double* p1, const double* p2, double* v) const;
 
 
  virtual void Translate(const double* p1, const double* p2);
 
 
  virtual void Translate(const double* v);
 
 
  vtkGetMacro(TranslationAxis, int);
  vtkSetClampMacro(TranslationAxis, int, -1, 2);
 
 
  void SetXTranslationAxisOn() { this->TranslationAxis = Axis::XAxis; }
  void SetYTranslationAxisOn() { this->TranslationAxis = Axis::YAxis; }
  void SetZTranslationAxisOn() { this->TranslationAxis = Axis::ZAxis; }
  void SetCustomTranslationAxisOn() { this->TranslationAxis = Axis::Custom; }
  void SetTranslationAxisOff() { this->TranslationAxis = Axis::NONE; }
 
 
  vtkGetVector3Macro(CustomTranslationAxis, double);
  vtkSetVector3Macro(CustomTranslationAxis, double);
 
 
  bool IsTranslationConstrained() { return this->TranslationAxis != Axis::NONE; }
 
protected:
  vtkHandleRepresentation();
  ~vtkHandleRepresentation() override;
 
  int Tolerance = 15;
  vtkTypeBool ActiveRepresentation = false;
  vtkTypeBool Constrained = false;
 
  // Two vtkCoordinates are available to subclasses, one in display
  // coordinates and the other in world coordinates. These facilitate
  // the conversion between these two systems. Note that the WorldPosition
  // is the ultimate maintainer of position.
  vtkNew<vtkCoordinate> DisplayPosition;
  vtkNew<vtkCoordinate> WorldPosition;
 
  // Keep track of when coordinates were changed
  vtkTimeStamp DisplayPositionTime;
  vtkTimeStamp WorldPositionTime;
 
  // Constraint the placement of handles.
  vtkPointPlacer* PointPlacer;
 
  // Constraint axis translation
  int TranslationAxis = Axis::NONE;
  double CustomTranslationAxis[3] = { 1.0, 0.0, 0.0 };
 
private:
  vtkHandleRepresentation(const vtkHandleRepresentation&) = delete;
  void operator=(const vtkHandleRepresentation&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif