vtkWidgetRepresentation.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 vtkWidgetRepresentation_h
#define vtkWidgetRepresentation_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkNew.h"                      // for ivars
#include "vtkProp.h"
#include "vtkWeakPointer.h"   // needed for vtkWeakPointer iVar.
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractPropPicker;
class vtkAbstractWidget;
class vtkMatrix4x4;
class vtkPickingManager;
class vtkProp3D;
class vtkRenderWindowInteractor;
class vtkRenderer;
class vtkTransform;
 
class VTKINTERACTIONWIDGETS_EXPORT VTK_MARSHALAUTO vtkWidgetRepresentation : public vtkProp
{
public:
 
  vtkTypeMacro(vtkWidgetRepresentation, vtkProp);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkBooleanMacro(PickingManaged, bool);
  void SetPickingManaged(bool managed);
  vtkGetMacro(PickingManaged, bool);
 
 
  virtual void SetRenderer(vtkRenderer* ren);
  virtual vtkRenderer* GetRenderer();
  virtual void BuildRepresentation() = 0;
 
  virtual void PlaceWidget(double vtkNotUsed(bounds)[6]);
  virtual void StartWidgetInteraction(double eventPos[2]) { (void)eventPos; }
  virtual void WidgetInteraction(double newEventPos[2]) { (void)newEventPos; }
  virtual void EndWidgetInteraction(double newEventPos[2]) { (void)newEventPos; }
  virtual int ComputeInteractionState(int X, int Y, int modify = 0);
  virtual int GetInteractionState() { return this->InteractionState; }
  virtual void Highlight(int vtkNotUsed(highlightOn)) {}
 
  // Widgets were originally designed to be driven by 2D mouse events
  // With Virtual Reality and multitouch we get mnore complex events
  // that may involve multiple pointers as well as 3D pointers and
  // orientations. As such we provide pointers to the interactor
  // widget and an event type so that representations can access the
  // values they need.
  virtual void StartComplexInteraction(
    vtkRenderWindowInteractor*, vtkAbstractWidget*, unsigned long /* event */, void* /*callData*/)
  {
  }
  virtual void ComplexInteraction(
    vtkRenderWindowInteractor*, vtkAbstractWidget*, unsigned long /* event */, void* /* callData */)
  {
  }
  virtual void EndComplexInteraction(
    vtkRenderWindowInteractor*, vtkAbstractWidget*, unsigned long /* event */, void* /* callData */)
  {
  }
  virtual int ComputeComplexInteractionState(vtkRenderWindowInteractor* iren,
    vtkAbstractWidget* widget, unsigned long event, void* callData, int modify = 0);
 
 
  vtkSetClampMacro(PlaceFactor, double, 0.01, VTK_DOUBLE_MAX);
  vtkGetMacro(PlaceFactor, double);
 
 
  vtkSetClampMacro(HandleSize, double, 0.001, 1000);
  vtkGetMacro(HandleSize, double);
 
 
  vtkGetMacro(NeedToRender, vtkTypeBool);
  vtkSetClampMacro(NeedToRender, vtkTypeBool, 0, 1);
  vtkBooleanMacro(NeedToRender, vtkTypeBool);
 
  double* GetBounds() VTK_SIZEHINT(6) override { return nullptr; }
  void ShallowCopy(vtkProp* prop) override;
  void GetActors(vtkPropCollection*) override {}
  void GetActors2D(vtkPropCollection*) override {}
  void GetVolumes(vtkPropCollection*) override {}
  void ReleaseGraphicsResources(vtkWindow*) override {}
  int RenderOverlay(vtkViewport* vtkNotUsed(viewport)) override { return 0; }
  int RenderOpaqueGeometry(vtkViewport* vtkNotUsed(viewport)) override { return 0; }
  int RenderTranslucentPolygonalGeometry(vtkViewport* vtkNotUsed(viewport)) override { return 0; }
  int RenderVolumetricGeometry(vtkViewport* vtkNotUsed(viewport)) override { return 0; }
  vtkTypeBool HasTranslucentPolygonalGeometry() override { return 0; }
 
  virtual void RegisterPickers();
 
  virtual void UnRegisterPickers();
 
 
  enum Axis
  {
    NONE = -1,
    XAxis = 0,
    YAxis = 1,
    ZAxis = 2,
    Custom = 3
  };
 
protected:
  vtkWidgetRepresentation();
  ~vtkWidgetRepresentation() override;
 
  // The renderer in which this widget is placed
  vtkWeakPointer<vtkRenderer> Renderer;
 
  // The state of this representation based on a recent event
  int InteractionState;
 
  // These are used to track the beginning of interaction with the representation
  // It's dimensioned [3] because some events re processed in 3D.
  double StartEventPosition[3];
 
  // Instance variable and members supporting suclasses
  double PlaceFactor; // Used to control how widget is placed around bounding box
  int Placed;         // Indicate whether widget has been placed
  void AdjustBounds(double bounds[6], double newBounds[6], double center[3]);
  double InitialBounds[6]; // initial bounds on place widget (valid after PlaceWidget)
  double InitialLength;    // initial length on place widget
 
  // Sizing handles is tricky because the procedure requires information
  // relative to the last pick, as well as a live renderer to perform
  // coordinate conversions. In some cases, a pick is never made so handle
  // sizing has to follow a different path. The following ivars help with
  // this process.
  int ValidPick; // indicate when valid picks are made
 
  // This variable controls whether the picking is managed by the Picking
  // Manager or not. True by default.
  bool PickingManaged;
 
  vtkPickingManager* GetPickingManager();
 
  vtkAssemblyPath* GetAssemblyPath(double X, double Y, double Z, vtkAbstractPropPicker* picker);
  vtkAssemblyPath* GetAssemblyPath3DPoint(double pos[3], vtkAbstractPropPicker* picker);
 
  // Helper function to cull events if they are not near to the actual widget
  // representation. This is needed typically in situations of extreme zoom
  // for 3D widgets. The current event position, and 3D bounds of the widget
  // are provided.
  bool NearbyEvent(int X, int Y, double bounds[6]);
 
  // Members use to control handle size. The two methods return a "radius"
  // in world coordinates. Note that the HandleSize data member is used
  // internal to the SizeHandles__() methods.
  double HandleSize; // controlling relative size of widget handles
  double SizeHandlesRelativeToViewport(double factor, double pos[3]);
  double SizeHandlesInPixels(double factor, double pos[3]);
 
  // Try and reduce multiple renders
  vtkTypeBool NeedToRender;
 
  // This is the time that the representation was built. This data member
  // can be used to reduce the time spent building the widget.
  vtkTimeStamp BuildTime;
 
  // update the pose of a prop based on two sets of
  // position, orientation vectors
  void UpdatePropPose(vtkProp3D* prop, const double* pos1, const double* orient1,
    const double* pos2, const double* orient2);
  vtkNew<vtkTransform> TempTransform;
  vtkNew<vtkMatrix4x4> TempMatrix;
 
private:
  vtkWidgetRepresentation(const vtkWidgetRepresentation&) = delete;
  void operator=(const vtkWidgetRepresentation&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif