IControls.h

Go to the documentation of this file.

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

 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers.

 See LICENSE.txt for  more info.

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

#pragma once

#include "IControl.h"
#include "IColorPickerControl.h"
#include "IVKeyboardControl.h"
#include "IVMeterControl.h"
#include "IVScopeControl.h"
#include "IVMultiSliderControl.h"
#include "IRTTextControl.h"
#include "IVDisplayControl.h"
#include "ILEDControl.h"
#include "IPopupMenuControl.h"

BEGIN_IPLUG_NAMESPACE
BEGIN_IGRAPHICS_NAMESPACE

#pragma mark - Vector Controls

class IVLabelControl : public ITextControl
                     , public IVectorBase
{
public:
  IVLabelControl(const IRECT& bounds, const char* label, const IVStyle& style = DEFAULT_STYLE.WithDrawFrame(false).WithColor(kSH, COLOR_BLACK).WithShadowOffset(1).WithValueText(DEFAULT_VALUE_TEXT.WithSize(20.f).WithFGColor(COLOR_WHITE)));
  void Draw(IGraphics& g) override;
};

class IVButtonControl : public IButtonControlBase
                      , public IVectorBase
{
public:
  IVButtonControl(const IRECT& bounds, IActionFunction aF = SplashClickActionFunc, const char* label = "", const IVStyle& style = DEFAULT_STYLE, bool labelInButton = true, bool valueInButton = true, EVShape shape = EVShape::Rectangle);

  void Draw(IGraphics& g) override;
  virtual void DrawWidget(IGraphics& g) override;
  bool IsHit(float x, float y) const override;
  void OnResize() override;
};

class IVSwitchControl : public ISwitchControlBase
                      , public IVectorBase
{
public:
  IVSwitchControl(const IRECT& bounds, int paramIdx = kNoParameter, const char* label = "", const IVStyle& style = DEFAULT_STYLE, bool valueInButton = true);
  
  IVSwitchControl(const IRECT& bounds, IActionFunction aF = SplashClickActionFunc, const char* label = "", const IVStyle& style = DEFAULT_STYLE, int numStates = 2, bool valueInButton = true);

  void Draw(IGraphics& g) override;
  virtual void DrawWidget(IGraphics& g) override;
  void OnMouseOut() override { ISwitchControlBase::OnMouseOut(); SetDirty(false); }
  bool IsHit(float x, float y) const override;
  void SetDirty(bool push, int valIdx = kNoValIdx) override;
  void OnResize() override;
  void OnInit() override;
};

class IVToggleControl : public IVSwitchControl
{
public:
  IVToggleControl(const IRECT& bounds, int paramIdx = kNoParameter, const char* label = "", const IVStyle& style = DEFAULT_STYLE, const char* offText = "OFF", const char* onText = "ON");
  
  IVToggleControl(const IRECT& bounds, IActionFunction aF = SplashClickActionFunc, const char* label = "", const IVStyle& style = DEFAULT_STYLE, const char* offText = "OFF", const char* onText = "ON", bool initialState = false);
  
  void DrawValue(IGraphics& g, bool mouseOver) override;
  void DrawWidget(IGraphics& g) override;
protected:
  WDL_String mOffText;
  WDL_String mOnText;
};

class IVSlideSwitchControl : public IVSwitchControl
{
public:
  IVSlideSwitchControl(const IRECT& bounds, int paramIdx = kNoParameter, const char* label = "", const IVStyle& style = DEFAULT_STYLE, bool valueInButton = false, EDirection direction = EDirection::Horizontal);
  
  IVSlideSwitchControl(const IRECT& bounds, IActionFunction aF = EmptyClickActionFunc, const char* label = "", const IVStyle& style = DEFAULT_STYLE, bool valueInButton = false, EDirection direction = EDirection::Horizontal, int numStates = 2, int initialState = 0);
  
  void Draw(IGraphics& g) override;
  void DrawWidget(IGraphics& g) override;
  virtual void DrawTrack(IGraphics& g, const IRECT& filledArea);

  void OnResize() override;
  void OnEndAnimation() override;
  void SetDirty(bool push, int valIdx = kNoValIdx) override;
protected:
  void UpdateRects();

  IRECT mStartRect, mEndRect;
  IRECT mHandleBounds;
  EDirection mDirection;
};

class IVTabSwitchControl : public ISwitchControlBase
                         , public IVectorBase
{
public:
  enum class ETabSegment { Start, Mid, End };

  IVTabSwitchControl(const IRECT& bounds, int paramIdx = kNoParameter, const std::initializer_list<const char*>& options = {}, const char* label = "", const IVStyle & style = DEFAULT_STYLE, EVShape shape = EVShape::Rectangle, EDirection direction = EDirection::Horizontal);

  IVTabSwitchControl(const IRECT& bounds, IActionFunction aF, const std::initializer_list<const char*>& options, const char* label = "", const IVStyle& style = DEFAULT_STYLE, EVShape shape = EVShape::Rectangle, EDirection direction = EDirection::Horizontal);
  
  virtual ~IVTabSwitchControl() { mTabLabels.Empty(true); }
  void Draw(IGraphics& g) override;
  void OnInit() override;

  virtual void DrawWidget(IGraphics& g) override;
  virtual void DrawButton(IGraphics& g, const IRECT& bounds, bool pressed, bool mouseOver, ETabSegment segment, bool disabled);
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnMouseOver(float x, float y, const IMouseMod& mod) override;
  void OnMouseOut() override { mMouseOverButton = -1; ISwitchControlBase::OnMouseOut(); SetDirty(false); }
  void OnResize() override;
  virtual bool IsHit(float x, float y) const override;
  
  const char* GetSelectedLabelStr() const;
protected:
  
  virtual int GetButtonForPoint(float x, float y) const;

  int mMouseOverButton = -1;
  WDL_TypedBuf<IRECT> mButtons;
  WDL_PtrList<WDL_String> mTabLabels;
  EDirection mDirection;
};

class IVRadioButtonControl : public IVTabSwitchControl
{
public:
  IVRadioButtonControl(const IRECT& bounds, int paramIdx = kNoParameter, const std::initializer_list<const char*>& options = {}, const char* label = "", const IVStyle& style = DEFAULT_STYLE, EVShape shape = EVShape::Ellipse, EDirection direction = EDirection::Vertical, float buttonSize = 10.f);

  IVRadioButtonControl(const IRECT& bounds, IActionFunction aF, const std::initializer_list<const char*>& options, const char* label = "", const IVStyle& style = DEFAULT_STYLE, EVShape shape = EVShape::Ellipse, EDirection direction = EDirection::Vertical, float buttonSize = 10.f);
  
  virtual void DrawWidget(IGraphics& g) override;
protected:
  int GetButtonForPoint(float x, float y) const override;

  float mButtonSize;
  float mButtonAreaWidth;
  bool mOnlyButtonsRespondToMouse = false;
};

class IVKnobControl : public IKnobControlBase
                    , public IVectorBase
{
public:
  IVKnobControl(const IRECT& bounds, int paramIdx,
                const char* label = "",
                const IVStyle& style = DEFAULT_STYLE,
                bool valueIsEditable = false, bool valueInWidget = false,
                float a1 = -135.f, float a2 = 135.f, float aAnchor = -135.f,
                EDirection direction = EDirection::Vertical, double gearing = DEFAULT_GEARING, float trackSize = 2.f);

  IVKnobControl(const IRECT& bounds, IActionFunction aF,
                const char* label = "",
                const IVStyle& style = DEFAULT_STYLE,
                bool valueIsEditable = false, bool valueInWidget = false,
                float a1 = -135.f, float a2 = 135.f, float aAnchor = -135.f,
                EDirection direction = EDirection::Vertical, double gearing = DEFAULT_GEARING, float trackSize = 2.f);

  virtual ~IVKnobControl() {}

  void Draw(IGraphics& g) override;
  virtual void DrawWidget(IGraphics& g) override;
  virtual void DrawIndicatorTrack(IGraphics& g, float angle, float cx, float cy, float radius);
  virtual void DrawPointer(IGraphics& g, float angle, float cx, float cy, float radius);

  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnMouseDblClick(float x, float y, const IMouseMod& mod) override;
  void OnMouseUp(float x, float y, const IMouseMod& mod) override;
  void OnMouseOver(float x, float y, const IMouseMod& mod) override;
  void OnMouseOut() override { mValueMouseOver = false; IKnobControlBase::OnMouseOut(); }

  void OnResize() override;
  bool IsHit(float x, float y) const override;
  void SetDirty(bool push, int valIdx = kNoValIdx) override;
  void OnInit() override;

  void SetInnerPointerFrac(float frac) { mInnerPointerFrac = frac; }
  void SetOuterPointerFrac(float frac) { mOuterPointerFrac = frac; }
  void SetPointerThickness(float thickness) { mPointerThickness = thickness; }

protected:
  virtual IRECT GetKnobDragBounds() override;

  float mTrackToHandleDistance = 4.f;
  float mInnerPointerFrac = 0.1f;
  float mOuterPointerFrac = 1.f;
  float mPointerThickness = 2.5f;
  float mAngle1, mAngle2;
  float mAnchorAngle; // for bipolar arc
  bool mValueMouseOver = false;
};

class IVSliderControl : public ISliderControlBase
                      , public IVectorBase
{
public:
  IVSliderControl(const IRECT& bounds, int paramIdx = kNoParameter, const char* label = "", const IVStyle& style = DEFAULT_STYLE, bool valueIsEditable = false, EDirection dir = EDirection::Vertical, double gearing = DEFAULT_GEARING, float handleSize = 8.f, float trackSize = 2.f, bool handleInsideTrack = false);
  
  IVSliderControl(const IRECT& bounds, IActionFunction aF, const char* label = "", const IVStyle& style = DEFAULT_STYLE, bool valueIsEditable = false, EDirection dir = EDirection::Vertical, double gearing = DEFAULT_GEARING, float handleSize = 8.f, float trackSize = 2.f, bool handleInsideTrack = false);

  virtual ~IVSliderControl() {}
  void Draw(IGraphics& g) override;
  virtual void DrawWidget(IGraphics& g) override;
  virtual void DrawTrack(IGraphics& g, const IRECT& filledArea);
  virtual void DrawHandle(IGraphics& g, const IRECT& bounds);

  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnMouseDblClick(float x, float y, const IMouseMod& mod) override;
  void OnMouseUp(float x, float y, const IMouseMod& mod) override;
  void OnMouseOver(float x, float y, const IMouseMod& mod) override;
  void OnMouseOut() override { mValueMouseOver = false; ISliderControlBase::OnMouseOut(); }
  bool IsHit(float x, float y) const override;
  void OnResize() override;
  void SetDirty(bool push, int valIdx = kNoValIdx) override;
  void OnInit() override;

protected:
  bool mHandleInsideTrack = false;
  bool mValueMouseOver = false;
};

class IVRangeSliderControl : public IVTrackControlBase
{
public:
  IVRangeSliderControl(const IRECT& bounds, const std::initializer_list<int>& params, const char* label = "", const IVStyle& style = DEFAULT_STYLE, EDirection dir = EDirection::Vertical, bool onlyHandle = false, float handleSize = 8.f, float trackSize = 2.f);

  void Draw(IGraphics& g) override;
  void DrawTrack(IGraphics& g, const IRECT& r, int chIdx) override;
  void DrawWidget(IGraphics& g) override;
  void OnMouseOver(float x, float y, const IMouseMod& mod) override;
  void OnMouseOut() override { mMouseOverHandle = -1; IVTrackControlBase::OnMouseOut(); }
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnMouseUp(float x, float y, const IMouseMod& mod) override { mMouseIsDown = false; }
  void OnMouseDrag(float x, float y, float dX, float dY, const IMouseMod& mod) override;

protected:
  void MakeTrackRects(const IRECT& bounds) override;
  IRECT GetHandleBounds(int trackIdx);
  
  int mMouseOverHandle = -1;
  float mHandleSize;
  bool mMouseIsDown = false;
};

class IVXYPadControl : public IControl
                     , public IVectorBase
{
public:
  IVXYPadControl(const IRECT& bounds, const std::initializer_list<int>& params, const char* label = "", const IVStyle& style = DEFAULT_STYLE, float handleRadius = 10.f);

  void Draw(IGraphics& g) override;
  void DrawWidget(IGraphics& g) override;
  virtual void DrawHandle(IGraphics& g, const IRECT& trackBounds, const IRECT& handleBounds);
  virtual void DrawTrack(IGraphics& g);
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnMouseUp(float x, float y, const IMouseMod& mod) override;
  void OnMouseDrag(float x, float y, float dX, float dY, const IMouseMod& mod) override;
  void OnResize() override;
protected:
  float mHandleRadius;
  bool mMouseDown = false;
  bool mTrackClipsHandle = true;
};

class IVPlotControl : public IControl
                    , public IVectorBase
{
public:
  using IPlotFunc = std::function<double(double)>;
    
  struct Plot {
    IColor color;
    IPlotFunc func;
  };
  
  IVPlotControl(const IRECT& bounds, const std::initializer_list<Plot>& funcs, int numPoints, const char* label = "", const IVStyle& style = DEFAULT_STYLE, float min = -1., float max = 1., bool useLayer = false);
  
  void Draw(IGraphics& g) override;
  void OnResize() override;
  
  void AddPlotFunc(const IColor& color, const IPlotFunc& func);
  
protected:
  ILayerPtr mLayer;
  std::vector<Plot> mPlots;
  float mMin;
  float mMax;
  bool mUseLayer = true;
  int mHorizontalDivisions = 10;
  int mVerticalDivisions = 10; // always + 2 when drawing
  
  std::vector<float> mPoints;
};

class IVGroupControl : public IControl
                     , public IVectorBase
{
public:
  IVGroupControl(const IRECT& bounds, const char* label = "", float labelOffset = 10.f, const IVStyle& style = DEFAULT_STYLE);
  
  IVGroupControl(const char* label, const char* groupName, float padL = 0.f, float padT = 0.f, float padR = 0.f, float padB = 0.f, const IVStyle& style = DEFAULT_STYLE);
  
  void Draw(IGraphics& g) override;
  void DrawWidget(IGraphics& g) override;
  void OnResize() override;
  void OnInit() override;
  
  void SetBoundsBasedOnGroup(const char* groupName, float padL, float padT, float padR, float padB);
protected:
  WDL_String mGroupName;
  float mPadL = 0.f;
  float mPadT = 0.f;
  float mPadR = 0.f;
  float mPadB = 0.f;
  float mLabelOffset = 10.f;
  float mLabelPadding = 10.f;
};

class IVPanelControl : public IControl
                     , public IVectorBase
{
public:
  IVPanelControl(const IRECT& bounds, const char* label = "", const IVStyle& style = DEFAULT_STYLE.WithColor(kFG, COLOR_TRANSLUCENT).WithEmboss(true))
  : IControl(bounds)
  , IVectorBase(style)
  {
    mIgnoreMouse = true;
    AttachIControl(this, label);
  }
  
  void Draw(IGraphics& g) override
  {
    DrawBackground(g, mRECT);
    DrawWidget(g);
    DrawLabel(g);
    DrawValue(g, mMouseIsOver);
  }
  
  void DrawWidget(IGraphics& g) override
  {
    DrawPressableRectangle(g, mWidgetBounds, false, false, false);
  }
  
  void OnResize() override
  {
    SetTargetRECT(MakeRects(mRECT));
  }
};

class IVColorSwatchControl : public IControl
                           , public IVectorBase
{
public:
  enum class ECellLayout { kGrid, kHorizontal, kVertical };
  
  using ColorChosenFunc = std::function<void(int, IColor)>;

  IVColorSwatchControl(const IRECT& bounds, const char* label = "", ColorChosenFunc func = nullptr, const IVStyle& spec = DEFAULT_STYLE, ECellLayout layout = ECellLayout::kGrid,
    const std::initializer_list<EVColor>& colorIDs = { kBG, kFG, kPR, kFR, kHL, kSH, kX1, kX2, kX3 },
    const std::initializer_list<const char*>& labelsForIDs = { kVColorStrs[kBG],kVColorStrs[kFG],kVColorStrs[kPR],kVColorStrs[kFR],kVColorStrs[kHL],kVColorStrs[kSH],kVColorStrs[kX1],kVColorStrs[kX2],kVColorStrs[kX3] });
  
  virtual ~IVColorSwatchControl() { mLabels.Empty(true); }
  
  void Draw(IGraphics& g) override;
  void OnMouseOver(float x, float y, const IMouseMod& mod) override;
  void OnMouseOut() override;
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnResize() override;

  void DrawWidget(IGraphics& g) override;

private:
  ColorChosenFunc mColorChosenFunc = nullptr;
  int mCellOver = -1;
  ECellLayout mLayout = ECellLayout::kVertical;
  WDL_TypedBuf<IRECT> mCellRects;
  WDL_PtrList<WDL_String> mLabels;
  std::vector<EVColor> mColorIdForCells;
};

#pragma mark - SVG Vector Controls

class ISVGKnobControl : public IKnobControlBase
{
public:
  ISVGKnobControl(const IRECT& bounds, const ISVG& svg, int paramIdx = kNoParameter);
  
  void Draw(IGraphics& g) override;
  void SetSVG(ISVG& svg);
  
private:
  ISVG mSVG;
  float mStartAngle = -135.f;
  float mEndAngle = 135.f;
};

class ISVGButtonControl : public IButtonControlBase
{
public:
  ISVGButtonControl(const IRECT& bounds, IActionFunction aF, const ISVG& offImage, const ISVG& onImage);

  void Draw(IGraphics& g) override;
  //void OnResize() override;

protected:
  ISVG mOffSVG;
  ISVG mOnSVG;
};

class ISVGSwitchControl : public ISwitchControlBase
{
public:
  ISVGSwitchControl(const IRECT& bounds, const std::initializer_list<ISVG>& svgs, int paramIdx = kNoParameter, IActionFunction aF = nullptr);

  void Draw(IGraphics& g) override;

protected:
  std::vector<ISVG> mSVGs;
};

class ISVGSliderControl : public ISliderControlBase
{
public:
  ISVGSliderControl(const IRECT& bounds, const ISVG& handleSvg, const ISVG& trackSVG, int paramIdx = kNoParameter, EDirection dir = EDirection::Vertical, double gearing = DEFAULT_GEARING);

  void Draw(IGraphics& g) override;
  void OnResize() override;

protected:
  IRECT GetHandleBounds(double value = -1.0) const;

  IRECT mTrackSVGBounds;
  IRECT mHandleBoundsAtMax;
  ISVG mHandleSVG;
  ISVG mTrackSVG;
};

#pragma mark - Bitmap Controls

class IBButtonControl : public IButtonControlBase
                      , public IBitmapBase
{
public:
  IBButtonControl(float x, float y, const IBitmap& bitmap, IActionFunction aF = DefaultClickActionFunc);

  IBButtonControl(const IRECT& bounds, const IBitmap& bitmap, IActionFunction aF = DefaultClickActionFunc);

  void Draw(IGraphics& g) override  { DrawBitmap(g); }
  void OnRescale() override { mBitmap = GetUI()->GetScaledBitmap(mBitmap); }
};

class IBSwitchControl : public ISwitchControlBase
                      , public IBitmapBase
{
public:
  IBSwitchControl(float x, float y, const IBitmap& bitmap, int paramIdx = kNoParameter);

  IBSwitchControl(const IRECT& bounds, const IBitmap& bitmap, int paramIdx = kNoParameter);
  
  virtual ~IBSwitchControl() {}
  void Draw(IGraphics& g) override { DrawBitmap(g); }
  void OnRescale() override { mBitmap = GetUI()->GetScaledBitmap(mBitmap); }
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
};

class IBKnobControl : public IKnobControlBase
                    , public IBitmapBase
{
public:
  IBKnobControl(float x, float y, const IBitmap& bitmap, int paramIdx, EDirection direction = EDirection::Vertical, double gearing = DEFAULT_GEARING)
  : IKnobControlBase(IRECT(x, y, bitmap), paramIdx, direction, gearing)
  , IBitmapBase(bitmap)  { AttachIControl(this); }

  IBKnobControl(const IRECT& bounds, const IBitmap& bitmap, int paramIdx, EDirection direction = EDirection::Vertical, double gearing = DEFAULT_GEARING)
  : IKnobControlBase(bounds.GetCentredInside(bitmap), paramIdx, direction, gearing)
  , IBitmapBase(bitmap)  { AttachIControl(this); }

  virtual ~IBKnobControl() {}
  void Draw(IGraphics& g) override { DrawBitmap(g); }
  void OnRescale() override { mBitmap = GetUI()->GetScaledBitmap(mBitmap); }
};

class IBKnobRotaterControl : public IBKnobControl
{
public:
  IBKnobRotaterControl(float x, float y, const IBitmap& bitmap, int paramIdx)
  : IBKnobControl(IRECT(x, y, bitmap), bitmap, paramIdx) {}

  IBKnobRotaterControl(const IRECT& bounds, const IBitmap& bitmap, int paramIdx)
  : IBKnobControl(bounds.GetCentredInside(bitmap), bitmap, paramIdx) {}

  virtual ~IBKnobRotaterControl() {}
  void Draw(IGraphics& g) override;
};

class IBSliderControl : public ISliderControlBase
                      , public IBitmapBase
{
public:
  IBSliderControl(float x, float y, float trackLength, const IBitmap& handleBitmap, const IBitmap& trackBitmap = IBitmap(), int paramIdx = kNoParameter, EDirection dir = EDirection::Vertical, double gearing = DEFAULT_GEARING);

  IBSliderControl(const IRECT& bounds, const IBitmap& handleBitmap, const IBitmap& trackBitmap = IBitmap(), int paramIdx = kNoParameter, EDirection dir = EDirection::Vertical, double gearing = DEFAULT_GEARING);

  virtual ~IBSliderControl() {}

  void Draw(IGraphics& g) override;
  void OnRescale() override { mBitmap = GetUI()->GetScaledBitmap(mBitmap); }
  void OnResize() override;
  
  IRECT GetHandleBounds(double value = -1.0) const;

protected:
  IBitmap mTrackBitmap;
};

class IBTextControl : public ITextControl
                    , public IBitmapBase
{
public:
  IBTextControl(const IRECT& bounds, const IBitmap& bitmap, const IText& text = DEFAULT_TEXT, const char* str = "", int charWidth = 6, int charHeight = 12, int charOffset = 0, bool multiLine = false, bool vCenter = true, EBlend blend = EBlend::Default);
  virtual ~IBTextControl() {}

  void Draw(IGraphics& g) override;
  void OnRescale() override { mBitmap = GetUI()->GetScaledBitmap(mBitmap); }

protected:
  int mCharWidth, mCharHeight, mCharOffset;
  bool mMultiLine;
  bool mVCentre;
};

END_IGRAPHICS_NAMESPACE
END_IPLUG_NAMESPACE

#include "IVPresetManagerControl.h"
#include "IVNumberBoxControl.h"