vtkControlPointsItem.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 vtkControlPointsItem_h
#define vtkControlPointsItem_h

#include "vtkPlot.h"

#include "vtkChartsCoreModule.h" // For export macro
#include "vtkCommand.h"          // For vtkCommand enum
#include "vtkSmartPointer.h"     // For SmartPointer
#include "vtkVector.h"           // For vtkVector2f
#include "vtkWrappingHints.h"    // For VTK_MARSHALAUTO
#include <string>                // Used by GetControlPointLabel

VTK_ABI_NAMESPACE_BEGIN
class vtkCallbackCommand;
class vtkContext2D;
class vtkControlPointsAddPointItem;
class vtkPiecewisePointHandleItem;
class vtkPoints2D;
class vtkTransform2D;

class VTKCHARTSCORE_EXPORT VTK_MARSHALAUTO vtkControlPointsItem : public vtkPlot
{
public:
  vtkTypeMacro(vtkControlPointsItem, vtkPlot);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  // Events fires by this class (and subclasses).
  // \li CurrentPointChangedEvent is fired when the current point index is changed.
  // \li CurrentPointEditEvent is fired to request the application to show UI to
  // edit the current point.
  // \li vtkCommand::StartEvent and vtkCommand::EndEvent is fired
  // to mark groups of changes to control points.
  enum
  {
    CurrentPointChangedEvent = vtkCommand::UserEvent,
    CurrentPointEditEvent
  };

  void GetBounds(double bounds[4]) override;


  vtkSetVector4Macro(UserBounds, double);
  vtkGetVector4Macro(UserBounds, double);


  vtkSetVector4Macro(ValidBounds, double);
  vtkGetVector4Macro(ValidBounds, double);


  vtkGetMacro(ScreenPointRadius, float);
  vtkSetMacro(ScreenPointRadius, float);


  vtkGetMacro(DrawPoints, bool);
  vtkSetMacro(DrawPoints, bool);
  vtkBooleanMacro(DrawPoints, bool);

  bool Paint(vtkContext2D* painter) override;

  void SelectPoint(vtkIdType pointId);

  void SelectPoint(double* currentPoint);

  void SelectAllPoints();

  void DeselectPoint(vtkIdType pointId);

  void DeselectPoint(double* currentPoint);

  void DeselectAllPoints();

  void ToggleSelectPoint(vtkIdType pointId);

  void ToggleSelectPoint(double* currentPoint);

  bool SelectPoints(const vtkVector2f& min, const vtkVector2f& max) override;

  vtkIdType GetNumberOfSelectedPoints() const;

  vtkIdType FindPoint(double* pos);

  bool IsOverPoint(double* pos, vtkIdType pointId);

  vtkIdType GetControlPointId(double* pos);

  void GetControlPointsIds(vtkIdTypeArray* ids, bool excludeFirstAndLast = false) const;


  vtkSetMacro(StrokeMode, bool);
  vtkGetMacro(StrokeMode, bool);


  vtkSetMacro(SwitchPointsMode, bool);
  vtkGetMacro(SwitchPointsMode, bool);


  vtkSetMacro(EndPointsXMovable, bool);
  vtkGetMacro(EndPointsXMovable, bool);
  vtkSetMacro(EndPointsYMovable, bool);
  vtkGetMacro(EndPointsYMovable, bool);
  virtual bool GetEndPointsMovable();


  vtkSetMacro(EndPointsRemovable, bool);
  vtkGetMacro(EndPointsRemovable, bool);


  vtkSetMacro(ShowLabels, bool);
  vtkGetMacro(ShowLabels, bool);


  vtkSetStringMacro(LabelFormat);
  vtkGetStringMacro(LabelFormat);

  virtual vtkIdType AddPoint(double* newPos) = 0;

  virtual vtkIdType RemovePoint(double* pos) = 0;

  vtkIdType RemovePoint(vtkIdType pointId);

  void RemoveCurrentPoint();

  virtual vtkIdType GetNumberOfPoints() const = 0;

  virtual void GetControlPoint(vtkIdType index, double* point) const = 0;

  virtual void SetControlPoint(vtkIdType index, double* point) = 0;

  void MovePoints(const vtkVector2f& translation, vtkIdTypeArray* pointIds);

  void MovePoints(const vtkVector2f& translation, bool dontMoveFirstAndLast = false);

  void SpreadPoints(float factor, vtkIdTypeArray* pointIds);

  void SpreadPoints(float factor, bool dontSpreadFirstAndLast = false);

  vtkIdType GetCurrentPoint() const;

  void SetCurrentPoint(vtkIdType index);


  vtkGetObjectMacro(SelectedPointPen, vtkPen);


  vtkGetObjectMacro(SelectedPointBrush, vtkBrush);


  vtkGetMacro(UseAddPointItem, bool);
  vtkSetMacro(UseAddPointItem, bool);
  vtkBooleanMacro(UseAddPointItem, bool);

  vtkPlot* GetAddPointItem();

  void ResetBounds();


  bool MouseButtonPressEvent(const vtkContextMouseEvent& mouse) override;
  bool MouseDoubleClickEvent(const vtkContextMouseEvent& mouse) override;
  bool MouseButtonReleaseEvent(const vtkContextMouseEvent& mouse) override;
  bool MouseMoveEvent(const vtkContextMouseEvent& mouse) override;
  bool KeyPressEvent(const vtkContextKeyEvent& key) override;
  bool KeyReleaseEvent(const vtkContextKeyEvent& key) override;

protected:
  vtkControlPointsItem();
  ~vtkControlPointsItem() override;

  friend class vtkPiecewisePointHandleItem;

  void StartChanges();
  void EndChanges();
  void StartInteraction();
  void StartInteractionIfNotStarted();
  void Interaction();
  void EndInteraction();
  int GetInteractionsCount() const;
  virtual void emitEvent(unsigned long event, void* params = nullptr) = 0;

  static void CallComputePoints(
    vtkObject* sender, unsigned long event, void* receiver, void* params);


  virtual void ComputePoints();
  virtual vtkMTimeType GetControlPointsMTime() = 0;

  bool Hit(const vtkContextMouseEvent& mouse) override;


  bool ClampValidDataPos(double pos[2]);
  bool ClampValidScreenPos(double pos[2]);


  void DrawUnselectedPoints(vtkContext2D* painter);
  void DrawSelectedPoints(vtkContext2D* painter);
  virtual void DrawPoint(vtkContext2D* painter, vtkIdType index);

  void SetCurrentPointPos(const vtkVector2f& newPos);
  vtkIdType SetPointPos(vtkIdType point, const vtkVector2f& newPos);
  void MoveCurrentPoint(const vtkVector2f& translation);
  vtkIdType MovePoint(vtkIdType point, const vtkVector2f& translation);

  vtkVector2f GetSelectionCenterOfMass() const;
  vtkVector2f GetCenterOfMass(vtkIdTypeArray* pointIDs) const;

  void Stroke(const vtkVector2f& newPos);
  virtual void EditPoint(float vtkNotUsed(tX), float vtkNotUsed(tY));

  virtual std::string GetControlPointLabel(vtkIdType index);

  void AddPointId(vtkIdType addedPointId);

  bool IsEndPointPicked();

  bool IsPointRemovable(vtkIdType pointId);

  virtual void ComputeBounds(double* bounds);

  vtkNew<vtkCallbackCommand> Callback;
  vtkNew<vtkPen> SelectedPointPen;
  vtkNew<vtkBrush> SelectedPointBrush;
  int BlockUpdates = 0;
  int StartedInteractions = 0;
  int StartedChanges = 0;
  vtkIdType CurrentPoint = -1;

  double Bounds[4] = { 0., -1., 0., -1. };
  double UserBounds[4] = { 0., -1., 0., -1. };
  double ValidBounds[4] = { 0., -1., 0., -1. };

  vtkNew<vtkTransform2D> ControlPointsTransform;
  float ScreenPointRadius = 6.f;

  bool DrawPoints = true;
  bool StrokeMode = false;
  bool SwitchPointsMode = false;
  bool MouseMoved = false;
  bool EnforceValidFunction = true;
  vtkIdType PointToDelete = -1;
  bool PointAboutToBeDeleted = false;
  vtkIdType PointToToggle = -1;
  bool PointAboutToBeToggled = false;
  bool InvertShadow = false;
  bool EndPointsXMovable = true;
  bool EndPointsYMovable = true;
  bool EndPointsRemovable = true;
  bool ShowLabels = false;
  char* LabelFormat = nullptr;

private:
  vtkControlPointsItem(const vtkControlPointsItem&) = delete;
  void operator=(const vtkControlPointsItem&) = delete;

  void ComputeBounds();

  vtkIdType RemovePointId(vtkIdType removedPointId);

  bool UseAddPointItem = false;
  vtkNew<vtkControlPointsAddPointItem> AddPointItem;
};
VTK_ABI_NAMESPACE_END
#endif