IControl.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 <cstring>
#include <cstdlib>
#include <vector>
#include <unordered_map>
 
#if defined VST3_API || defined VST3C_API
#undef stricmp
#undef strnicmp
#include "pluginterfaces/vst/ivstcontextmenu.h"
#include "base/source/fobject.h"
#endif
 
#include "IPlugPlatform.h"
 
#include "wdlstring.h"
#include "ptrlist.h"
 
#include "IGraphics.h"
 
BEGIN_IPLUG_NAMESPACE
BEGIN_IGRAPHICS_NAMESPACE
 
class IContainerBase;
 
class IControl
#if defined VST3_API || defined VST3C_API
: public Steinberg::Vst::IContextMenuTarget
, public Steinberg::FObject
#endif
{
public:
  IControl(const IRECT& bounds, int paramIdx = kNoParameter, IActionFunction actionFunc = nullptr);
  
  IControl(const IRECT& bounds, const std::initializer_list<int>& params, IActionFunction actionFunc = nullptr);
  
  IControl(const IRECT& bounds, IActionFunction actionFunc);
  
  IControl(const IControl&) = delete;
  void operator=(const IControl&) = delete;
  
  virtual ~IControl() {}
 
  virtual void OnMouseDown(float x, float y, const IMouseMod& mod);
 
  virtual void OnMouseUp(float x, float y, const IMouseMod& mod) {}
 
  virtual void OnMouseDrag(float x, float y, float dX, float dY, const IMouseMod& mod) {}
   
  virtual void OnMouseDblClick(float x, float y, const IMouseMod& mod);
 
  virtual void OnMouseWheel(float x, float y, const IMouseMod& mod, float d) {};
 
  virtual bool OnKeyDown(float x, float y, const IKeyPress& key) { return false; }
 
  virtual bool OnKeyUp(float x, float y, const IKeyPress& key) { return false; }
  
  virtual void OnMouseOver(float x, float y, const IMouseMod& mod);
 
  virtual void OnMouseOut();
  
  virtual void OnTouchCancelled(float x, float y, const IMouseMod& mod) {}
 
  virtual void OnDrop(const char* str) {};
 
  virtual void OnDropMultiple(const std::vector<const char*>& paths) { OnDrop(paths[0]); }
 
  virtual void OnRescale() {}
 
  virtual void OnResize() {}
  
  virtual void OnInit() {}
  
  virtual void OnAttached() {}
  
  virtual void OnMsgFromDelegate(int msgTag, int dataSize, const void* pData) {};
  
  virtual void OnMidi(const IMidiMsg& msg) {};
 
  virtual bool OnGesture(const IGestureInfo& info);
  
  virtual void CreateContextMenu(IPopupMenu& contextMenu) {}
  
  virtual void OnPopupMenuSelection(IPopupMenu* pSelectedMenu, int valIdx);
 
  virtual void OnDeleteFromPopupMenu(IPopupMenu* pMenu, int itemIdx) {}
    
  virtual void OnTextEntryCompletion(const char* str, int valIdx) {}
 
  virtual void OnContextSelection(int itemSelected) {}
 
  virtual void Draw(IGraphics& g) = 0;
 
  virtual void DrawPTHighlight(IGraphics& g);
 
  void PromptUserInput(int valIdx = 0);
  
  void PromptUserInput(const IRECT& bounds, int valIdx = 0);
  
  inline IControl* SetActionFunction(IActionFunction actionFunc) { mActionFunc = actionFunc; return this; }
 
  inline IControl* SetAnimationEndActionFunction(IActionFunction actionFunc) { mAnimationEndActionFunc = actionFunc; return this; }
  
  inline IControl* SetTooltip(const char* str) { mTooltip.Set(str); return this; }
  
  inline const char* GetTooltip() const { return mTooltip.Get(); }
 
  int GetParamIdx(int valIdx = 0) const;
  
  virtual void SetParamIdx(int paramIdx, int valIdx = 0);
 
  int LinkedToParam(int paramIdx) const;
  
  int NVals() const { return (int) mVals.size(); }
 
  virtual int GetValIdxForPos(float x, float y) const { return mVals.size() == 1 ? 0 : kNoValIdx; }
  
  const IParam* GetParam(int valIdx = 0) const;
  
  virtual void SetValueFromDelegate(double value, int valIdx = 0);
  
  virtual void SetValueFromUserInput(double value, int valIdx = 0);
    
  virtual void SetValueToDefault(int valIdx = kNoValIdx);
  
  virtual void SetValue(double value, int valIdx = 0);
  
  double GetValue(int valIdx = 0) const;
  
  void SetGroup(const char* groupName) { mGroup.Set(groupName); }
  
  const char* GetGroup() const { return mGroup.Get(); }
 
  const IText& GetText() const { return mText; }
 
  virtual void SetText(const IText& txt) { mText = txt; }
 
  void SetBlend(const IBlend& blend) { mBlend = blend; }
 
  IBlend GetBlend() const { return mBlend; }
 
  int GetTextEntryLength() const { return mTextEntryLength; }
 
  void SetTextEntryLength(int len) { mTextEntryLength = len;  }
  
  const IRECT& GetRECT() const { return mRECT; }
 
  void SetRECT(const IRECT& bounds) { mRECT = bounds; mMouseIsOver = false; OnResize(); }
  
  const IRECT& GetTargetRECT() const { return mTargetRECT; } // The mouse target area (default = draw area).
 
  void SetTargetRECT(const IRECT& bounds) { mTargetRECT = bounds; mMouseIsOver = false; }
  
  void SetTargetAndDrawRECTs(const IRECT& bounds) { mRECT = mTargetRECT = bounds; mMouseIsOver = false; OnResize(); }
 
  virtual void SetPosition(float x, float y);
 
  virtual void SetSize(float w, float h);
 
  void SetPTParameterHighlight(bool isHighlighted, int color);
  
  bool GetMouseDblAsSingleClick() const { return mDblAsSingleClick; }
 
  virtual void Hide(bool hide);
  
  bool IsHidden() const { return mHide; }
 
  virtual void SetDisabled(bool disable);
  
  bool IsDisabled() const { return mDisabled; }
 
  void SetMouseOverWhenDisabled(bool allow) { mMouseOverWhenDisabled = allow; }
 
  void SetMouseEventsWhenDisabled(bool allow) { mMouseEventsWhenDisabled = allow; }
 
  bool GetMouseOverWhenDisabled() const { return mMouseOverWhenDisabled; }
 
  bool GetMouseEventsWhenDisabled() const { return mMouseEventsWhenDisabled; }
  
  bool GetIgnoreMouse() const { return mIgnoreMouse; }
  
  virtual void SetIgnoreMouse(bool ignore) { mIgnoreMouse = ignore; }
  
  bool GetPromptShowsParamLabel() const { return mPromptShowsParamLabel; }
 
  void SetPromptShowsParamLabel(bool enable) { mPromptShowsParamLabel = enable; }
  
  virtual bool IsHit(float x, float y) const { return mTargetRECT.Contains(x, y); }
 
  virtual void SetDirty(bool triggerAction = true, int valIdx = kNoValIdx);
 
  /* Set the control clean, i.e. Called by IGraphics draw loop after control has been drawn */
  virtual void SetClean() { mDirty = false; }
 
  /* Called at each display refresh by the IGraphics draw loop, triggers the control's AnimationFunc if it is set */
  void Animate();
 
  virtual bool IsDirty();
 
  void DisablePrompt(bool disable) { mDisablePrompt = disable; }
 
  virtual void OnGUIIdle() {}
  
  int GetTag() const { return GetUI()->GetControlTag(this); }
  
  void SetWantsMidi(bool enable = true) { mWantsMidi = enable; }
 
  bool GetWantsMidi() const { return mWantsMidi; }
 
  void SetWantsMultiTouch(bool enable = true) { mWantsMultiTouch = enable; }
  
  bool GetWantsMultiTouch() const { return mWantsMultiTouch; }
  
  IControl* AttachGestureRecognizer(EGestureType type, IGestureFunc func);
  
  virtual bool GetWantsGestures() const { return mGestureFuncs.size() > 0 && !mAnimationFunc; }
  
  EGestureType GetLastGesture() const { return mLastGesture; }
  
  IGEditorDelegate* GetDelegate() { return mDelegate; }
  
  void SetDelegate(IGEditorDelegate& dlg)
  {
    mDelegate = &dlg;
    mGraphics = dlg.GetUI();
    OnInit();
    OnResize();
    OnRescale();
  }
  
  IContainerBase* GetParent() const { return mParent; }
  
  void SetParent(IContainerBase* pParent) { mParent = pParent; }
  
  IGraphics* GetUI() { return mGraphics; }
    
  const IGraphics* GetUI() const { return mGraphics; }
 
  bool GetMouseIsOver() const { return mMouseIsOver; }
  
  virtual void SnapToMouse(float x, float y, EDirection direction, const IRECT& bounds, int valIdx = -1, double minClip = 0., double maxClip = 1.);
 
  /* if you override this you must call the base implementation, to free mAnimationFunc */
  virtual void OnEndAnimation();
  
  void StartAnimation(int duration);
  
  void SetAnimation(IAnimationFunction func) { mAnimationFunc = func;}
  
  void SetAnimation(IAnimationFunction func, int duration) { mAnimationFunc = func; StartAnimation(duration); }
 
  IAnimationFunction GetAnimationFunction() { return mAnimationFunc; }
 
  IActionFunction GetActionFunction() { return mActionFunc; }
 
  double GetAnimationProgress() const;
  
  Milliseconds GetAnimationDuration() const { return mAnimationDuration; }
 
  template <class T>
  T* As() { return dynamic_cast<T*>(this); }
    
#if defined VST3_API || defined VST3C_API
  Steinberg::tresult PLUGIN_API executeMenuItem (Steinberg::int32 tag) override { OnContextSelection(tag); return Steinberg::kResultOk; }
#endif
  
#pragma mark - IControl Member variables
protected:
  
  template<typename T, typename... Args>
  void ForValIdx(int valIdx, T func, Args... args)
  {
    if (valIdx > kNoValIdx)
      func(valIdx, args...);
    else
    {
      const int nVals = NVals();
      for (int v = 0; v < nVals; v++)
        func(v, args...);
    }
  }
  
  IRECT mRECT;
  IRECT mTargetRECT;
  
  WDL_String mGroup;
  
  IText mText;
  IBlend mBlend;
  int mTextEntryLength = DEFAULT_TEXT_ENTRY_LEN;
  bool mDirty = true;
  bool mHide = false;
  bool mDisabled = false;
  bool mDisablePrompt = true;
  bool mDblAsSingleClick = false;
  bool mMouseOverWhenDisabled = false;
  bool mMouseEventsWhenDisabled = false;
  bool mIgnoreMouse = false;
  bool mWantsMidi = false;
  bool mWantsMultiTouch = false;
  bool mPromptShowsParamLabel = false;
  bool mMouseIsOver = false;
  WDL_String mTooltip;
 
  IColor mPTHighlightColor = COLOR_RED;
  bool mPTisHighlighted = false;
  
  void SetNVals(int nVals)
  {
    assert(nVals > 0);
    mVals.resize(nVals);
  }
 
#if defined VST3_API || defined VST3C_API
  OBJ_METHODS(IControl, FObject)
  DEFINE_INTERFACES
  DEF_INTERFACE (IContextMenuTarget)
  END_DEFINE_INTERFACES (FObject)
  REFCOUNT_METHODS(FObject)
#endif
  
private:
  IContainerBase* mParent = nullptr;
  IGEditorDelegate* mDelegate = nullptr;
  IGraphics* mGraphics = nullptr;
  IActionFunction mActionFunc = nullptr;
  IActionFunction mAnimationEndActionFunc = nullptr;
  IAnimationFunction mAnimationFunc = nullptr;
  TimePoint mAnimationStartTime;
  Milliseconds mAnimationDuration;
  std::vector<ParamTuple> mVals { {kNoParameter, 0.} };
  std::unordered_map<EGestureType, IGestureFunc> mGestureFuncs;
  EGestureType mLastGesture = EGestureType::Unknown;
};
 
#pragma mark - Base Controls
 
class IContainerBase : public IControl
{
public:
  using AttachFunc = std::function<void(IContainerBase* pContainer, const IRECT& bounds)>;
  using ResizeFunc = std::function<void(IContainerBase* pContainer, const IRECT& bounds)>;
  
  IContainerBase(const IRECT& bounds, int paramIdx = kNoParameter, IActionFunction actionFunc = nullptr)
  : IControl(bounds, paramIdx, actionFunc)
  {}
  
  IContainerBase(const IRECT& bounds, const std::initializer_list<int>& params, IActionFunction actionFunc = nullptr)
  : IControl(bounds, params, actionFunc)
  {}
  
  IContainerBase(const IRECT& bounds, IActionFunction actionFunc)
  : IControl(bounds, actionFunc)
  {}
  
  IContainerBase(const IRECT& bounds, AttachFunc attachFunc, ResizeFunc resizeFunc)
  : IControl(bounds)
  , mAttachFunc(attachFunc)
  , mResizeFunc(resizeFunc)
  {
    mIgnoreMouse = true;
  }
  
  void SetAttachFunc(AttachFunc attachFunc)
  {
    mAttachFunc = attachFunc;
  }
  
  void SetResizeFunc(ResizeFunc resizeFunc)
  {
    mResizeFunc = resizeFunc;
  }
  
  virtual void Draw(IGraphics& g) override
  {
    /* NO-OP */
  }
  
  virtual ~IContainerBase()
  {
    mChildren.Empty(false);
  }
  
  virtual void OnAttached() override
  {
    if (mAttachFunc)
      mAttachFunc(this, mRECT);
    
    OnResize();
  }
  
  virtual void OnResize() override
  {
    if (mResizeFunc && mChildren.GetSize())
      mResizeFunc(this, mRECT);
  }
  
  void SetDisabled(bool disable) override
  {
    ForAllChildrenFunc([disable](int childIdx, IControl* pChild) {
      pChild->SetDisabled(disable);
    });
 
    IControl::SetDisabled(disable);
  }
 
  void Hide(bool hide) override
  {
    ForAllChildrenFunc([hide](int childIdx, IControl* pChild) {
      pChild->Hide(hide);
    });
    
    IControl::Hide(hide);
  }
  
  IControl* AddChildControl(IControl* pControl, int ctrlTag = kNoTag, const char* group = "")
  {
    pControl->SetParent(this);
    return mChildren.Add(GetUI()->AttachControl(pControl, ctrlTag, group));
  }
  
  void RemoveChildControl(IControl* pControl)
  {
    pControl->SetParent(nullptr);
    mChildren.DeletePtr(pControl, false);
    GetUI()->RemoveControl(pControl);
  }
  
  IControl* GetChild(int idx)
  {
    return mChildren.Get(idx);
  }
  
  int NChildren() const { return mChildren.GetSize(); }
  
  void ForAllChildrenFunc(std::function<void(int childIdx, IControl* pControl)> func)
  {
    for (int i=0; i<mChildren.GetSize(); i++)
    {
      func(i, mChildren.Get(i));
    }
  }
  
protected:
  AttachFunc mAttachFunc = nullptr;
  ResizeFunc mResizeFunc = nullptr;
  WDL_PtrList<IControl> mChildren;
};
 
class IBitmapBase
{
public:
  IBitmapBase(const IBitmap& bitmap)
  : mBitmap(bitmap)
  {
  }
  
  virtual ~IBitmapBase() {}
  
  void AttachIControl(IControl* pControl) { mControl = pControl; }
  
  void DrawBitmap(IGraphics& g)
  {
    int i = 1;
 
    if (mBitmap.N() > 1)
    {
      i = 1 + int(0.5 + mControl->GetValue() * static_cast<double>(mBitmap.N() - 1));
      i = Clip(i, 1, mBitmap.N());
    }
    IBlend blend = mControl->GetBlend();
    g.DrawBitmap(mBitmap, mControl->GetRECT().GetCentredInside(IRECT(0, 0, mBitmap)), i, &blend);
  }
 
protected:
  IBitmap mBitmap;
  IControl* mControl = nullptr;
};
 
class IVectorBase
{
public:
  IVectorBase(const IVStyle& style, bool labelInWidget = false, bool valueInWidget = false)
  : mLabelInWidget(labelInWidget)
  , mValueInWidget(valueInWidget)
  {
    SetStyle(style);
  }
  
  virtual ~IVectorBase() {}
  
  void AttachIControl(IControl* pControl, const char* label)
  {
    mControl = pControl;
    mLabelStr.Set(label);
  }
  
  virtual void OnStyleChanged() { /* NO-OP */ }
 
  void SetColor(EVColor colorIdx, const IColor& color)
  {
    mStyle.colorSpec.mColors[static_cast<int>(colorIdx)] = color;
    mControl->SetDirty(false);
  }
 
  void SetColors(const IVColorSpec& spec)
  {
    mStyle.colorSpec = spec;
  }
 
  const IColor& GetColor(EVColor color) const
  {
    return mStyle.colorSpec.GetColor(color);
  }
  
  void SetLabelStr(const char* label) { mLabelStr.Set(label); mControl->SetDirty(false); OnStyleChanged(); }
  const char* GetLabelStr() const { return mLabelStr.Get(); }
  void SetValueStr(const char* value) { mValueStr.Set(value); mControl->SetDirty(false); OnStyleChanged(); }
  void SetWidgetFrac(float frac) { mStyle.widgetFrac = Clip(frac, 0.f, 1.f);  mControl->OnResize(); mControl->SetDirty(false); OnStyleChanged(); }
  void SetAngle(float angle) { mStyle.angle = Clip(angle, 0.f, 360.f);  mControl->SetDirty(false); OnStyleChanged(); }
  void SetShowLabel(bool show) { mStyle.showLabel = show;  mControl->OnResize(); mControl->SetDirty(false); OnStyleChanged(); }
  void SetShowValue(bool show) { mStyle.showValue = show;  mControl->OnResize(); mControl->SetDirty(false); OnStyleChanged(); }
  void SetRoundness(float roundness) { mStyle.roundness = Clip(roundness, 0.f, 1.f); mControl->SetDirty(false); OnStyleChanged(); }
  void SetDrawFrame(bool draw) { mStyle.drawFrame = draw; mControl->SetDirty(false); OnStyleChanged(); }
  void SetDrawShadows(bool draw) { mStyle.drawShadows = draw; mControl->SetDirty(false); OnStyleChanged(); }
  void SetEmboss(bool draw) { mStyle.emboss = draw; mControl->SetDirty(false); OnStyleChanged(); }
  void SetShadowOffset(float offset) { mStyle.shadowOffset = offset; mControl->SetDirty(false); OnStyleChanged(); }
  void SetFrameThickness(float thickness) { mStyle.frameThickness = thickness; mControl->SetDirty(false); OnStyleChanged(); }
  void SetSplashRadius(float radius) { mSplashRadius = radius * mMaxSplashRadius; OnStyleChanged(); }
  void SetSplashPoint(float x, float y) { mSplashPoint.x = x; mSplashPoint.y = y; OnStyleChanged(); }
  void SetShape(EVShape shape) { mShape = shape; mControl->SetDirty(false); OnStyleChanged(); }
 
  virtual void SetStyle(const IVStyle& style)
  {
    mStyle = style;
    SetColors(style.colorSpec);
    OnStyleChanged();
  }
 
  IVStyle GetStyle() const { return mStyle; }
  
  IRECT GetAdjustedHandleBounds(IRECT handleBounds) const
  {
    if (mStyle.drawFrame)
      handleBounds.Pad(- 0.5f * mStyle.frameThickness);
    
    if (mStyle.drawShadows)
      handleBounds.Offset(mStyle.shadowOffset, 0, -mStyle.shadowOffset, -mStyle.shadowOffset);
    
    return handleBounds;
  }
  
  float GetRoundedCornerRadius(const IRECT& bounds) const
  {
    if (bounds.W() < bounds.H())
      return mStyle.roundness * (bounds.W() / 2.f);
    else
      return mStyle.roundness * (bounds.H() / 2.f);
  }
  
  IRECT GetWidgetBounds() const { return mWidgetBounds; }
  IRECT GetLabelBounds() const { return mLabelBounds; }
  IRECT GetValueBounds() const { return mValueBounds; }
  
  void DrawSplash(IGraphics& g, const IRECT& clipRegion = IRECT())
  {
    g.PathClipRegion(clipRegion);
    g.FillCircle(GetColor(kHL), mSplashPoint.x, mSplashPoint.y, mSplashRadius);
    g.PathClipRegion(IRECT());
  }
  
  virtual void DrawBackground(IGraphics& g, const IRECT& rect)
  {
    IBlend blend = mControl->GetBlend();
    g.FillRect(GetColor(kBG), rect, &blend);
  }
  
  virtual void DrawWidget(IGraphics& g)
  {
    // NO-OP
  }
  
  virtual void DrawLabel(IGraphics& g)
  {
    if (mLabelBounds.H() && mStyle.showLabel)
    {
      IBlend blend = mControl->GetBlend();
      g.DrawText(mStyle.labelText, mLabelStr.Get(), mLabelBounds, &blend);
    }
  }
  
  virtual void DrawValue(IGraphics& g, bool mouseOver)
  {
    if(mouseOver)
      g.FillRect(COLOR_TRANSLUCENT, mValueBounds);
    
    if (mStyle.showValue)
    {
      IBlend blend = mControl->GetBlend();
      g.DrawText(mStyle.valueText, mValueStr.Get(), mValueBounds, &blend);
    }
  }
  
  virtual void DrawPressableShape(IGraphics& g, EVShape shape, const IRECT& bounds, bool pressed, bool mouseOver, bool disabled)
  {
    switch (shape)
    {
    case EVShape::Ellipse:
      DrawPressableEllipse(g, bounds, pressed, mouseOver, disabled);
      break;
    case EVShape::Rectangle:
      DrawPressableRectangle(g, bounds, pressed, mouseOver, disabled);
      break;
    case EVShape::Triangle:
      DrawPressableTriangle(g, bounds, pressed, mouseOver, mStyle.angle, disabled);
      break;
    case EVShape::EndsRounded:
      DrawPressableRectangle(g, bounds, pressed, mouseOver, disabled, true, true, false, false);
      break;
    case EVShape::AllRounded:
      DrawPressableRectangle(g, bounds, pressed, mouseOver, disabled, true, true, true, true);
      break;
    default:
      break;
    }
  }
 
  void DrawPressableEllipse(IGraphics& g, const IRECT& bounds, bool pressed, bool mouseOver, bool disabled)
  {
    IRECT handleBounds = bounds;
    IRECT centreBounds = bounds.GetPadded(-mStyle.shadowOffset);
    IRECT shadowBounds = bounds.GetTranslated(mStyle.shadowOffset, mStyle.shadowOffset);
    const IBlend blend = mControl->GetBlend();
    const float contrast = disabled ? -GRAYED_ALPHA : 0.f;
    
    if(!pressed && !disabled && mStyle.drawShadows)
      g.FillEllipse(GetColor(kSH), shadowBounds);
   
    if (pressed)
    {
      if (mStyle.emboss)
      {
        shadowBounds.ReduceFromRight(mStyle.shadowOffset);
        shadowBounds.ReduceFromBottom(mStyle.shadowOffset);
        // Fill background with pressed color and shade it
        g.FillEllipse(GetColor(kPR), bounds, &blend);
        g.FillEllipse(GetColor(kSH), bounds, &blend);
 
        // Inverse shading for recessed look - shadowBounds = inner shadow
        g.FillEllipse(GetColor(kFG).WithContrast(contrast), shadowBounds/*, &blend*/);
 
        // Fill in center with pressed color
        g.FillEllipse(GetColor(kPR).WithContrast(contrast), centreBounds/*, &blend*/);
      }
      else
        g.FillEllipse(GetColor(kPR).WithContrast(contrast), handleBounds/*, &blend*/);
    }
    else
    {
      // Embossed style unpressed
      if (mStyle.emboss)
      {
        // Positive light TODO: use thes kPR color for now, maybe change the name?
        g.FillEllipse(GetColor(kPR).WithContrast(contrast), bounds/*, &blend*/);
 
        // Negative light TODO: clip this?
        g.FillEllipse(GetColor(kSH).WithContrast(contrast), shadowBounds/*, &blend*/);
 
        // Fill in foreground
        g.FillEllipse(GetColor(kFG).WithContrast(contrast), centreBounds/*, &blend*/);
 
        // Shade when hovered
        if (mouseOver)
          g.FillEllipse(GetColor(kHL), centreBounds, &blend);
      }
      else
      {
        g.FillEllipse(GetColor(kFG).WithContrast(contrast), handleBounds/*, &blend*/);
 
        // Shade when hovered
        if (mouseOver)
          g.FillEllipse(GetColor(kHL), handleBounds, &blend);
      }
    }
    
    if (pressed && mControl->GetAnimationFunction())
      DrawSplash(g, handleBounds);
    
    if (mStyle.drawFrame)
      g.DrawEllipse(GetColor(kFR), handleBounds, &blend, mStyle.frameThickness);
  }
  
  IRECT DrawPressableRectangle(IGraphics&g, const IRECT& bounds, bool pressed, bool mouseOver, bool disabled,
                               bool rtl = true, bool rtr = true, bool rbl = true, bool rbr = true)
  {
    IRECT handleBounds = GetAdjustedHandleBounds(bounds);
    IRECT centreBounds = handleBounds.GetPadded(-mStyle.shadowOffset);
    IRECT shadowBounds = handleBounds.GetTranslated(mStyle.shadowOffset, mStyle.shadowOffset);
    const IBlend blend = mControl->GetBlend();
    const float contrast = disabled ? -GRAYED_ALPHA : 0.f;
    float cR = GetRoundedCornerRadius(handleBounds);
 
    const float tlr = rtl ? cR : 0.f;
    const float trr = rtr ? cR : 0.f;
    const float blr = rbl ? cR : 0.f;
    const float brr = rbr ? cR : 0.f;
 
    if (pressed)
    {
      shadowBounds.ReduceFromRight(mStyle.shadowOffset);
      shadowBounds.ReduceFromBottom(mStyle.shadowOffset);
 
      if (mStyle.emboss)
      {
        // Fill background with pressed color and shade it
        g.FillRoundRect(GetColor(kPR), handleBounds, tlr, trr, blr, brr, &blend);
        g.FillRoundRect(GetColor(kSH), handleBounds, tlr, trr, blr, brr, &blend);
 
        // Inverse shading for recessed look - shadowBounds = inner shadow
        g.FillRoundRect(GetColor(kFG).WithContrast(contrast), shadowBounds, tlr, trr, blr, brr/*, &blend*/);
 
        // Fill in center with pressed color
        g.FillRoundRect(GetColor(kPR), centreBounds, tlr, trr, blr, brr, &blend);
      }
      else
      {
        g.FillRoundRect(GetColor(kPR).WithContrast(contrast), handleBounds, tlr, trr, blr, brr/*, &blend*/);
      }
    }
    else
    {
      // outer shadow
      if (mStyle.drawShadows)
        g.FillRoundRect(GetColor(kSH), shadowBounds, tlr, trr, blr, brr, &blend);
 
      // Embossed style unpressed
      if (mStyle.emboss)
      {
        // Positive light TODO: use thes kPR color for now, maybe change the name?
        g.FillRoundRect(GetColor(kPR).WithContrast(contrast), handleBounds, tlr, trr, blr, brr/*, &blend*/);
 
        // Negative light TODO: clip this?
        g.FillRoundRect(GetColor(kSH).WithContrast(contrast), shadowBounds, tlr, trr, blr, brr/*, &blend*/);
 
        // Fill in foreground
        g.FillRoundRect(GetColor(kFG).WithContrast(contrast), centreBounds, tlr, trr, blr, brr/*, &blend*/);
 
        // Shade when hovered
        if (mouseOver)
          g.FillRoundRect(GetColor(kHL), centreBounds, tlr, trr, blr, brr, &blend);
      }
      else
      {
        g.FillRoundRect(GetColor(kFG).WithContrast(contrast), handleBounds, tlr, trr, blr, brr/*, &blend*/);
 
        // Shade when hovered
        if (mouseOver)
          g.FillRoundRect(GetColor(kHL), handleBounds, tlr, trr, blr, brr, &blend);
      }
    }
    
    if (pressed && mControl->GetAnimationFunction())
      DrawSplash(g, handleBounds);
    
    if (mStyle.drawFrame)
      g.DrawRoundRect(GetColor(kFR), handleBounds, tlr, trr, blr, brr, &blend, mStyle.frameThickness);
    
    return handleBounds;
  }
  
  IRECT DrawPressableTriangle(IGraphics&g, const IRECT& bounds, bool pressed, bool mouseOver, float angle, bool disabled)
  {
    float x1, x2, x3, y1, y2, y3;
    
    float theta = DegToRad(angle);
    
    IRECT handleBounds = GetAdjustedHandleBounds(bounds);
    
    // Center bounds around origin for rotation
    float xT = handleBounds.L + handleBounds.W() * 0.5f;
    float yT = handleBounds.T + handleBounds.H() * 0.5f;
    IRECT centered = handleBounds.GetTranslated(-xT, -yT);
    
    // Do rotation and translate points back into view space
    float c = cosf(theta);
    float s = sinf(theta);
    x1 = centered.L * c - centered.B * s + xT;
    y1 = centered.L * s + centered.B * c + yT;
    x2 = centered.MW() * c - centered.T * s + xT;
    y2 = centered.MW() * s + centered.T * c + yT;
    x3 = centered.R * c - centered.B * s + xT;
    y3 = centered.R * s + centered.B * c + yT;
 
    const IBlend blend = mControl->GetBlend();
    const float contrast = disabled ? -GRAYED_ALPHA : 0.f;
 
    if (pressed)
      g.FillTriangle(GetColor(kPR).WithContrast(contrast), x1, y1, x2, y2, x3, y3/*, &blend*/);
    else
    {
      //outer shadow
      if (mStyle.drawShadows)
        g.FillTriangle(GetColor(kSH), x1 + mStyle.shadowOffset, y1 + mStyle.shadowOffset,
                                      x2 + mStyle.shadowOffset, y2 + mStyle.shadowOffset,
                                      x3 + mStyle.shadowOffset, y3 + mStyle.shadowOffset, &blend);
      
      g.FillTriangle(GetColor(kFG).WithContrast(contrast), x1, y1, x2, y2, x3, y3/*, &blend*/);
    }
    
    if (mouseOver)
      g.FillTriangle(GetColor(kHL), x1, y1, x2, y2, x3, y3, &blend);
    
    if(pressed && mControl->GetAnimationFunction())
      DrawSplash(g);
    
    if (mStyle.drawFrame)
      g.DrawTriangle(GetColor(kFR), x1, y1, x2, y2, x3, y3, &blend, mStyle.frameThickness);
    
    return handleBounds;
  }
  
  IRECT MakeRects(const IRECT& parent, bool hasHandle = false)
  {
    IRECT clickableArea = parent;
    
    if(!mLabelInWidget)
    {
      if(mStyle.showLabel && CStringHasContents(mLabelStr.Get()))
      {
        IRECT textRect;
        mControl->GetUI()->MeasureText(mStyle.labelText, mLabelStr.Get(), textRect);
 
        switch (mStyle.labelOrientation)
        {
          case EOrientation::North:
            mLabelBounds = parent.GetFromTop(textRect.H()).GetCentredInside(textRect.W(), textRect.H());
            break;
          case EOrientation::East:
            mLabelBounds = parent.GetFromRight(textRect.W()).GetCentredInside(textRect.W(), textRect.H());
            break;
          case EOrientation::South:
            mLabelBounds = parent.GetFromBottom(textRect.H()).GetCentredInside(textRect.W(), textRect.H());
            break;
          case EOrientation::West:
            mLabelBounds = parent.GetFromLeft(textRect.W()).GetCentredInside(textRect.W(), textRect.H());
            break;
        }
      }
      else
        mLabelBounds = IRECT();
      
      if (!mLabelBounds.Empty())
      {
        switch (mStyle.labelOrientation)
        {
          case EOrientation::North:
            clickableArea = parent.GetReducedFromTop(mLabelBounds.H());
            break;
          case EOrientation::East:
            clickableArea = parent.GetReducedFromRight(mLabelBounds.W());
            break;
          case EOrientation::South:
            clickableArea = parent.GetReducedFromBottom(mLabelBounds.H());
            break;
          case EOrientation::West:
            clickableArea = parent.GetReducedFromLeft(mLabelBounds.W());
            break;
        }
      }
    }
    
    if (mStyle.showValue && !mValueInWidget)
    {
      IRECT textRect;
      
      if(CStringHasContents(mValueStr.Get()))
        mControl->GetUI()->MeasureText(mStyle.valueText, mValueStr.Get(), textRect);
 
      const float valueDisplayWidth = textRect.W() * mValueDisplayFrac;
 
      switch (mStyle.valueText.mVAlign)
      {
        case EVAlign::Middle:
          mValueBounds = clickableArea.GetMidVPadded(textRect.H()/2.f).GetMidHPadded(valueDisplayWidth);
          mWidgetBounds = clickableArea.GetScaledAboutCentre(mStyle.widgetFrac);
          break;
        case EVAlign::Bottom:
        {
          mValueBounds = clickableArea.GetFromBottom(textRect.H()).GetMidHPadded(valueDisplayWidth);
          mWidgetBounds = clickableArea.GetReducedFromBottom(textRect.H()).GetScaledAboutCentre(mStyle.widgetFrac);
          break;
        }
        case EVAlign::Top:
          mValueBounds = clickableArea.GetFromTop(textRect.H()).GetMidHPadded(valueDisplayWidth);
          mWidgetBounds = clickableArea.GetReducedFromTop(textRect.H()).GetScaledAboutCentre(mStyle.widgetFrac);
          break;
        default:
          break;
      }
    }
    else
    {
      mWidgetBounds = clickableArea.GetScaledAboutCentre(mStyle.widgetFrac);
    }
    
    if(hasHandle)
      mWidgetBounds = GetAdjustedHandleBounds(clickableArea).GetScaledAboutCentre(mStyle.widgetFrac);
    
    if(mLabelInWidget)
      mLabelBounds = mWidgetBounds;
    
    if(mValueInWidget)
      mValueBounds = mWidgetBounds;
    
    return clickableArea;
  }
  
protected:
  IControl* mControl = nullptr;
  IVStyle mStyle; // IVStyle that defines certain common properties of an IVControl
  bool mLabelInWidget = false; // Should the Label text be displayed inside the widget
  bool mValueInWidget = false; // Should the Value text be displayed inside the widget
  float mSplashRadius = 0.f; // Modified during the default SplashClickAnimationFunc to specify the radius of the splash
  IVec2 mSplashPoint = {0.f, 0.f}; // Set at the start of the SplashClickActionFunc to set the position of the splash
  float mMaxSplashRadius = 50.f;
  float mTrackSize = 2.f;
  float mValueDisplayFrac = 0.66f; // the fraction of the control width for the text entry
  IRECT mWidgetBounds; // The knob/slider/button
  IRECT mLabelBounds; // A piece of text above the control
  IRECT mValueBounds; // Text below the contol, usually displaying the value of a parameter
  WDL_String mLabelStr;
  WDL_String mValueStr;
  EVShape mShape = EVShape::Rectangle;
};
 
class IMultiTouchControlBase
{
public:
  struct TrackedTouch
  {
    int index = 0;
    float x = 0.f;
    float y = 0.f;
    float sx = 0.f;
    float sy = 0.f;
    float radius = 1.f;
    TimePoint startTime;
    
    TrackedTouch(int index, float x, float y, float radius, TimePoint time)
    : index(index), x(x), y(y), sx(x), sy(y), radius(radius), startTime(time)
    {}
    
    TrackedTouch()
    {}
  };
  
  virtual ~IMultiTouchControlBase() {}
  
  virtual void AddTouch(ITouchID touchID, float x, float y, float radius)
  {
    int touchIndex = 0;
    for (int i = 0; i < MAX_TOUCHES; i++)
    {
      if (mTouchStatus[i] == false)
      {
        touchIndex = i;
        mTouchStatus[i] = true;
        break;
      }
    }
 
    if(NTrackedTouches() < MAX_TOUCHES)
      mTrackedTouches.insert(std::make_pair(touchID, TrackedTouch(touchIndex, x, y, radius, std::chrono::high_resolution_clock::now())));
  }
  
  virtual void ReleaseTouch(ITouchID touchID)
  {
    mTouchStatus[GetTouchWithIdentifier(touchID)->index] = false;
    mTrackedTouches.erase(touchID);
  }
  
  virtual void UpdateTouch(ITouchID touchID, float x, float y, float radius)
  {
    mTrackedTouches[touchID].x = x;
    mTrackedTouches[touchID].y = y;
    mTrackedTouches[touchID].radius = radius;
  }
  
  void ClearAllTouches()
  {
    mTrackedTouches.clear();
    memset(mTouchStatus, 0, MAX_TOUCHES * sizeof(bool));
  }
  
  int NTrackedTouches() const
  {
    return static_cast<int>(mTrackedTouches.size());
  }
  
  TrackedTouch* GetTouch(int index)
  {
    auto itr = std::find_if(mTrackedTouches.begin(), mTrackedTouches.end(),
    [index](auto element) {
      return(element.second.index == index);
    });
 
    if(itr != mTrackedTouches.end())
      return &itr->second;
    else
      return nullptr;
  }
  
  TrackedTouch* GetTouchWithIdentifier(ITouchID touchID)
  {
    auto itr = mTrackedTouches.find(touchID);
    
    if(itr != mTrackedTouches.end())
      return &itr->second;
    else
      return nullptr;
  }
  
protected:
  static constexpr int MAX_TOUCHES = 10;
  std::unordered_map<ITouchID, TrackedTouch> mTrackedTouches;
  bool mTouchStatus[MAX_TOUCHES] = { 0 };
};
 
class IKnobControlBase : public IControl
{
public:
  IKnobControlBase(const IRECT& bounds, int paramIdx = kNoParameter, EDirection direction = EDirection::Vertical, double gearing = DEFAULT_GEARING)
  : IControl(bounds, paramIdx)
  , mDirection(direction)
  , mGearing(gearing)
  {}
 
  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 OnMouseWheel(float x, float y, const IMouseMod& mod, float d) override;
  
  void SetGearing(double gearing) { mGearing = gearing; }
  bool IsFineControl(const IMouseMod& mod, bool wheel) const;
 
protected:
  virtual IRECT GetKnobDragBounds() { return mTargetRECT; }
 
  bool mHideCursorOnDrag = true;
  EDirection mDirection;
  double mGearing;
  bool mMouseDown = false;
  double mMouseDragValue = 0.0;
};
 
class ISliderControlBase : public IControl
{
public:
  ISliderControlBase(const IRECT& bounds, int paramIdx = kNoParameter, EDirection dir = EDirection::Vertical, double gearing = DEFAULT_GEARING, float handleSize = 0.f);
  ISliderControlBase(const IRECT& bounds, IActionFunction aF = nullptr, EDirection dir = EDirection::Vertical, double gearing = DEFAULT_GEARING, float handleSize = 0.f);
  
  void OnResize() override;
  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 OnMouseWheel(float x, float y, const IMouseMod& mod, float d) override;
 
  void SetGearing(double gearing) { mGearing = gearing; }
  bool IsFineControl(const IMouseMod& mod, bool wheel) const;
  
protected:
  bool mHideCursorOnDrag = true;
  EDirection mDirection;
  IRECT mTrackBounds;
  float mHandleSize;
  double mGearing;
  bool mMouseDown = false;
  double mMouseDragValue;
};
 
class IVTrackControlBase : public IControl
                         , public IVectorBase
{
public:
  IVTrackControlBase(const IRECT& bounds, const char* label, const IVStyle& style, int maxNTracks = 1, int nSteps = 0, EDirection dir = EDirection::Horizontal, std::initializer_list<const char*> trackNames = {})
  : IControl(bounds)
  , IVectorBase(style)
  , mDirection(dir)
  , mNSteps(nSteps)
  {
    SetNVals(maxNTracks);
    mTrackBounds.Resize(maxNTracks);
    
    for (int i=0; i<maxNTracks; i++)
    {
      SetParamIdx(kNoParameter, i);
    }
    
    if(trackNames.size())
    {
      assert(trackNames.size() == maxNTracks); // check that the trackNames list size matches the number of tracks
      
      for (auto& trackName : trackNames)
      {
        mTrackNames.Add(new WDL_String(trackName));
      }
    }
    
    AttachIControl(this, label);
  }
 
  IVTrackControlBase(const IRECT& bounds, const char* label, const IVStyle& style, int lowParamidx, int maxNTracks = 1, int nSteps = 0, EDirection dir = EDirection::Horizontal, std::initializer_list<const char*> trackNames = {})
  : IControl(bounds)
  , IVectorBase(style)
  , mDirection(dir)
  , mNSteps(nSteps)
  {
    SetNVals(maxNTracks);
    mTrackBounds.Resize(maxNTracks);
    
    for (int i = 0; i < maxNTracks; i++)
    {
      SetParamIdx(lowParamidx+i, i);
    }
    
    if(trackNames.size())
    {
      assert(trackNames.size() == maxNTracks);
      
      for (auto& trackName : trackNames)
      {
        mTrackNames.Add(new WDL_String(trackName));
      }
    }
 
    AttachIControl(this, label);
  }
  
  IVTrackControlBase(const IRECT& bounds, const char* label, const IVStyle& style, const std::initializer_list<int>& params, int nSteps = 0, EDirection dir = EDirection::Horizontal, std::initializer_list<const char*> trackNames = {})
  : IControl(bounds)
  , IVectorBase(style)
  , mDirection(dir)
  , mNSteps(nSteps)
  {
    int maxNTracks = static_cast<int>(params.size());
    SetNVals(maxNTracks);
    mTrackBounds.Resize(maxNTracks);
    
    int valIdx = 0;
    for (auto param : params)
    {
      SetParamIdx(param, valIdx++);
    }
    
    if(trackNames.size())
    {
      assert(trackNames.size() == params.size());
      
      for (auto& trackName : trackNames)
      {
        mTrackNames.Add(new WDL_String(trackName));
      }
    }
    
    AttachIControl(this, label);
  }
  
  virtual ~IVTrackControlBase()
  {
    mTrackNames.Empty(true);
  }
  
  void OnMouseOver(float x, float y, const IMouseMod& mod) override
  {
    mMouseOverTrack = GetValIdxForPos(x, y);
    SetDirty(false);
  }
 
  void OnMouseOut() override
  {
    mMouseOverTrack = -1;
    SetDirty(false);
  }
  
  virtual void OnResize() override
  {
    SetTargetRECT(MakeRects(mRECT));
    MakeTrackRects(mWidgetBounds);
    MakeStepRects(mWidgetBounds, mNSteps);
    SetDirty(false);
  }
  
  int GetValIdxForPos(float x, float y) const override
  {
    int nVals = NVals();
    
    for (auto v = 0; v < nVals; v++)
    {
      if (mTrackBounds.Get()[v].Contains(x, y))
      {
        return v;
      }
    }
 
    return kNoValIdx;
  }
  
  void DrawWidget(IGraphics& g) override
  {
    const int nVals = NVals();
    
    for (int ch = 0; ch < nVals; ch++)
    {
      DrawTrack(g, mTrackBounds.Get()[ch], ch);
    }
  }
  
  void SetParamsByGroup(const char* paramGroup)
  {
    int nParams = GetDelegate()->NParams();
    std::vector<int> paramIdsForGroup;
    
    for (auto p = 0; p < nParams; p++)
    {
      IParam* pParam = GetDelegate()->GetParam(p);
      
      if(strcmp(pParam->GetGroup(), paramGroup) == 0)
      {
        paramIdsForGroup.push_back(p);
      }
    }
 
    SetParams(paramIdsForGroup);
  }
  
  void SetParams(const std::vector<int>& paramIds)
  {
    int nParams = static_cast<int>(paramIds.size());
 
    SetNVals(nParams);
    mTrackBounds.Resize(nParams);
  
    int valIdx = 0;
    for (auto param : paramIds)
    {
      SetParamIdx(param, valIdx++);
    }
    
    const IParam* pFirstParam = GetParam(0);
    const int range = static_cast<int>(pFirstParam->GetRange() / pFirstParam->GetStep());
    mZeroValueStepHasBounds = !(range == 1);
    SetNSteps(pFirstParam->GetStepped() ? range : 0); // calls OnResize()
  }
  
  void SetNTracks(int nTracks)
  {
    SetNVals(nTracks);
    mTrackBounds.Resize(nTracks);
    OnResize();
  }
  
  void SetBaseValue(double value)
  {
    mBaseValue = value; OnResize();
  }
  
  void SetTrackPadding(float value)
  {
    mTrackPadding = value; OnResize();
  }
  
  void SetPeakSize(float value)
  {
    mPeakSize = value; OnResize();
  }
  
  void SetNSteps(int nSteps)
  {
    mNSteps = nSteps; OnResize();
  }
 
  void SetHighlightedTrack(int highlightIdx)
  {
    mHighlightedTrack = highlightIdx;
    SetDirty(false);
  }
  
  void SetZeroValueStepHasBounds(bool val)
  {
    mZeroValueStepHasBounds = val;
    OnResize();
  }
  
  bool HasTrackNames() const
  {
    return mTrackNames.GetSize() > 0;
  }
  
  const char* GetTrackName(int chIdx) const
  {
    WDL_String* pStr = mTrackNames.Get(chIdx);
    return pStr ? pStr->Get() : "";
  }
  
  void SetTrackName(int chIdx, const char* newName)
  {
    assert(chIdx >= 0 && chIdx < mTrackNames.GetSize());
    
    if(chIdx >= 0 && chIdx < mTrackNames.GetSize())
    {
      mTrackNames.Get(chIdx)->Set(newName);
    }
  }
  
protected:
  virtual void DrawBackground(IGraphics& g, const IRECT& r) override
  {
    g.FillRect(GetColor(kBG), r, &mBlend);
 
    if(mBaseValue > 0.)
    {
      if(mDirection == EDirection::Horizontal)
        g.DrawVerticalLine(GetColor(kSH), r, static_cast<float>(mBaseValue));
      else
        g.DrawHorizontalLine(GetColor(kSH), r, static_cast<float>(mBaseValue));
    }
  }
 
  virtual void DrawTrack(IGraphics& g, const IRECT& r, int chIdx)
  {
    DrawTrackBackground(g, r, chIdx);
    
    if(HasTrackNames())
      DrawTrackName(g, r, chIdx);
    
    const float trackPos = static_cast<float>(GetValue(chIdx));
    
    const bool stepped = GetStepped();
    
    IRECT fillRect;
    const float bv = static_cast<float>(mBaseValue);
 
    if(bv > 0.f)
    {
      if(mDirection == EDirection::Vertical)
      {
        fillRect = IRECT(r.L,
                         trackPos < bv ? r.B - r.H() * bv : r.B - r.H() * trackPos,
                         r.R,
                         trackPos < bv ? r.B - r.H() * trackPos : r.B - r.H() * bv);
      }
      else
      {
        fillRect = IRECT(trackPos < bv ? r.L + r.W() * trackPos : r.L + r.W() * bv,
                         r.T,
                         trackPos < bv ? r.L + r.W() * bv : r.L + r.W() * trackPos,
                         r.B);
      }
    }
    else
    {
      fillRect = r.FracRect(mDirection, trackPos);
      
      if(stepped && mZeroValueStepHasBounds && trackPos == 0.f)
      {
        if(mDirection == EDirection::Vertical)
          fillRect.T = mStepBounds.Get()[0].T;
      }
    }
    
    if(stepped)
    {
      int step = GetStepIdxForPos(fillRect.R, fillRect.T);
 
      if (step > -1)
      {
        if(mDirection == EDirection::Horizontal)
        {
          fillRect.L = mStepBounds.Get()[step].L;
          fillRect.R = mStepBounds.Get()[step].R;
        }
        else
        {
          fillRect.T = mStepBounds.Get()[step].T;
          fillRect.B = mStepBounds.Get()[step].B;
        }
      }
      
      if(mZeroValueStepHasBounds || GetValue(chIdx) > 0.)
        DrawTrackHandle(g, fillRect, chIdx, trackPos > mBaseValue);
    }
    else
    {
      DrawTrackHandle(g, fillRect, chIdx, trackPos > mBaseValue);
      
      IRECT peakRect;
      
      if(mDirection == EDirection::Vertical)
      {
        peakRect = IRECT(fillRect.L,
                         trackPos < mBaseValue ? fillRect.B : fillRect.T,
                         fillRect.R,
                         trackPos < mBaseValue ? fillRect.B - mPeakSize: fillRect.T + mPeakSize);
      }
      else
      {
        peakRect = IRECT(trackPos < mBaseValue ? fillRect.L + mPeakSize : fillRect.R - mPeakSize,
                         fillRect.T,
                         trackPos < mBaseValue ? fillRect.L : fillRect.R,
                         fillRect.B);
      }
      
      DrawPeak(g, peakRect, chIdx, trackPos > mBaseValue);
    }
 
    if(mStyle.drawFrame && mDrawTrackFrame)
      g.DrawRect(GetColor(kFR), r, &mBlend, mStyle.frameThickness);
  }
 
  virtual void DrawTrackBackground(IGraphics& g, const IRECT& r, int chIdx)
  {
    g.FillRect(chIdx == mHighlightedTrack ? this->GetColor(kHL) : COLOR_TRANSPARENT, r);
  }
  
  virtual void DrawTrackName(IGraphics& g, const IRECT& r, int chIdx)
  {
    g.DrawText(mText, GetTrackName(chIdx), r);
  }
  
  virtual void DrawTrackHandle(IGraphics& g, const IRECT& r, int chIdx, bool aboveBaseValue)
  {
    g.FillRect(chIdx == mHighlightedTrack ? GetColor(kX1) : GetColor(kFG), r, &mBlend);
 
    if(chIdx == mMouseOverTrack)
      g.FillRect(GetColor(kHL), r, &mBlend);
  }
  
  virtual void DrawPeak(IGraphics& g, const IRECT& r, int chIdx, bool aboveBaseValue)
  {
    g.FillRect(GetColor(kFR), r, &mBlend);
  }
    
  int GetStepIdxForPos(float x, float y) const
  {
    int nSteps = mStepBounds.GetSize();
    
    for (auto v = 0; v < nSteps; v++)
    {
      if (mStepBounds.Get()[v].ContainsEdge(x, y))
      {
        return v;
      }
    }
 
    return -1;
  }
 
  virtual void MakeTrackRects(const IRECT& bounds)
  {
    int nVals = NVals();
    int dir = static_cast<int>(mDirection); // 0 = horizontal, 1 = vertical
    for (int ch = 0; ch < nVals; ch++)
    {
      mTrackBounds.Get()[ch] = bounds.SubRect(EDirection(!dir), nVals, ch).
                                     GetPadded(0, -mTrackPadding * (float) dir, -mTrackPadding * (float) !dir, -mTrackPadding);
    }
  }
  
  virtual void MakeStepRects(const IRECT& bounds, int nSteps)
  {
    if(nSteps)
    {
      int dir = static_cast<int>(mDirection);
      
      nSteps += (int) mZeroValueStepHasBounds;
      
      mStepBounds.Resize(nSteps);
      
      for (int step = 0; step < nSteps; step++)
      {
        mStepBounds.Get()[step] = bounds.SubRect(EDirection(dir), nSteps, nSteps - 1 - step);
      }
    }
    else
      mStepBounds.Resize(0);
  }
  
  bool GetStepped() const
  {
    return mStepBounds.GetSize() > 0;
  }
 
protected:
  EDirection mDirection = EDirection::Vertical;
  WDL_TypedBuf<IRECT> mTrackBounds;
  WDL_TypedBuf<IRECT> mStepBounds;
  WDL_PtrList<WDL_String> mTrackNames;
  int mNSteps = 0;
  float mTrackPadding = 0.;
  float mPeakSize = 1.;
  int mHighlightedTrack = -1; // Highlight a single track, e.g. for step sequencer
  int mMouseOverTrack = -1;
  double mBaseValue = 0.; // 0-1 value to represent the mid-point, i.e. for displaying bipolar data
  bool mDrawTrackFrame = true;
  bool mZeroValueStepHasBounds = true; // If this is true, there is a separate step for zero, when mNSteps > 0
};
 
class IButtonControlBase : public IControl
{
public:
  IButtonControlBase(const IRECT& bounds, IActionFunction aF);
  
  virtual ~IButtonControlBase() {}
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnEndAnimation() override;
};
 
class ISwitchControlBase : public IControl
{
public:
  ISwitchControlBase(const IRECT& bounds, int paramIdx = kNoParameter, IActionFunction aF = nullptr, int numStates = 2);
 
  virtual ~ISwitchControlBase() {}
  void OnInit() override;
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnMouseUp(float x, float y, const IMouseMod& mod) override;
  
  int GetSelectedIdx() const { return int(0.5 + GetValue() * (double) (mNumStates - 1)); }
  
  void SetStateDisabled(int stateIdx, bool disabled);
  void SetAllStatesDisabled(bool disabled);
  bool GetStateDisabled(int stateIdx) const;
protected:
  int mNumStates;
  WDL_TypedBuf<bool> mDisabledState;
  bool mMouseDown = false;
};
 
class IDirBrowseControlBase : public IContainerBase
{
public:
  IDirBrowseControlBase(const IRECT& bounds, const char* extension, bool showFileExtensions = true, bool scanRecursively = true, bool showEmptySubmenus = false)
  : IContainerBase(bounds)
  , mExtension(extension)
  , mShowFileExtensions(showFileExtensions)
  , mScanRecursively(scanRecursively)
  , mShowEmptySubmenus(showEmptySubmenus)
  {
  }
 
  virtual ~IDirBrowseControlBase();
 
  int NItems() const;
 
  void AddPath(const char* path, const char* displayText);
  
  void ClearPathList();
 
  void SetupMenu();
  
  void SetSelectedFile(const char* filePath);
  
  void GetSelectedFile(WDL_String& path) const;
  
  void CheckSelectedItem();
 
private:
  void ScanDirectory(const char* path, IPopupMenu& menuToAddTo);
  void CollectSortedItems(IPopupMenu* pMenu);
  
protected:
  const bool mScanRecursively;
  const bool mShowFileExtensions;
  const bool mShowEmptySubmenus;
  int mSelectedItemIndex = -1; // index into mItems
  IPopupMenu mMainMenu;
  WDL_PtrList<WDL_String> mPaths;
  WDL_PtrList<WDL_String> mPathLabels;
  WDL_PtrList<WDL_String> mFiles;
  WDL_PtrList<IPopupMenu::Item> mItems; // ptr to item for each file
  WDL_String mExtension;
};
 
#pragma mark - BASIC CONTROLS
 
class IPanelControl : public IContainerBase
{
public:
  IPanelControl(const IRECT& bounds, const IColor& color, bool drawFrame = false,
                AttachFunc attachFunc = nullptr, ResizeFunc resizeFunc = nullptr)
  : IContainerBase(bounds, attachFunc, resizeFunc)
  , mPattern(color)
  , mDrawFrame(drawFrame)
  {
    mIgnoreMouse = true;
  }
  
  IPanelControl(const IRECT& bounds, const IPattern& pattern, bool drawFrame = false,
                AttachFunc attachFunc = nullptr, ResizeFunc resizeFunc = nullptr)
  : IContainerBase(bounds, attachFunc, resizeFunc)
  , mPattern(pattern)
  , mDrawFrame(drawFrame)
  {
    mIgnoreMouse = true;
  }
 
  void Draw(IGraphics& g) override
  {
    g.PathRect(mRECT);
    g.PathFill(mPattern, IFillOptions(), &mBlend);
  
    if (mDrawFrame)
      g.DrawRect(COLOR_LIGHT_GRAY, mRECT, &mBlend);
  }
  
  void SetPattern(const IPattern& pattern)
  {
    mPattern = pattern;
    SetDirty(false);
  }
  
  IPattern GetPattern() const { return mPattern; }
  
private:
  IPattern mPattern;
  bool mDrawFrame;
};
 
class ILambdaControl : public IControl
{
public:
  ILambdaControl(const IRECT& bounds, ILambdaDrawFunction drawFunc, int animationDuration = DEFAULT_ANIMATION_DURATION,
    bool loopAnimation = false, bool startImmediately = false, int paramIdx = kNoParameter, bool ignoreMouse = false)
  : IControl(bounds, paramIdx, DefaultClickActionFunc)
  , mDrawFunc(drawFunc)
  , mLoopAnimation(loopAnimation)
  , mAnimationDuration(animationDuration)
  {
    if (startImmediately)
      SetAnimation(DefaultAnimationFunc, mAnimationDuration);
    
    mIgnoreMouse = ignoreMouse;
    mDblAsSingleClick = true;
  }
  
  void Draw(IGraphics& g) override
  {
    if (mDrawFunc)
      mDrawFunc(this, g, mRECT);
  }
  
  virtual void OnEndAnimation() override // if you override this you must call the base implementation, to free mAnimationFunc
  {
    if (mLoopAnimation && mAnimationDuration)
      StartAnimation(mAnimationDuration);
    else
      IControl::OnEndAnimation();
    
    SetDirty(false);
  }
  
  void OnMouseDown(float x, float y, const IMouseMod& mod) override
  {
    mMouseInfo.x = x; mMouseInfo.y = y; mMouseInfo.ms = mod;
    SetAnimation(DefaultAnimationFunc, mAnimationDuration);
  }
  
  void OnMouseUp(float x, float y, const IMouseMod& mod) override
  {
    mMouseInfo.x = x;
    mMouseInfo.y = y;
    mMouseInfo.ms = IMouseMod();
    SetDirty(false);
  }
  
  void OnMouseDrag(float x, float y, float dX, float dY, const IMouseMod& mod) override
  {
    mMouseInfo.x = x;
    mMouseInfo.y = y;
    mMouseInfo.dX = dX;
    mMouseInfo.dY = dY;
    mMouseInfo.ms = mod;
    SetDirty(false);
  }
 
public: // public for easy access :-)
  ILayerPtr mLayer;
  IMouseInfo mMouseInfo;
private:
  ILambdaDrawFunction mDrawFunc = nullptr;
  bool mLoopAnimation;
  int mAnimationDuration;
};
 
class IBitmapControl : public IControl
                     , public IBitmapBase
{
public:
  IBitmapControl(float x, float y, const IBitmap& bitmap, int paramIdx = kNoParameter, EBlend blend = EBlend::Default)
  : IControl(IRECT(x, y, bitmap), paramIdx)
  , IBitmapBase(bitmap)
  {
    AttachIControl(this);
    mBlend = blend;
  }
  
  IBitmapControl(const IRECT& bounds, const IBitmap& bitmap, int paramIdx = kNoParameter, EBlend blend = EBlend::Default)
  : IControl(bounds, paramIdx)
  , IBitmapBase(bitmap)
  {
    AttachIControl(this);
    mBlend = blend;
  }
  
  virtual ~IBitmapControl() {}
 
  void Draw(IGraphics& g) override { DrawBitmap(g); }
 
  void OnRescale() override { mBitmap = GetUI()->GetScaledBitmap(mBitmap); }
};
 
class ISVGControl : public IControl
{
public:
  ISVGControl(const IRECT& bounds, const ISVG& svg, bool useLayer = false)
  : IControl(bounds)
  , mUseLayer(useLayer)
  , mSVG(svg)
  {}
 
  virtual ~ISVGControl() {}
 
  void Draw(IGraphics& g) override
  {
    if(mUseLayer)
    {
      if (!g.CheckLayer(mLayer))
      {
        g.StartLayer(this, mRECT);
        g.DrawSVG(mSVG, mRECT);
        mLayer = g.EndLayer();
      }
 
      g.DrawLayer(mLayer, &mBlend);
    }
    else
      g.DrawSVG(mSVG, mRECT, &mBlend);
  }
  
  void SetSVG(const ISVG& svg)
  {
    mSVG = svg;
  }
  
private:
  bool mUseLayer;
  ILayerPtr mLayer;
  ISVG mSVG;
};
 
class ITextControl : public IControl
{
public:
  ITextControl(const IRECT& bounds, const char* str = "", const IText& text = DEFAULT_TEXT, const IColor& BGColor = DEFAULT_BGCOLOR, bool setBoundsBasedOnStr = false);
 
  void Draw(IGraphics& g) override;
  void OnInit() override;
 
  virtual void SetStr(const char* str);
  
  virtual void SetStrFmt(int maxlen, const char* fmt, ...);
  
  virtual void ClearStr() { SetStr(""); }
  
  const char* GetStr() const { return mStr.Get(); }
  
  void SetBoundsBasedOnStr();
  
protected:
  WDL_String mStr;
  IColor mBGColor;
  bool mSetBoundsBasedOnStr = false;
};
 
class IEditableTextControl : public ITextControl
{
public:
  IEditableTextControl(const IRECT& bounds, const char* str, const IText& text = DEFAULT_TEXT, const IColor& BGColor = DEFAULT_BGCOLOR)
  : ITextControl(bounds, str, text, BGColor)
  {
    mIgnoreMouse = false;
  }
  
  void OnMouseDown(float x, float y, const IMouseMod& mod) override
  {
    GetUI()->CreateTextEntry(*this, mText, mRECT, GetStr());
  }
  
  void OnTextEntryCompletion(const char* str, int valIdx) override
  {
    SetStr(str);
    SetDirty(true);
  }
};
 
class IMultiLineTextControl : public ITextControl
{
public:
  IMultiLineTextControl(const IRECT& bounds, const char* str, const IText& text = DEFAULT_TEXT, const IColor& BGColor = DEFAULT_BGCOLOR)
  : ITextControl(bounds, str, text, BGColor)
  {
  }
  
  void Draw(IGraphics& g) override
  {
    g.FillRect(mBGColor, mRECT, &mBlend);
    g.DrawMultiLineText(mText, mStr.Get(), mRECT, &mBlend);
  }
};
 
 
class IURLControl : public ITextControl
{
public:
  IURLControl(const IRECT& bounds, const char* str, const char* url, const IText& text = DEFAULT_TEXT, const IColor& BGColor = DEFAULT_BGCOLOR, const IColor& MOColor = COLOR_WHITE, const IColor& CLColor = COLOR_BLUE);
  
  void Draw(IGraphics& g) override;
  
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnMouseOver(float x, float y, const IMouseMod& mod) override { GetUI()->SetMouseCursor(ECursor::HAND); IControl::OnMouseOver(x, y, mod); };
  void OnMouseOut() override { GetUI()->SetMouseCursor(); IControl::OnMouseOut(); }
  void SetText(const IText&) override;
 
  void SetMOColor(const IColor& color) { mMOColor = color; SetDirty(false); }
  
  void SetCLColor(const IColor& color) { mCLColor = color; SetDirty(false); }
  
protected:
  WDL_String mURLStr;
  IColor mOriginalColor, mMOColor, mCLColor;
  bool mClicked = false;
};
 
class ITextToggleControl : public ITextControl
{
public:
  ITextToggleControl(const IRECT& bounds, int paramIdx = kNoParameter, const char* offText = "OFF", const char* onText = "ON", const IText& text = DEFAULT_TEXT, const IColor& BGColor = DEFAULT_BGCOLOR);
  
  ITextToggleControl(const IRECT& bounds, IActionFunction aF = nullptr, const char* offText = "OFF", const char* onText = "ON", const IText& text = DEFAULT_TEXT, const IColor& BGColor = DEFAULT_BGCOLOR);
 
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void SetDirty(bool push, int valIdx = 0) override;
protected:
  WDL_String mOffText;
  WDL_String mOnText;
};
 
class ICaptionControl : public ITextControl
{
public:
  ICaptionControl(const IRECT& bounds, int paramIdx, const IText& text = DEFAULT_TEXT, const IColor& BGColor = DEFAULT_BGCOLOR, bool showParamLabel = true);
  void Draw(IGraphics& g) override;
  void OnMouseDown(float x, float y, const IMouseMod& mod) override;
  void OnResize() override;
protected:
  bool mShowParamLabel;
  IColor mTriangleColor = COLOR_BLACK;
  IColor mTriangleMouseOverColor = COLOR_WHITE;
  IRECT mTriangleRect;
};
 
class PlaceHolder : public ITextControl
{
public:
  PlaceHolder(const IRECT& bounds, const char* str = "Place Holder");
  
  void Draw(IGraphics& g) override;
  void OnMouseDblClick(float x, float y, const IMouseMod& mod) override { GetUI()->CreateTextEntry(*this, mText, mRECT, mStr.Get()); }
  void OnTextEntryCompletion(const char* str, int valIdx) override { SetStr(str); }
  void OnResize() override;
 
protected:
  IRECT mCentreLabelBounds;
  WDL_String mTLHCStr;
  WDL_String mWidthStr;
  WDL_String mHeightStr;
  IText mTLGCText = DEFAULT_TEXT.WithAlign(EAlign::Near);
  IText mWidthText = DEFAULT_TEXT;
  IText mHeightText = DEFAULT_TEXT.WithAngle(270.f);
  static constexpr float mInset = 10.f;
};
 
END_IGRAPHICS_NAMESPACE
END_IPLUG_NAMESPACE