ScrollbarView.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2026 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @author Yan Pujante
 */
#pragma once
 
#include "CustomView.h"
#include <pongasoft/VST/GUI/DrawContext.h>
#include <pongasoft/Utils/Lerp.h>
 
namespace pongasoft::VST::GUI::Views {
 
using namespace VSTGUI;

class ScrollbarView : public CustomView
{
public:
  enum class EOrientation { kHorizontal, kVertical };
 
public:
  // Constructor
  explicit ScrollbarView(const CRect &iSize) : CustomView(iSize) {}
 
  // draw
  void draw(CDrawContext *iContext) override;

  EOrientation getOrientation() const { return fOrientation; }
  void setOrientation(EOrientation iOrientation);

  ParamID getOffsetPercentTag() const { return fOffsetPercentTag; }
  void setOffsetPercentTag(ParamID offsetPercentTag);

  ParamID getZoomPercentTag() const { return fZoomPercentTag; }
  void setZoomPercentTag(ParamID zoomPercentTag);

  Margin const &getMargin() const { return fMargin; }
  void setMargin(Margin  const &iMargin) { fMargin = iMargin; needsRecomputing();}

  const CColor &getScrollbarColor() const { return fScrollbarColor; }
  void setScrollbarColor(const CColor &iColor) { fScrollbarColor = iColor; needsRecomputing(); }

  CCoord getScrollbarMinSize() const { return fScrollbarMinSize; }
  void setScrollbarMinSize(CCoord iScrollbarMinSize) { fScrollbarMinSize = iScrollbarMinSize; needsRecomputing();}

  CCoord getScrollbarGutterSpacing() const { return fScrollbarGutterSpacing; }
  void setScrollbarGutterSpacing(CCoord iScrollbarGutterSpacing) { fScrollbarGutterSpacing = iScrollbarGutterSpacing; needsRecomputing();}
 
  // showHandles
  bool showHandles() const { return fZoomHandlesSize != 0; }

  const CColor &getZoomHandlesColor() const { return fZoomHandlesColor; }
  void setZoomHandlesColor(const CColor &iColor) { fZoomHandlesColor = iColor; needsRecomputing(); }

  CCoord getZoomHandlesSize() const { return fZoomHandlesSize; }
  void setZoomHandlesSize(CCoord iSize) { fZoomHandlesSize = iSize; needsRecomputing(); }

  Range const &getShiftDragFactor() const { return fShiftDragFactor; }

  void setShiftDragFactor(Range const &iShiftDragFactor) { fShiftDragFactor = iShiftDragFactor; }

  bool getEnableZoomDoubleClick() const { return fEnableZoomDoubleClick; }
  void setEnableZoomDoubleClick(bool iEnableZoomDoubleClick) { fEnableZoomDoubleClick = iEnableZoomDoubleClick; }
 
  // offsetPercent accessor
  double getOffsetPercent() const;
  void setOffsetPercent(double iOffsetPercent);
 
  // zoomPercent accessor
  double getZoomPercent() const;
  void setZoomPercent(double iZoomPercent);
 
  CLASS_METHODS_NOCOPY(ScrollbarView, CustomView)
 
protected:
  // setViewSize
  void setViewSize(const CRect &rect, bool invalid = true) override;
 
  // registerParameters
  void registerParameters() override;
 
  // onParameterChange
  void onParameterChange(ParamID iParamID) override;
 
  // onMouseDown
  CMouseEventResult onMouseDown(CPoint &where, const CButtonState &buttons) override;
 
  // onMouseMoved
  CMouseEventResult onMouseMoved(CPoint &where, const CButtonState &buttons) override;
 
  // onMouseUp
  CMouseEventResult onMouseUp(CPoint &where, const CButtonState &buttons) override;
 
  // onMouseCancel
  CMouseEventResult onMouseCancel() override;
 
  // isVertical
  bool isVertical() const { return fOrientation == EOrientation::kVertical; }
 
protected:
  enum class DragType { kNone, kScroll, kZoomStart, kZoomEnd, kStretchStart, kStretchEnd };

  struct ZoomBox
  {
    // When comparing coordinates to be equal, we cannot really use `==` for double as it leads to errors due to
    // floating point precision. In this case, 2 decimal places if far enough.
    static constexpr auto kEqualCoord = [](double a, double b) { return std::abs(a - b) < 0.01; };
 
    CRect fViewSize;
    bool fVertical;
    RelativeCoord fMinCenter;
    RelativeCoord fMaxCenter;
    RelativeCoord fCenter;
    CCoord fMinSize;
    CCoord fMaxSize;
    CCoord fHalfSize;
    CCoord fZoomHandlesSize;
 
    // when the box is full it cannot be moved anymore
    bool isFull() const { return kEqualCoord(fMinCenter, fMaxCenter); }
 
    // start position
    RelativeCoord getStart() const { return fCenter - fHalfSize; }
    RelativeCoord getMinStart() const { return fMinCenter - fHalfSize; }
    bool isMinStart() const { return kEqualCoord(fCenter, fMinCenter); }
 
    // end position
    RelativeCoord getEnd() const { return fCenter + fHalfSize; }
    RelativeCoord getMaxEnd() const { return fMaxCenter + fHalfSize; }
    bool isMaxEnd() const { return kEqualCoord(fCenter, fMaxCenter); }
 
    // the short dimension of the box
    CCoord getShortDimension() const { return fVertical ? fViewSize.getWidth() : fViewSize.getHeight(); }
 
    // the long dimension of the box
    CCoord getLongDimension() const { return fHalfSize * 2.0; }
 
    // the relative view containing the box (which is the original view minus the margin)
    RelativeView getRelativeView() const { return RelativeView{fViewSize}; }
 
    // compute position from offsetPercent
    RelativeCoord computeCenter(double iOffsetPercent) const
    {
      return Utils::mapValueDP(iOffsetPercent, 0.0, 1.0, fMinCenter, fMaxCenter);
    }
 
    // compute the offsetPercent from the position
    double computeOffsetPercent() const
    {
      if(isMinStart()) return 0.0;
      if(isMaxEnd()) return 1.0;
      return Utils::mapValueDP(fCenter, fMinCenter, fMaxCenter, 0.0, 1.0);
    }
 
    // compute size from zoomPercent
    CCoord computeLongDimension(double iZoomPercent) const
    {
      return Utils::mapValueDP(iZoomPercent, 1.0, 0.0, fMinSize, fMaxSize);
    }
 
    // compute zoomPercent from size
    double computeZoomPercent() const
    {
      auto longDimension = getLongDimension();
      if(kEqualCoord(longDimension, fMinSize)) return 1.0;
      if(kEqualCoord(longDimension, fMaxSize)) return 0.0;
      return Utils::mapValueDP(longDimension, fMinSize, fMaxSize, 1.0, 0.0);
    }
 
    // move the box by iDelta (can be positive or negative)
    void move(CCoord iDelta)
    {
      fCenter = Utils::clamp(fCenter + iDelta, fMinCenter, fMaxCenter);
    }
 
    // move the box to a specific location
    void moveTo(RelativeCoord const &iNewCenter)
    {
      fCenter = Utils::clamp(iNewCenter, fMinCenter, fMaxCenter);
    }

    bool stretch(CCoord iDelta, DragType iDragType);
 
    // zoom to max and move to specific location
    void maxZoom(RelativeCoord const &iNewCenter);
 
    // zoom to minimum (since the box is full, there is no specific location)
    void minZoom();
  };
 
protected:
  // drawStartHandle - can be overridden to draw something different but should fit in fStartHandleRect
  virtual void drawStartHandle(CDrawContext *iContext);
 
  // drawEndHandle - can be overridden to draw something different but should fit in fEndHandleRect
  virtual void drawEndHandle(CDrawContext *iContext);
 
  // drawScrollbar - can be overridden to draw something different but should fit in fScrollbarRect
  virtual void drawScrollbar(CDrawContext *iContext);
 
  // needsRecomputing when something changes that requires recomputing the 3 AbsoluteRect
  void needsRecomputing() { fNeedsRecomputing = true; markDirty(); }
 
  // recompute the 3 AbsoluteRect
  void recompute();
 
  // computeZoomBox
  ZoomBox computeZoomBox() const;
 
  // returns the size of just the scrollbar (excluding handles and gutter)
  CCoord getScrollbarSize() const;
 
  // compute the mouse position relative to the scrollbar
  RelativeCoord computeMousePosition(CPoint const &where) const;
 
protected:
  // set to true when the 3 AbsoluteRect need to be recomputed
  bool fNeedsRecomputing{true};
  ZoomBox fZoomBox{};
 
  // the 3 Rect representing the position and size of the 3 pieces of the rendering
  AbsoluteRect fStartHandleRect;
  AbsoluteRect fEndHandleRect;
  AbsoluteRect fScrollbarRect;
 
  // look and feel
  EOrientation fOrientation{EOrientation::kHorizontal};
  Margin fMargin{};
  CColor fScrollbarColor{kWhiteCColor};
  CCoord fScrollbarMinSize{-1}; // -1 means it will be computed
  CCoord fScrollbarGutterSpacing{1};
 
  CColor fZoomHandlesColor{kWhiteCColor};
  CCoord fZoomHandlesSize{-1}; // -1 means it will be computed, 0 means no show
 
  // how much to slow down (if less than 1) or accelerate (if more than 1) when shift is held when dragging
  Range fShiftDragFactor{1.0};
  bool fEnableZoomDoubleClick{true};
 
  // offsetPercent tag/param/value + editor and editor value ("value" is used when no param)
  ParamID fOffsetPercentTag{UNDEFINED_PARAM_ID};
  GUIOptionalParam<ParamValue> fOffsetPercentParam{};
  GUIOptionalParamEditor<ParamValue> fOffsetPercentEditor{};
 
  // zoomPercent tag/param/value + editor and editor value ("value" is used when no param)
  ParamID fZoomPercentTag{UNDEFINED_PARAM_ID};
  GUIOptionalParam<ParamValue> fZoomPercentParam{};
  GUIOptionalParamEditor<ParamValue> fZoomPercentEditor{};
 
  // used when dragging
  RelativeCoord fDragGesture{-1.0};
  DragType fDragType{DragType::kNone};
 
public:
  class Creator : public CustomViewCreator<ScrollbarView, CustomView>
  {
  public:
    explicit Creator(char const *iViewName = nullptr, char const *iDisplayName = nullptr) :
      CustomViewCreator(iViewName, iDisplayName)
    {
      registerListAttribute<EOrientation>("orientation", &ScrollbarView::getOrientation, &ScrollbarView::setOrientation,
                                          {
                                            { "vertical", EOrientation::kVertical },
                                            { "horizontal", EOrientation::kHorizontal }
                                          });
      registerTagAttribute("offset-percent-tag", &ScrollbarView::getOffsetPercentTag, &ScrollbarView::setOffsetPercentTag);
      registerTagAttribute("zoom-percent-tag", &ScrollbarView::getZoomPercentTag, &ScrollbarView::setZoomPercentTag);
      registerMarginAttribute("margin", &ScrollbarView::getMargin, &ScrollbarView::setMargin);
      registerColorAttribute("scrollbar-color", &ScrollbarView::getScrollbarColor, &ScrollbarView::setScrollbarColor);
      registerDoubleAttribute("scrollbar-min-size", &ScrollbarView::getScrollbarMinSize, &ScrollbarView::setScrollbarMinSize);
      registerDoubleAttribute("scrollbar-gutter-spacing", &ScrollbarView::getScrollbarGutterSpacing, &ScrollbarView::setScrollbarGutterSpacing);
      registerColorAttribute("zoom-handles-color", &ScrollbarView::getZoomHandlesColor, &ScrollbarView::setZoomHandlesColor);
      registerDoubleAttribute("zoom-handles-size", &ScrollbarView::getZoomHandlesSize, &ScrollbarView::setZoomHandlesSize);
      registerRangeAttribute("shift-drag-factor", &ScrollbarView::getShiftDragFactor, &ScrollbarView::setShiftDragFactor);
      registerBooleanAttribute("enable-zoom-double-click", &ScrollbarView::getEnableZoomDoubleClick, &ScrollbarView::setEnableZoomDoubleClick);
    }
  };
};
 
}