vtkControlPointsItem.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkControlPointsItem.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 vtkControlPointsItem_h
#define vtkControlPointsItem_h

#include "vtkChartsCoreModule.h" // For export macro
#include "vtkCommand.h" // For vtkCommand enum
#include "vtkPlot.h"
#include "vtkVector.h" // For vtkVector2f

class vtkCallbackCommand;
class vtkContext2D;
class vtkPoints2D;
class vtkTransform2D;

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

  // 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
  };

  virtual void GetBounds(double bounds[4]);


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


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


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

  virtual bool Paint(vtkContext2D *painter);

  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);

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

  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;


  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);

  inline 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);

  void ResetBounds();


  virtual bool MouseButtonPressEvent(const vtkContextMouseEvent &mouse);
  virtual bool MouseDoubleClickEvent(const vtkContextMouseEvent &mouse);

  virtual bool MouseMoveEvent(const vtkContextMouseEvent &mouse);

  virtual bool KeyPressEvent(const vtkContextKeyEvent &key);
  virtual bool KeyReleaseEvent(const vtkContextKeyEvent &key);

protected:
  vtkControlPointsItem();
  virtual ~vtkControlPointsItem();

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

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


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

  virtual bool Hit(const vtkContextMouseEvent &mouse);


  virtual void TransformScreenToData(const vtkVector2f& in, vtkVector2f& out);
  virtual void TransformDataToScreen(const vtkVector2f& in, vtkVector2f& out);


  virtual bool ClampPos(double pos[2], double bounds[4]);
  bool ClampValidPos(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);

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

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

  virtual vtkStdString GetControlPointLabel(vtkIdType index);

  void AddPointId(vtkIdType addedPointId);

  bool IsEndPointPicked();

  bool IsPointRemovable(vtkIdType pointId);

  virtual void ComputeBounds(double* bounds);

  virtual bool UsingLogScale() { return false; }

  vtkCallbackCommand* Callback;
  vtkPen*             SelectedPointPen;
  vtkBrush*           SelectedPointBrush;
  int                 BlockUpdates;
  int                 StartedInteractions;
  int                 StartedChanges;
  vtkIdType           CurrentPoint;

  double              Bounds[4];
  double              UserBounds[4];
  double              ValidBounds[4];

  vtkTransform2D*     Transform;
  float               ScreenPointRadius;

  bool                StrokeMode;
  bool                SwitchPointsMode;
  bool                MouseMoved;
  bool                EnforceValidFunction;
  vtkIdType           PointToDelete;
  bool                PointAboutToBeDeleted;
  vtkIdType           PointToToggle;
  bool                PointAboutToBeToggled;
  bool                InvertShadow;
  bool                EndPointsXMovable;
  bool                EndPointsYMovable;
  bool                EndPointsRemovable;
  bool                ShowLabels;
  char*               LabelFormat;
private:
  vtkControlPointsItem(const vtkControlPointsItem &) VTK_DELETE_FUNCTION;
  void operator=(const vtkControlPointsItem &) VTK_DELETE_FUNCTION;

  void      ComputeBounds();

  vtkIdType RemovePointId(vtkIdType removedPointId);
};

//-----------------------------------------------------------------------------
void vtkControlPointsItem::RemoveCurrentPoint()
{
  this->RemovePoint(this->GetCurrentPoint());
}

//-----------------------------------------------------------------------------
vtkVector2f vtkControlPointsItem::GetSelectionCenterOfMass()const
{
  return this->GetCenterOfMass(this->Selection);
}

#endif