Adding vtkRangeHandlesItem

This add a new item, vtkRangeHandlesItem
This items are perfect for manipulating the range of a vtkChartXY.
They emit an EndInteractionEvent when the interaction has finished
and the new range can be recovered with GetHandlesRange.
This also adds a test

Charts/Core/CMakeLists.txt

@@ -41,6 +41,7 @@ set(classes
   vtkPlotPoints
   vtkPlotStacked
   vtkPlotSurface
+  vtkRangeHandlesItem
   vtkScalarsToColorsItem
   vtkScatterPlotMatrix
   )

Charts/Core/Testing/Cxx/CMakeLists.txt

@@ -93,6 +93,7 @@ vtk_add_test_cxx(vtkChartsCoreCxxTests tests
   TestPieChart.cxx
   TestPlotMatrix.cxx
   TestPropItem.cxx
+  TestRangeHandlesItemEvents.cxx,NO_DATA,NO_VALID
   TestScalarsToColors.cxx
   TestScatterPlot.cxx
   TestScatterPlotMatrix.cxx

Charts/Core/Testing/Cxx/TestColorTransferFunction.cxx

@@ -21,6 +21,7 @@
 #include "vtkContextDevice2D.h"
 #include "vtkContextScene.h"
 #include "vtkContextView.h"
+#include "vtkRangeHandlesItem.h"
 #include "vtkRenderWindow.h"
 #include "vtkRenderWindowInteractor.h"
 #include "vtkRenderer.h"
@@ -57,6 +58,10 @@ int TestColorTransferFunction(int ,  char * [])
   controlPointsItem->SetUserBounds(0., 255., 0., 1.);
   chart->AddPlot(controlPointsItem);
 
+  vtkNew<vtkRangeHandlesItem> rangeHandlesItem;
+  rangeHandlesItem->SetColorTransferFunction(colorTransferFunction);
+  chart->AddPlot(rangeHandlesItem);
+
   // Finally render the scene and compare the image to a reference image
   view->GetRenderWindow()->SetMultiSamples(1);
   view->GetInteractor()->Initialize();

Charts/Core/Testing/Cxx/TestRangeHandlesItemEvents.cxx

+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    TestVector.cxx
+
+  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.
+
+=========================================================================*/
+
+#include "vtkChartXY.h"
+#include "vtkColorTransferFunction.h"
+#include "vtkContextInteractorStyle.h"
+#include "vtkContextScene.h"
+#include "vtkInteractorEventRecorder.h"
+#include "vtkNew.h"
+#include "vtkRangeHandlesItem.h"
+#include "vtkRenderWindowInteractor.h"
+
+#include <iostream>
+#include <map>
+
+//----------------------------------------------------------------------------
+class vtkRangeHandlesCallBack : public vtkCommand
+{
+public:
+  static vtkRangeHandlesCallBack* New() { return new vtkRangeHandlesCallBack; }
+
+  void Execute(vtkObject* caller, unsigned long event, void* vtkNotUsed(callData)) override
+  {
+    vtkRangeHandlesItem* self = vtkRangeHandlesItem::SafeDownCast(caller);
+    if (!self)
+    {
+      return;
+    }
+    if (event == vtkCommand::EndInteractionEvent)
+    {
+      self->GetHandlesRange(this->Range);
+    }
+    if (this->EventSpy.count(event) == 0)
+    {
+      this->EventSpy[event] = 0;
+    }
+    ++this->EventSpy[event];
+    std::cout << "InvokedEvent: " << event << this->EventSpy[event] << std::endl;
+  }
+  std::map<unsigned long, int> EventSpy;
+  double Range[2];
+};
+
+//----------------------------------------------------------------------------
+int TestRangeHandlesItemEvents(int, char*[])
+{
+  vtkNew<vtkColorTransferFunction> transferFunction;
+  transferFunction->AddHSVSegment(50., 0., 1., 1., 85., 0.3333, 1., 1.);
+  transferFunction->AddHSVSegment(85., 0.3333, 1., 1., 170., 0.6666, 1., 1.);
+  transferFunction->AddHSVSegment(170., 0.6666, 1., 1., 200., 0., 1., 1.);
+
+  vtkNew<vtkRangeHandlesItem> rangeHandles;
+  rangeHandles->SetColorTransferFunction(transferFunction);
+  rangeHandles->ComputeHandlesDrawRange();
+  double range[2];
+  rangeHandles->GetHandlesRange(range);
+  if (range[0] != 50 || range[1] != 200)
+  {
+    std::cerr << "Unexepected range in range handle : [" << range[0] << ", " << range[1]
+              << "]. Expecting : [50, 200]." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  vtkNew<vtkRangeHandlesCallBack> cbk;
+  rangeHandles->AddObserver(vtkCommand::StartInteractionEvent, cbk);
+  rangeHandles->AddObserver(vtkCommand::InteractionEvent, cbk);
+  rangeHandles->AddObserver(vtkCommand::EndInteractionEvent, cbk);
+
+  vtkNew<vtkChartXY> chart;
+  chart->AddPlot(rangeHandles);
+
+  vtkNew<vtkContextScene> scene;
+  scene->AddItem(rangeHandles);
+
+  vtkNew<vtkContextInteractorStyle> interactorStyle;
+  interactorStyle->SetScene(scene);
+
+  vtkNew<vtkRenderWindowInteractor> iren;
+  iren->SetInteractorStyle(interactorStyle);
+
+  vtkNew<vtkInteractorEventRecorder> recorder;
+  recorder->SetInteractor(iren);
+  recorder->ReadFromInputStringOn();
+
+  // Move left handle
+  const char leftEvents[] = "# StreamVersion 1\n"
+                            "LeftButtonPressEvent 51 1 0 0 0 0 0\n"
+                            "MouseMoveEvent 70 1 0 0 0 0 0\n"
+                            "LeftButtonReleaseEvent 70 1 0 0 0 0 0\n";
+  recorder->SetInputString(leftEvents);
+  recorder->Play();
+
+  if (cbk->EventSpy[vtkCommand::StartInteractionEvent] != 1 ||
+    cbk->EventSpy[vtkCommand::InteractionEvent] != 1 ||
+    cbk->EventSpy[vtkCommand::EndInteractionEvent] != 1)
+  {
+    std::cerr << "Wrong number of fired events : "
+              << cbk->EventSpy[vtkCommand::StartInteractionEvent] << " "
+              << cbk->EventSpy[vtkCommand::InteractionEvent] << " "
+              << cbk->EventSpy[vtkCommand::EndInteractionEvent] << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  if (cbk->Range[0] != 69.25 || cbk->Range[1] != 200)
+  {
+    std::cerr << "Unexepected range in range handle : [" << cbk->Range[0] << ", " << cbk->Range[1]
+              << "]. Expecting : [69.25, 200]." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  cbk->EventSpy.clear();
+
+  // Move right handle
+  const char rightEvents[] = "# StreamVersion 1\n"
+                             "LeftButtonPressEvent 199 1 0 0 0 0 0\n"
+                             "MouseMoveEvent 120 1 0 0 0 0 0\n"
+                             "LeftButtonReleaseEvent 120 1 0 0 0 0 0\n";
+  recorder->SetInputString(rightEvents);
+  recorder->Play();
+
+  if (cbk->EventSpy[vtkCommand::StartInteractionEvent] != 1 ||
+    cbk->EventSpy[vtkCommand::InteractionEvent] != 1 ||
+    cbk->EventSpy[vtkCommand::EndInteractionEvent] != 1)
+  {
+    std::cerr << "Wrong number of fired events : "
+              << cbk->EventSpy[vtkCommand::StartInteractionEvent] << " "
+              << cbk->EventSpy[vtkCommand::InteractionEvent] << " "
+              << cbk->EventSpy[vtkCommand::EndInteractionEvent] << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  if (cbk->Range[0] != 50 || cbk->Range[1] != 120.75)
+  {
+    std::cerr << "Unexepected range in range handle : [" << cbk->Range[0] << ", " << cbk->Range[1]
+              << "]. Expecting : [50, 120.75]." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}

Charts/Core/Testing/Data/Baseline/TestColorTransferFunction.png.sha512

-9547e9acf5d70c04fec279184a180f5aa2d60310524cdc20034358ed7bebf4dd03a909ae1dc2560b02c433659ebdebb2ac292cf018aaa66166e41fea8275efef
+97a34b9d4fbaa394d787193a0373cfecdec1dd1f9788aec09e941e1d86f62404722e0cdec2a48e85f97940e16b69240ef58abf803771243e3830e2e779135e28

Charts/Core/Testing/Data/Baseline/TestColorTransferFunction_1.png.sha512

-577fd4c4b96042ca3171ccfbca92e0cead5cad0b768bb4ac9dc122714e0ef0a56d01fe7ab2f4c9eced2927156731f6b4483d383c56be96ce88034fbc220b864e

Charts/Core/Testing/Data/Baseline/TestColorTransferFunction_2.png.sha512

-3300634ed1383f00039e4d86cf6ead42be457333faf5589f46de78664a1181af937dff9e369385faeaf7107c78f5de9ebe023b8e98ba9531c23e57dc75fee491

Charts/Core/vtkRangeHandlesItem.cxx

+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    vtkRangeHandlesItem.cxx
+
+  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.
+
+=========================================================================*/
+
+#include "vtkRangeHandlesItem.h"
+
+#include "vtkBrush.h"
+#include "vtkColorTransferFunction.h"
+#include "vtkCommand.h"
+#include "vtkContext2D.h"
+#include "vtkContextMouseEvent.h"
+#include "vtkContextScene.h"
+#include "vtkObjectFactory.h"
+#include "vtkPen.h"
+#include "vtkTransform2D.h"
+
+//-----------------------------------------------------------------------------
+vtkStandardNewMacro(vtkRangeHandlesItem);
+vtkSetObjectImplementationMacro(
+  vtkRangeHandlesItem, ColorTransferFunction, vtkColorTransferFunction);
+
+//-----------------------------------------------------------------------------
+vtkRangeHandlesItem::vtkRangeHandlesItem()
+{
+  this->Brush->SetColor(125, 135, 144, 200);
+  this->ActiveHandleBrush->SetColor(255, 0, 255, 200);
+  this->RangeLabelBrush->SetColor(255, 255, 255, 200);
+}
+
+//-----------------------------------------------------------------------------
+vtkRangeHandlesItem::~vtkRangeHandlesItem()
+{
+  if (this->ColorTransferFunction)
+  {
+    this->ColorTransferFunction->Delete();
+  }
+}
+
+//-----------------------------------------------------------------------------
+void vtkRangeHandlesItem::ComputeHandlesDrawRange()
+{
+  double screenBounds[4];
+  this->GetBounds(screenBounds);
+  this->HandleDelta = static_cast<float>((screenBounds[1] - screenBounds[0]) / 200.0);
+  if (this->ActiveHandle == vtkRangeHandlesItem::LEFT_HANDLE)
+  {
+    this->LeftHandleDrawRange[0] = this->ActiveHandlePosition - this->HandleDelta;
+    this->LeftHandleDrawRange[1] = this->ActiveHandlePosition + this->HandleDelta;
+  }
+  else
+  {
+    this->LeftHandleDrawRange[0] = screenBounds[0];
+    this->LeftHandleDrawRange[1] = screenBounds[0] + 2.0f * this->HandleDelta;
+  }
+  if (this->ActiveHandle == vtkRangeHandlesItem::RIGHT_HANDLE)
+  {
+    this->RightHandleDrawRange[0] = this->ActiveHandlePosition - this->HandleDelta;
+    this->RightHandleDrawRange[1] = this->ActiveHandlePosition + this->HandleDelta;
+  }
+  else
+  {
+    this->RightHandleDrawRange[0] = screenBounds[1];
+    this->RightHandleDrawRange[1] = screenBounds[1] - 2.0f * this->HandleDelta;
+  }
+}
+
+//-----------------------------------------------------------------------------
+bool vtkRangeHandlesItem::Paint(vtkContext2D* painter)
+{
+  if (!this->Visible || !this->ColorTransferFunction)
+  {
+    return false;
+  }
+
+  vtkNew<vtkPen> transparentPen;
+  transparentPen->SetLineType(vtkPen::NO_PEN);
+  painter->ApplyPen(transparentPen);
+
+  // Compute handles draw range
+  this->ComputeHandlesDrawRange();
+
+  // Draw Left Handle
+  if (this->ActiveHandle == vtkRangeHandlesItem::LEFT_HANDLE ||
+    this->HoveredHandle == vtkRangeHandlesItem::LEFT_HANDLE)
+  {
+    painter->ApplyBrush(this->ActiveHandleBrush);
+  }
+  else
+  {
+    painter->ApplyBrush(this->Brush);
+  }
+  painter->DrawQuad(this->LeftHandleDrawRange[0], 0, this->LeftHandleDrawRange[0], 1,
+    this->LeftHandleDrawRange[1], 1, this->LeftHandleDrawRange[1], 0);
+
+  // Draw Right Handle
+  if (this->ActiveHandle == vtkRangeHandlesItem::RIGHT_HANDLE ||
+    this->HoveredHandle == vtkRangeHandlesItem::RIGHT_HANDLE)
+  {
+    painter->ApplyBrush(this->ActiveHandleBrush);
+  }
+  else
+  {
+    painter->ApplyBrush(this->Brush);
+  }
+  painter->DrawQuad(this->RightHandleDrawRange[0], 0, this->RightHandleDrawRange[0], 1,
+    this->RightHandleDrawRange[1], 1, this->RightHandleDrawRange[1], 0);
+
+  // Draw range info
+  if (this->ActiveHandle != vtkRangeHandlesItem::NO_HANDLE ||
+    this->HoveredHandle != vtkRangeHandlesItem::NO_HANDLE)
+  {
+    double range[2];
+    this->GetHandlesRange(range);
+    std::string label =
+      "Range : [" + std::to_string(range[0]) + ", " + std::to_string(range[1]) + "]";
+
+    vtkVector2f labelBounds[2];
+    painter->ComputeStringBounds(label, labelBounds[0].GetData());
+
+    float scale[2];
+    painter->GetTransform()->GetScale(scale);
+    double screenBounds[4];
+    this->GetBounds(screenBounds);
+
+    float labelStart =
+      static_cast<float>(screenBounds[1] + screenBounds[0]) / 2.0f - labelBounds[1].GetX() / 2.0f;
+    painter->ApplyBrush(this->RangeLabelBrush);
+    painter->DrawRect(labelStart - 5.0f / scale[0], 0, labelBounds[1].GetX() + 8.0f / scale[0],
+      labelBounds[1].GetY() + 10.0f / scale[1]);
+    painter->DrawString(labelStart, 3.0f / scale[1], label);
+  }
+
+  this->PaintChildren(painter);
+  return true;
+}
+
+//-----------------------------------------------------------------------------
+void vtkRangeHandlesItem::PrintSelf(ostream& os, vtkIndent indent)
+{
+  this->Superclass::PrintSelf(os, indent);
+
+  os << indent << "ColorTransferFunction: ";
+  if (this->ColorTransferFunction)
+  {
+    os << endl;
+    this->ColorTransferFunction->PrintSelf(os, indent.GetNextIndent());
+  }
+  else
+  {
+    os << "(none)" << endl;
+  }
+  os << indent << "HoveredHandle: " << this->HoveredHandle << endl;
+  os << indent << "ActiveHandle: " << this->ActiveHandle << endl;
+  os << indent << "ActiveHandlePosition: " << this->ActiveHandlePosition << endl;
+  os << indent << "ActiveHandleRangeValue: " << this->ActiveHandleRangeValue << endl;
+}
+
+//-----------------------------------------------------------------------------
+void vtkRangeHandlesItem::GetBounds(double* bounds)
+{
+  if (!this->ColorTransferFunction)
+  {
+    vtkErrorMacro("vtkRangeHandlesItem should always be used with a ColorTransferFunction");
+    return;
+  }
+
+  double tfRange[2];
+  this->ColorTransferFunction->GetRange(tfRange);
+  double unused;
+  this->TransformDataToScreen(tfRange[0], 1, bounds[0], unused);
+  this->TransformDataToScreen(tfRange[1], 1, bounds[1], unused);
+  bounds[2] = 0;
+  bounds[3] = 1;
+}
+
+//-----------------------------------------------------------------------------
+bool vtkRangeHandlesItem::Hit(const vtkContextMouseEvent& mouse)
+{
+  // Add more tolerance than the mouse interaction to make sure handles do
+  // not stay highlighted when moving the mouse
+  vtkVector2f vpos = mouse.GetPos();
+  vtkVector2f tolerance = { 2.0f * static_cast<float>(this->HandleDelta), 0 };
+  return this->FindRangeHandle(vpos, tolerance) != vtkRangeHandlesItem::NO_HANDLE;
+}
+
+//-----------------------------------------------------------------------------
+bool vtkRangeHandlesItem::MouseButtonPressEvent(const vtkContextMouseEvent& mouse)
+{
+  vtkVector2f vpos = mouse.GetPos();
+  vtkVector2f tolerance = { 2.0f * static_cast<float>(this->HandleDelta), 0 };
+  this->HoveredHandle = vtkRangeHandlesItem::NO_HANDLE;
+  this->ActiveHandle = this->FindRangeHandle(vpos, tolerance);
+  if (this->ActiveHandle != vtkRangeHandlesItem::NO_HANDLE)
+  {
+    this->SetActiveHandlePosition(vpos.GetX());
+    this->GetScene()->SetDirty(true);
+    this->InvokeEvent(vtkCommand::StartInteractionEvent);
+    return true;
+  }
+  return false;
+}
+
+//-----------------------------------------------------------------------------
+bool vtkRangeHandlesItem::MouseButtonReleaseEvent(const vtkContextMouseEvent& mouse)
+{
+  if (this->ActiveHandle != vtkRangeHandlesItem::NO_HANDLE)
+  {
+    vtkVector2f vpos = mouse.GetPos();
+    this->SetActiveHandlePosition(vpos.GetX());
+    this->InvokeEvent(vtkCommand::EndInteractionEvent);
+    this->ActiveHandle = vtkRangeHandlesItem::NO_HANDLE;
+    this->GetScene()->SetDirty(true);
+    return true;
+  }
+  return false;
+}
+
+//-----------------------------------------------------------------------------
+bool vtkRangeHandlesItem::MouseMoveEvent(const vtkContextMouseEvent& mouse)
+{
+  if (this->ActiveHandle != vtkRangeHandlesItem::NO_HANDLE)
+  {
+    vtkVector2f vpos = mouse.GetPos();
+    this->SetActiveHandlePosition(vpos.GetX());
+    this->InvokeEvent(vtkCommand::InteractionEvent);
+    this->GetScene()->SetDirty(true);
+    return true;
+  }
+  return false;
+}
+
+//-----------------------------------------------------------------------------
+bool vtkRangeHandlesItem::MouseEnterEvent(const vtkContextMouseEvent& mouse)
+{
+  if (this->ActiveHandle == vtkRangeHandlesItem::NO_HANDLE)
+  {
+    vtkVector2f vpos = mouse.GetPos();
+    vtkVector2f tolerance = { 2.0f * static_cast<float>(this->HandleDelta), 0 };
+    this->HoveredHandle = this->FindRangeHandle(vpos, tolerance);
+    if (this->HoveredHandle != this->PreviousHoveredHandle)
+    {
+      this->GetScene()->SetDirty(true);
+      return true;
+    }
+  }
+  return false;
+}
+
+//-----------------------------------------------------------------------------
+bool vtkRangeHandlesItem::MouseLeaveEvent(const vtkContextMouseEvent& vtkNotUsed(mouse))
+{
+  if (this->ActiveHandle == vtkRangeHandlesItem::NO_HANDLE &&
+    this->HoveredHandle != vtkRangeHandlesItem::NO_HANDLE)
+  {
+    this->HoveredHandle = vtkRangeHandlesItem::NO_HANDLE;
+    this->GetScene()->SetDirty(true);
+    return true;
+  }
+  return false;
+}
+
+//-----------------------------------------------------------------------------
+int vtkRangeHandlesItem::FindRangeHandle(const vtkVector2f& point, const vtkVector2f& tolerance)
+{
+  double pos[2];
+  pos[0] = point.GetX();
+  pos[1] = point.GetY();
+  if (0 - tolerance.GetY() <= pos[1] && pos[1] <= 1 + tolerance.GetY())
+  {
+    if (this->LeftHandleDrawRange[0] - tolerance.GetX() <= pos[0] &&
+      pos[0] <= this->LeftHandleDrawRange[1] + tolerance.GetX())
+    {
+      return vtkRangeHandlesItem::LEFT_HANDLE;
+    }
+    else if (this->RightHandleDrawRange[0] - tolerance.GetX() <= pos[0] &&
+      pos[0] <= this->RightHandleDrawRange[1] + tolerance.GetX())
+    {
+      return vtkRangeHandlesItem::RIGHT_HANDLE;
+    }
+  }
+  return vtkRangeHandlesItem::NO_HANDLE;
+}
+
+//-----------------------------------------------------------------------------
+void vtkRangeHandlesItem::GetHandlesRange(double range[2])
+{
+  this->ColorTransferFunction->GetRange(range);
+  if (this->ActiveHandle != vtkRangeHandlesItem::NO_HANDLE)
+  {
+    range[this->ActiveHandle] = this->ActiveHandleRangeValue;
+  }
+}
+
+//-----------------------------------------------------------------------------
+void vtkRangeHandlesItem::SetActiveHandlePosition(double position)
+{
+  if (this->ActiveHandle != vtkRangeHandlesItem::NO_HANDLE)
+  {
+    // Clamp the position and set the handle position
+    double bounds[4];
+    double clampedPos[2] = { position, 1 };
+    this->GetBounds(bounds);
+    double minRange = bounds[0];
+    double maxRange = bounds[1];
+    bounds[0] += this->HandleDelta;
+    bounds[1] -= this->HandleDelta;
+    vtkPlot::ClampPos(clampedPos, bounds);
+    this->ActiveHandlePosition = clampedPos[0];
+
+    // Correct the position for range set
+    if (this->ActiveHandle == vtkRangeHandlesItem::LEFT_HANDLE)
+    {
+      position -= this->HandleDelta;
+    }
+    else // if (this->ActiveHandle == vtkRangeHandlesItem::RIGHT_HANDLE)
+    {
+      position += this->HandleDelta;
+    }
+
+    // Make the range value stick to the range for easier use
+    if (minRange - this->HandleDelta <= position && position <= minRange + this->HandleDelta)
+    {
+      position = minRange;
+    }
+    if (maxRange - this->HandleDelta <= position && position <= maxRange + this->HandleDelta)
+    {
+      position = maxRange;
+    }
+
+    // Transform it to data and set it
+    double unused;
+    this->TransformScreenToData(position, 1, this->ActiveHandleRangeValue, unused);
+  }
+}

Charts/Core/vtkRangeHandlesItem.h

+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    vtkRangeHandlesItem.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.
+
+=========================================================================*/
+
+/**
+ * @class   vtkRangeHandlesItem
+ * @brief   item to show and control the range of a vtkColorTransferFunction
+ *
+ * vtkRangeHandlesItem provides range handles painting and management
+ * for a provided vtkColorTransferFunction.
+ * Handles can be moved by clicking on them.
+ * The range is shown when hovering or moving the handles.
+ * It emits a StartInteractionEvent when starting to interact with a handle,
+ * an InteractionEvent when interacting with a handle and an EndInteractionEvent
+ * when releasing a handle.
+ *
+ * @sa
+ * vtkControlPointsItem
+ * vtkScalarsToColorsItem
+ * vtkColorTransferFunctionItem
+ */
+
+#ifndef vtkRangeHandlesItem_h
+#define vtkRangeHandlesItem_h
+
+#include "vtkChartsCoreModule.h" // For export macro
+#include "vtkPlot.h"
+
+class vtkColorTransferFunction;
+class vtkBrush;
+
+class VTKCHARTSCORE_EXPORT vtkRangeHandlesItem : public vtkPlot
+{
+public:
+  vtkTypeMacro(vtkRangeHandlesItem, vtkPlot);
+  void PrintSelf(ostream& os, vtkIndent indent) override;
+  static vtkRangeHandlesItem* New();
+
+  enum Handle
+  {
+    NO_HANDLE = -1,
+    LEFT_HANDLE = 0,
+    RIGHT_HANDLE = 1
+  };
+
+  /**
+   * Paint both handles and the range if
+   * a handle is active or hovered
+   */
+  bool Paint(vtkContext2D* painter) override;
+
+  /**
+   * Recover the bounds of the item
+   */
+  void GetBounds(double bounds[4]) override;
+
+  /**
+   * Recover the range currently set by the handles
+   * Use this method by observing EndInteractionEvent
+   */
+  virtual void GetHandlesRange(double range[2]);
+
+  //@{
+  /**
+   * Get/set the color transfer function to interact with.
+   */
+  void SetColorTransferFunction(vtkColorTransferFunction* ctf);
+  vtkGetObjectMacro(ColorTransferFunction, vtkColorTransferFunction);
+  //@}
+
+  /**
+   * Compute the handles draw range
+   */
+  void ComputeHandlesDrawRange();
+
+protected:
+  vtkRangeHandlesItem();
+  ~vtkRangeHandlesItem() override;
+
+  /**
+   * Returns true if the supplied x, y coordinate is around a handle
+   */
+  bool Hit(const vtkContextMouseEvent& mouse) override;
+
+  //@{
+  /**
+   * Interaction methods to interact with the handles.
+   */
+  bool MouseButtonPressEvent(const vtkContextMouseEvent& mouse) override;
+  bool MouseButtonReleaseEvent(const vtkContextMouseEvent& mouse) override;
+  bool MouseMoveEvent(const vtkContextMouseEvent& mouse) override;
+  bool MouseEnterEvent(const vtkContextMouseEvent& mouse) override;
+  bool MouseLeaveEvent(const vtkContextMouseEvent& mouse) override;
+  //@}
+
+  /**
+   * Returns the handle the provided point is over with a provided tolerance,
+   * it can be NO_HANDLE, LEFT_HANDLE or RIGHT_HANDLE
+   */
+  virtual int FindRangeHandle(const vtkVector2f& point, const vtkVector2f& tolerance);
+
+  /**
+   * Internal method to set the ActiveHandlePosition
+   * and compute the ActiveHandleRangeValue accordingly
+   */
+  void SetActiveHandlePosition(double position);
+
+private:
+  vtkRangeHandlesItem(const vtkRangeHandlesItem&) = delete;
+  void operator=(const vtkRangeHandlesItem&) = delete;
+
+  vtkColorTransferFunction* ColorTransferFunction = nullptr;
+
+  float HandleDelta = 0;
+  float LeftHandleDrawRange[2] = { 0, 0 };
+  float RightHandleDrawRange[2] = { 0, 0 };
+  int ActiveHandle = NO_HANDLE;
+  int HoveredHandle = NO_HANDLE;
+  int PreviousHoveredHandle = NO_HANDLE;
+  double ActiveHandlePosition = 0;
+  double ActiveHandleRangeValue = 0;
+  vtkNew<vtkBrush> ActiveHandleBrush;
+  vtkNew<vtkBrush> RangeLabelBrush;
+};
+
+#endif // vtkRangeHandlesItem_h