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 "ILEDControl.h"
#include "IPopupMenuControl.h"
#include "IRTTextControl.h"
#include "IVKeyboardControl.h"
#include "IVMeterControl.h"
#include "IVScopeControl.h"
#include "IVMultiSliderControl.h"
#include "IVDisplayControl.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;
  virtual void DrawWidget(IGraphics& g) override;
  virtual void DrawHandle(IGraphics& g, const IRECT& filledArea);
  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::vector<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::vector<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);
  virtual void DrawButtonText(IGraphics& g, const IRECT& bounds, bool pressed, bool mouseOver, ETabSegment segment, bool disabled, const char* textStr);
 
  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 IVMenuButtonControl : public IContainerBase
                          , public IVectorBase
{
public:
  IVMenuButtonControl(const IRECT& bounds, int paramIdx, const char* label = "", const IVStyle& style = DEFAULT_STYLE, EVShape shape = EVShape::Rectangle);
  
  void OnPopupMenuSelection(IPopupMenu* pSelectedMenu, int valIdx) override;
  void SetValueFromUserInput(double value, int valIdx) override;
 
  void SetValueFromDelegate(double value, int valIdx = 0) override;
  void SetStyle(const IVStyle& style) override;
 
private:
  IVButtonControl* mButtonControl = nullptr;
};
 
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; }
 
  float GetRadius() const;
  IRECT GetTrackBounds() const;
  
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, float handleXOffset = 0.f, float handleYOffset = 0.f);
  
  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, float handleXOffset = 0.f, float handleYOffset = 0.f);
 
  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;
  
  IRECT GetTrackBounds() const
  {
    auto offset = -mHandleSize + (mStyle.frameThickness / 2.0f);
    return mWidgetBounds.GetPadded(mDirection == EDirection::Horizontal ? offset : 0,
                                   mDirection == EDirection::Vertical ? offset : 0,
                                   mDirection == EDirection::Horizontal ? offset : 0,
                                   mDirection == EDirection::Vertical ? offset : 0);
  }
 
protected:
  bool mHandleInsideTrack = false;
  bool mValueMouseOver = false;
  float mHandleXOffset = 0.f;
  float mHandleYOffset = 0.f;
};
 
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, bool trackClipsHandle = true, bool drawCross = true);
 
  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;
  bool mDrawCross = 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 IContainerBase
                     , public IVectorBase
{
public:
  IVGroupControl(const IRECT& bounds, const char* label = "", float labelOffset = 10.f, const IVStyle& style = DEFAULT_STYLE, IContainerBase::AttachFunc attachFunc = nullptr, IContainerBase::ResizeFunc resizeFunc = nullptr);
  
  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 IContainerBase
                     , public IVectorBase
{
public:
  IVPanelControl(const IRECT& bounds, const char* label = "", const IVStyle& style = DEFAULT_STYLE.WithColor(kFG, COLOR_TRANSLUCENT).WithEmboss(true))
  : IContainerBase(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 OnAttached() override
  {
    if (mAttachFunc)
      mAttachFunc(this, mWidgetBounds);
  }
  
  void OnResize() override
  {
    SetTargetRECT(MakeRects(mRECT));
 
    if (mResizeFunc && mChildren.GetSize())
      mResizeFunc(this, mWidgetBounds);
  }
};
 
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);
  
  ISVGButtonControl(const IRECT& bounds, IActionFunction aF, const ISVG& image, const std::array<IColor, 4> colors = {COLOR_BLACK, COLOR_WHITE, COLOR_DARK_GRAY, COLOR_LIGHT_GRAY}, EColorReplacement colorReplacement = EColorReplacement::Fill);
 
  void Draw(IGraphics& g) override;
 
protected:
  ISVG mOffSVG;
  ISVG mOnSVG;
  std::array<IColor, 4> mColors;
  EColorReplacement mColorReplacement = EColorReplacement::None;
};
 
class ISVGToggleControl : public ISwitchControlBase
{
public:
  ISVGToggleControl(const IRECT& bounds, IActionFunction aF, const ISVG& offImage, const ISVG& onImage);
 
  ISVGToggleControl(const IRECT& bounds, int paramIdx, const ISVG& offImage, const ISVG& onImage);
  
  ISVGToggleControl(const IRECT& bounds, IActionFunction aF, const ISVG& image, const std::array<IColor, 4> colors = {COLOR_BLACK, COLOR_WHITE, COLOR_DARK_GRAY, COLOR_LIGHT_GRAY}, EColorReplacement colorReplacement = EColorReplacement::Fill);
 
  ISVGToggleControl(const IRECT& bounds, int paramIdx, const ISVG& image, const std::array<IColor, 4> colors = {COLOR_BLACK, COLOR_WHITE, COLOR_DARK_GRAY, COLOR_LIGHT_GRAY}, EColorReplacement colorReplacement = EColorReplacement::Fill);
 
  void Draw(IGraphics& g) override;
 
protected:
  ISVG mOffSVG;
  ISVG mOnSVG;
  std::array<IColor, 4> mColors;
  EColorReplacement mColorReplacement = EColorReplacement::None;
};
 
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;
};
 
class IBMeterControl : public IBitmapControl
{
public:
  enum class EResponse {
    Linear,
    Log,
  };
  
  IBMeterControl(float x, float y, const IBitmap& bitmap, EResponse response = EResponse::Log, float lowRangeDB = -72.f, float highRangeDB = 12.f)
  : IBitmapControl(x, y, bitmap)
  , mResponse(response)
  , mLowRangeDB(lowRangeDB)
  , mHighRangeDB(highRangeDB)
  {}
  
  IBMeterControl(const IRECT& bounds, const IBitmap& bitmap, EResponse response = EResponse::Log, float lowRangeDB = -72.f, float highRangeDB = 12.f)
  : IBitmapControl(bounds, bitmap)
  , mResponse(response)
  , mLowRangeDB(lowRangeDB)
  , mHighRangeDB(highRangeDB)
  {}
  
  virtual ~IBMeterControl() {}
  void Draw(IGraphics& g) override { DrawBitmap(g); }
  void OnRescale() override { mBitmap = GetUI()->GetScaledBitmap(mBitmap); }
  void OnMsgFromDelegate(int msgTag, int dataSize, const void* pData) override;
  
protected:
  float mHighRangeDB;
  float mLowRangeDB;
  EResponse mResponse = EResponse::Linear;
};
 
END_IGRAPHICS_NAMESPACE
END_IPLUG_NAMESPACE
 
// These meta controls depend on the other controls
#include "IAboutBoxControl.h"
#include "IVPresetManagerControls.h"
#include "IVNumberBoxControl.h"
#include "IVTabbedPagesControl.h"