IGraphicsStructs.h

/*
 ==============================================================================
 
 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers.
 
 See LICENSE.txt for  more info.
 
 ==============================================================================
*/
 
#pragma once
 
#include <functional>
#include <chrono>
#include <numeric>
 
#include "IPlugUtilities.h"
#include "IPlugLogger.h"
#include "IPlugStructs.h"
 
#include "IGraphicsPrivate.h"
#include "IGraphicsUtilities.h"
#include "IGraphicsConstants.h"
 
BEGIN_IPLUG_NAMESPACE
BEGIN_IGRAPHICS_NAMESPACE
 
class IGraphics;
class IControl;
class ILambdaControl;
class IPopupMenu;
struct IRECT;
struct IVec2;
struct IMouseInfo;
struct IColor;
struct IGestureInfo;
 
using IActionFunction = std::function<void(IControl*)>;
using IAnimationFunction = std::function<void(IControl*)>;
using IControlFunction = std::function<void(IControl*)>;
using ILambdaDrawFunction = std::function<void(ILambdaControl*, IGraphics&, IRECT&)>;
using IKeyHandlerFunc = std::function<bool(const IKeyPress& key, bool isUp)>;
using IMsgBoxCompletionHandlerFunc = std::function<void(EMsgBoxResult result)>;
using IFileDialogCompletionHandlerFunc = std::function<void(const WDL_String& fileName, const WDL_String& path)>;
using IColorPickerHandlerFunc = std::function<void(const IColor& result)>;
using IGestureFunc = std::function<void(IControl*, const IGestureInfo&)>;
using IPopupFunction = std::function<void(IPopupMenu* pMenu)>;
using IDisplayTickFunc = std::function<void()>;
using IUIAppearanceChangedFunc = std::function<void(EUIAppearance appearance)>;
using ITouchID = uintptr_t;
 
void EmptyClickActionFunc(IControl* pCaller);
 
void DefaultClickActionFunc(IControl* pCaller);
 
void DefaultAnimationFunc(IControl* pCaller);
 
void SplashClickActionFunc(IControl* pCaller);
 
void SplashAnimationFunc(IControl* pCaller);
 
void ShowBubbleHorizontalActionFunc(IControl* pCaller);
 
void ShowBubbleVerticalActionFunc(IControl* pCaller);
 
using MTLTexturePtr = void*;
 
using Milliseconds = std::chrono::duration<double, std::chrono::milliseconds::period>;
using TimePoint = std::chrono::time_point<std::chrono::high_resolution_clock, Milliseconds>;
 
class IBitmap
{
public:
  IBitmap(APIBitmap* pAPIBitmap, int n, bool framesAreHorizontal, const char* name = "")
  : mAPIBitmap(pAPIBitmap)
  , mW(static_cast<int>(pAPIBitmap->GetWidth() / pAPIBitmap->GetScale()))
  , mH(static_cast<int>(pAPIBitmap->GetHeight() / pAPIBitmap->GetScale()))
  , mN(n)
  , mFramesAreHorizontal(framesAreHorizontal)
  , mResourceName(name, static_cast<int>(strlen(name)))
  {
  }
 
  IBitmap()
  : mAPIBitmap(nullptr)
  , mW(0)
  , mH(0)
  , mN(0)
  , mFramesAreHorizontal(false)
  {
  }
  
  int W() const { return mW; }
 
  int H() const { return mH; }
 
  int FW() const { return (mFramesAreHorizontal ? mW / mN : mW); }
  
  int FH() const { return (mFramesAreHorizontal ? mH : mH / mN); }
  
  int N() const { return mN; }
  
  float GetScale() const { return mAPIBitmap->GetScale(); }
 
  float GetDrawScale() const { return mAPIBitmap->GetDrawScale(); }
    
  APIBitmap* GetAPIBitmap() const { return mAPIBitmap; }
 
  bool GetFramesAreHorizontal() const { return mFramesAreHorizontal; }
  
  const WDL_String& GetResourceName() const { return mResourceName; }
  
  inline bool IsValid() const { return mAPIBitmap != nullptr; }
 
private:
  APIBitmap* mAPIBitmap;
  int mW;
  int mH;
  int mN;
  bool mFramesAreHorizontal;
  WDL_String mResourceName;
};
 
#ifdef SVG_USE_SKIA
struct ISVG
{
  ISVG(sk_sp<SkSVGDOM> svgDom)
  : mSVGDom(svgDom)
  {
  }
  
  float W() const
  {
    assert(mSVGDom);
    return mSVGDom->containerSize().width();
  }
  
  float H() const
  {
    assert(mSVGDom);
    return mSVGDom->containerSize().height();
  }
  
  inline bool IsValid() const { return mSVGDom != nullptr; }
  
  sk_sp<SkSVGDOM> mSVGDom;
};
#else
struct ISVG
{  
  ISVG(NSVGimage* pImage)
  {
    mImage = pImage;
  }
  
  float W() const
  {
    assert(mImage);
    return mImage->width;
  }
 
  float H() const
  {
    assert(mImage);
    return mImage->height;
  }
  
  inline bool IsValid() const { return mImage != nullptr; }
  
  NSVGimage* mImage = nullptr;
};
#endif
 
struct IColor
{
  int A, R, G, B;
  
  IColor(int a = 255, int r = 0, int g = 0, int b = 0) : A(a), R(r), G(g), B(b) {}
 
  bool operator==(const IColor& rhs) { return (rhs.A == A && rhs.R == R && rhs.G == G && rhs.B == B); }
  bool operator!=(const IColor& rhs) { return !operator==(rhs); }
  
  void Set(int a = 255, int r = 0, int g = 0, int b = 0) { A = a; R = r; G = g; B = b; }
  
  bool Empty() const { return A == 0 && R == 0 && G == 0 && B == 0; }
  
  void Clamp() { A = Clip(A, 0, 255); R = Clip(R, 0, 255); G = Clip(G, 0, 255); B = Clip(B, 0, 255); }
  
  void Randomise(int alpha = 255) { A = alpha; R = std::rand() % 255; G = std::rand() % 255; B = std::rand() % 255; }
 
  void SetOpacity(float alpha)
  {
    A = static_cast<int>(Clip(alpha, 0.f, 1.f) * 255.f);
  }
 
  IColor WithOpacity(float alpha) const
  {
    IColor n = *this;
    n.SetOpacity(alpha);
    return n;
  }
 
  void Contrast(float c)
  {
    const int mod = static_cast<int>(c * 255.f);
    R = Clip(R += mod, 0, 255);
    G = Clip(G += mod, 0, 255);
    B = Clip(B += mod, 0, 255);
  }
 
  IColor WithContrast(float c) const
  {
    IColor n = *this;
    n.Contrast(c);
    return n;
  }
  
  void GetRGBf(float* rgbf) const
  {
    rgbf[0] = R / 255.f;
    rgbf[1] = G / 255.f;
    rgbf[2] = B / 255.f;
  }
 
  void GetRGBAf(float* rgbaf) const
  {
    rgbaf[0] = R / 255.f;
    rgbaf[1] = G / 255.f;
    rgbaf[2] = B / 255.f;
    rgbaf[3] = A / 255.f;
  }
 
  void GetHSLA(float& h, float& s, float& l, float& a) const
  {
    const float fR = R / 255.f;
    const float fG = G / 255.f;
    const float fB = B / 255.f;
    a = A / 255.f;
 
    const float fMin = std::min(fR, std::min(fG, fB));
    const float fMax = std::max(fR, std::max(fG, fB));
    const float fDiff = fMax - fMin;
    const float fSum = fMax + fMin;
 
    l = 50.f * fSum;
 
    if (fMin == fMax) { s = 0.f; h = 0.f; l /= 100.f; return; }
    else if (l < 50.f) { s = 100.f * fDiff / fSum; }
    else { s = 100.f * fDiff / (2.f - fDiff); }
 
    if (fMax == fR) { h = 60.f * (fG - fB) / fDiff; }
    if (fMax == fG) { h = 60.f * (fB - fR) / fDiff + 120.f; }
    if (fMax == fB) { h = 60.f * (fR - fG) / fDiff + 240.f; }
 
    if (h < 0.f) { h = h + 360.f; }
 
    h /= 360.f;
    s /= 100.f;
    l /= 100.f;
  }
 
  int GetLuminosity() const
  {
    int min = R < G ? (R < B ? R : B) : (G < B ? G : B);
    int max = R > G ? (R > B ? R : B) : (G > B ? G : B);
    return (min + max) / 2;
  };
  
  static IColor GetRandomColor(bool randomAlpha = false)
  {
    int A = randomAlpha ? std::rand() & 0xFF : 255;
    int R = std::rand() & 0xFF;
    int G = std::rand() & 0xFF;
    int B = std::rand() & 0xFF;
 
    return IColor(A, R, G, B);
  }
 
  static IColor FromRGBf(float* rgbf)
  {
    int A = 255;
    int R = static_cast<int>(rgbf[0] * 255.f);
    int G = static_cast<int>(rgbf[1] * 255.f);
    int B = static_cast<int>(rgbf[2] * 255.f);
    
    return IColor(A, R, G, B);
  }
  
  static IColor FromRGBAf(float* rgbaf)
  {
    int R = static_cast<int>(rgbaf[0] * 255.f);
    int G = static_cast<int>(rgbaf[1] * 255.f);
    int B = static_cast<int>(rgbaf[2] * 255.f);
    int A = static_cast<int>(rgbaf[3] * 255.f);
 
    return IColor(A, R, G, B);
  }
 
  static IColor FromColorCode(int colorCode, int A = 0xFF)
  {
    int R = (colorCode >> 16) & 0xFF;
    int G = (colorCode >> 8) & 0xFF;
    int B = colorCode & 0xFF;
 
    return IColor(A, R, G, B);
  }
  
  static IColor FromColorCodeStr(const char* hexStr)
  {
    WDL_String str(hexStr);
    
    if ((str.GetLength() == 7 || str.GetLength() == 9) && str.Get()[0] == '#')
    {
      str.DeleteSub(0, 1);
 
      return FromColorCode(static_cast<int>(std::stoul(str.Get(), nullptr, 16)));
    }
    else
    {
      assert(0 && "Invalid color code str, returning black");
      return IColor();
    }
  }
  
  int ToColorCode() const
  {
    return (R << 16) | (G << 8) | B;
  }
  
  void ToColorCodeStr(WDL_String& str, bool withAlpha = true) const
  {
    if (withAlpha)
      str.SetFormatted(32, "#%02x%02x%02x%02x", R, G, B, A);
    else
      str.SetFormatted(32, "#%02x%02x%02x", R, G, B);
  }
  
  static IColor FromHSLA(float h, float s, float l, float a = 1.f)
  {
    auto hue = [](float h, float m1, float m2) {
      if (h < 0) h += 1;
      if (h > 1) h -= 1;
      if (h < 1.0f / 6.0f)
        return m1 + (m2 - m1) * h * 6.0f;
      else if (h < 3.0f / 6.0f)
        return m2;
      else if (h < 4.0f / 6.0f)
        return m1 + (m2 - m1) * (2.0f / 3.0f - h) * 6.0f;
      return m1;
    };
 
    IColor col;
    h = std::fmodf(h, 1.0f);
    if (h < 0.0f) h += 1.0f;
    s = Clip(s, 0.0f, 1.0f);
    l = Clip(l, 0.0f, 1.0f);
    float m2 = l <= 0.5f ? (l * (1 + s)) : (l + s - l * s);
    float m1 = 2 * l - m2;
    col.R = static_cast<int>(Clip(hue(h + 1.0f / 3.0f, m1, m2), 0.0f, 1.0f) * 255.f);
    col.G = static_cast<int>(Clip(hue(h, m1, m2), 0.0f, 1.0f) * 255.f);
    col.B = static_cast<int>(Clip(hue(h - 1.0f / 3.0f, m1, m2), 0.0f, 1.0f) * 255.f);
    col.A = static_cast<int>(a * 255.f);
    return col;
  }
 
  static IColor LinearInterpolateBetween(const IColor& start, const IColor& dest, float progress)
  {
    IColor result;
    result.A = start.A + static_cast<int>(progress * static_cast<float>(dest.A -  start.A));
    result.R = start.R + static_cast<int>(progress * static_cast<float>(dest.R -  start.R));
    result.G = start.G + static_cast<int>(progress * static_cast<float>(dest.G -  start.G));
    result.B = start.B + static_cast<int>(progress * static_cast<float>(dest.B -  start.B));
    return result;
  }
};
 
const IColor COLOR_TRANSPARENT(0, 0, 0, 0);
const IColor COLOR_TRANSLUCENT(10, 0, 0, 0);
const IColor COLOR_BLACK(255, 0, 0, 0);
const IColor COLOR_BLACK_DROP_SHADOW(128, 0, 0, 0);
const IColor COLOR_GRAY(255, 127, 127, 127);
const IColor COLOR_LIGHT_GRAY(255, 240, 240, 240);
const IColor COLOR_MID_GRAY(255, 200, 200, 200);
const IColor COLOR_DARK_GRAY(255, 70, 70, 70);
const IColor COLOR_WHITE(255, 255, 255, 255);
const IColor COLOR_RED(255, 255, 0, 0);
const IColor COLOR_GREEN(255, 0, 255, 0);
const IColor COLOR_BLUE(255, 0, 0, 255);
const IColor COLOR_YELLOW(255, 255, 255, 0);
const IColor COLOR_ORANGE(255, 255, 127, 0);
const IColor COLOR_INDIGO(255, 75, 0, 130);
const IColor COLOR_VIOLET(255, 148, 0, 211);
 
static IColor GetRainbow(int colorIdx)
{
  switch (colorIdx) {
    case 0: return COLOR_RED;
    case 1: return COLOR_ORANGE;
    case 2: return COLOR_YELLOW;
    case 3: return COLOR_GREEN;
    case 4: return COLOR_BLUE;
    case 5: return COLOR_INDIGO;
    case 6: return COLOR_VIOLET;
    default:
      assert(0);
      return COLOR_WHITE;
  }
}
 
const IColor DEFAULT_GRAPHICS_BGCOLOR = COLOR_GRAY;
const IColor DEFAULT_BGCOLOR = COLOR_TRANSPARENT;
const IColor DEFAULT_FGCOLOR = COLOR_MID_GRAY;
const IColor DEFAULT_PRCOLOR = COLOR_LIGHT_GRAY;
 
const IColor DEFAULT_FRCOLOR = COLOR_DARK_GRAY;
const IColor DEFAULT_HLCOLOR = COLOR_TRANSLUCENT;
const IColor DEFAULT_SHCOLOR = IColor(60, 0, 0, 0);
const IColor DEFAULT_X1COLOR = COLOR_BLACK;
const IColor DEFAULT_X2COLOR = COLOR_GREEN;
const IColor DEFAULT_X3COLOR = COLOR_BLUE;
 
const IColor DEFAULT_TEXT_FGCOLOR = COLOR_BLACK;
const IColor DEFAULT_TEXTENTRY_BGCOLOR = COLOR_WHITE;
const IColor DEFAULT_TEXTENTRY_FGCOLOR = COLOR_BLACK;
 
struct IBlend
{
  EBlend mMethod;
  float mWeight;
 
  IBlend(EBlend type = EBlend::Default, float weight = 1.0f)
  : mMethod(type)
  , mWeight(Clip(weight, 0.f, 1.f))
  {}
};
 
inline float BlendWeight(const IBlend* pBlend)
{
  return (pBlend ? pBlend->mWeight : 1.0f);
}
 
const IBlend BLEND_75 = IBlend(EBlend::Default, 0.75f);
const IBlend BLEND_50 = IBlend(EBlend::Default, 0.5f);
const IBlend BLEND_25 = IBlend(EBlend::Default, 0.25f);
const IBlend BLEND_10 = IBlend(EBlend::Default, 0.1f);
const IBlend BLEND_05 = IBlend(EBlend::Default, 0.05f);
const IBlend BLEND_01 = IBlend(EBlend::Default, 0.01f);
const IBlend BLEND_DST_IN = IBlend(EBlend::DstIn, 1.f);
const IBlend BLEND_DST_OVER = IBlend(EBlend::DstOver, 1.f);
 
struct IFillOptions
{
  EFillRule mFillRule { EFillRule::Winding };
  bool mPreserve { false };
 
  IFillOptions(bool preserve = false, EFillRule fillRule = EFillRule::Winding)
  : mFillRule(fillRule)
  , mPreserve(preserve)
  {
  }
   
};
 
struct IStrokeOptions
{
  class DashOptions
  {
  public:
    DashOptions()
    : mOffset(0)
    , mCount(0)
    {}
 
    DashOptions(float* array, float offset, int count)
    {
      SetDash(array, offset, count);
    }
 
    int GetCount() const { return mCount; }
 
    float GetOffset() const { return mOffset; }
 
    const float* GetArray() const { return mArray; }
 
    void SetDash(float* pArray, float offset, int count)
    {
      assert(count >= 0 && count <= 8);
 
      mCount = count;
      mOffset = offset;
 
      for (int i = 0; i < count; i++)
        mArray[i] = pArray[i];
    }
 
  private:
    float mArray[8] = {};
    float mOffset;
    int mCount;
  };
 
  float mMiterLimit = 10.f;
  bool mPreserve = false;
  ELineCap mCapOption = ELineCap::Butt;
  ELineJoin mJoinOption = ELineJoin::Miter;
  DashOptions mDash;
};
 
static const char* TextStyleString(ETextStyle style)
{
  switch (style)
  {
    case ETextStyle::Bold: return "Bold";
    case ETextStyle::Italic: return "Italic";
    case ETextStyle::Normal:
    default:
      return "Regular";
  }
}
 
struct IText
{
  IText(float size = DEFAULT_TEXT_SIZE,
        const IColor& color = DEFAULT_TEXT_FGCOLOR,
        const char* fontID = nullptr,
        EAlign align = EAlign::Center,
        EVAlign valign = EVAlign::Middle,
        float angle = 0,
        const IColor& TEBGColor = DEFAULT_TEXTENTRY_BGCOLOR,
        const IColor& TEFGColor = DEFAULT_TEXTENTRY_FGCOLOR)
    : mSize(size)
    , mFGColor(color)
    , mTextEntryBGColor(TEBGColor)
    , mTextEntryFGColor(TEFGColor)
    , mAngle(angle)
    , mAlign(align)
    , mVAlign(valign)
  {
    strcpy(mFont, (fontID ? fontID : DEFAULT_FONT));
  }
 
  IText(float size, EVAlign valign, const IColor& color = DEFAULT_TEXT_FGCOLOR)
  : IText()
  {
    mSize = size;
    mVAlign = valign;
    mFGColor = color;
  }
  
  IText(float size, EAlign align, const IColor& color = DEFAULT_TEXT_FGCOLOR)
  : IText()
  {
    mSize = size;
    mAlign = align;
    mFGColor = color;
  }
  
  IText(float size, const char* fontID)
  : IText()
  {
    mSize = size;
    strcpy(mFont, (fontID ? fontID : DEFAULT_FONT));
  }
  
  IText WithFGColor(const IColor& fgColor) const { IText newText = *this; newText.mFGColor = fgColor; return newText; }
  IText WithTEColors(const IColor& teBgColor, const IColor& teFgColor) const { IText newText = *this; newText.mTextEntryBGColor = teBgColor; newText.mTextEntryFGColor = teFgColor; return newText; }
  IText WithAlign(EAlign align) const { IText newText = *this; newText.mAlign = align; return newText; }
  IText WithVAlign(EVAlign valign) const { IText newText = *this; newText.mVAlign = valign; return newText; }
  IText WithSize(float size) const { IText newText = *this; newText.mSize = size; return newText; }
  IText WithAngle(float v) const { IText newText = *this; newText.mAngle = v; return newText; }
  IText WithFont(const char* fontID) const { IText newText = *this; strcpy(newText.mFont, (fontID ? fontID : DEFAULT_FONT));; return newText; }
  
  char mFont[FONT_LEN];
  float mSize;
  IColor mFGColor;
  IColor mTextEntryBGColor;
  IColor mTextEntryFGColor;
  float mAngle = 0.f; // Degrees ccwise from normal.
  EAlign mAlign = EAlign::Near;
  EVAlign mVAlign = EVAlign::Middle;
};
 
const IText DEFAULT_TEXT = IText();
 
struct IRECT
{
  float L, T, R, B;
 
  IRECT()
  {
    L = T = R = B = 0.f;
  }
  
  IRECT(float l, float t, float r, float b)
  : L(l), T(t), R(r), B(b)
  {}
  
  IRECT(float x, float y, const IBitmap& bitmap)
  {
    L = x;
    T = y;
    R = L + (float) bitmap.FW();
    B = T + (float) bitmap.FH();
  }
 
  static IRECT MakeXYWH(float l, float t, float w, float h)
  {
    return IRECT(l, t, l+w, t+h);
  }
  
  static IRECT MakeMidXYWH(float x, float y, float w, float h)
  {
    return IRECT(x-(w/2.0f), y-(h/2.0f), x+(w/2.0f), y+(h/2.0f));
  }
  
  bool Empty() const
  {
    return (L == 0.f && T == 0.f && R == 0.f && B == 0.f);
  }
 
  void Clear()
  {
    L = T = R = B = 0.f;
  }
  
  bool operator==(const IRECT& rhs) const
  {
    return (L == rhs.L && T == rhs.T && R == rhs.R && B == rhs.B);
  }
 
  bool operator!=(const IRECT& rhs) const
  {
    return !(*this == rhs);
  }
 
  inline float W() const { return R - L; }
 
  inline float H() const { return B - T; }
 
  inline float MW() const { return 0.5f * (L + R); }
 
  inline float MH() const { return 0.5f * (T + B); }
 
  inline float Area() const { return W() * H(); }
  
  inline IRECT Union(const IRECT& rhs) const
  {
    if (Empty()) { return rhs; }
    if (rhs.Empty()) { return *this; }
    return IRECT(std::min(L, rhs.L), std::min(T, rhs.T), std::max(R, rhs.R), std::max(B, rhs.B));
  }
 
  inline IRECT Intersect(const IRECT& rhs) const
  {
    if (Intersects(rhs))
      return IRECT(std::max(L, rhs.L), std::max(T, rhs.T), std::min(R, rhs.R), std::min(B, rhs.B));
 
    return IRECT();
  }
 
  inline bool Intersects(const IRECT& rhs) const
  {
    return (!Empty() && !rhs.Empty() && R >= rhs.L && L < rhs.R && B >= rhs.T && T < rhs.B);
  }
 
  inline bool Contains(const IRECT& rhs) const
  {
    return (!Empty() && !rhs.Empty() && rhs.L >= L && rhs.R <= R && rhs.T >= T && rhs.B <= B);
  }
 
  inline bool Contains(float x, float y) const
  {
    return (!Empty() && x >= L && x < R && y >= T && y < B);
  }
  
  inline bool ContainsEdge(float x, float y) const
  {
    return (!Empty() && x >= L && x <= R && y >= T && y <= B);
  }
 
  inline void Constrain(float& x, float& y) const
  {
    if (x < L) x = L;
    else if (x > R) x = R;
 
    if (y < T) y = T;
    else if (y > B) y = B;
  }
  
  IRECT Inset(const IRECT& rhs) const
  {
    return IRECT(L + rhs.L, T + rhs.T, L + rhs.R, T + rhs.B);
  }
  
  bool Mergeable(const IRECT& rhs) const
  {
    if (Empty() || rhs.Empty())
      return true;
    if (L == rhs.L && R == rhs.R && ((T >= rhs.T && T <= rhs.B) || (rhs.T >= T && rhs.T <= B)))
      return true;
    return T == rhs.T && B == rhs.B && ((L >= rhs.L && L <= rhs.R) || (rhs.L >= L && rhs.L <= R));
  }
  
  inline IRECT FracRect(EDirection layoutDir, float frac, bool fromTopOrRight = false) const
  {
    if(layoutDir == EDirection::Vertical)
      return FracRectVertical(frac, fromTopOrRight);
    else
      return FracRectHorizontal(frac, fromTopOrRight);
  }
  
  inline IRECT FracRectHorizontal(float frac, bool rhs = false) const
  {
    float widthOfSubRect = W() * frac;
    
    if(rhs)
      return IRECT(R - widthOfSubRect, T, R, B);
    else
      return IRECT(L, T, L + widthOfSubRect, B);
  }
  
  inline IRECT FracRectVertical(float frac, bool fromTop = false) const
  {
    float heightOfSubRect = H() * frac;
 
    if(fromTop)
      return IRECT(L, T, R, T + heightOfSubRect);
    else
      return IRECT(L, B - heightOfSubRect, R, B);
  }
 
  inline IRECT SubRectVertical(int numSlices, int sliceIdx) const
  {
    float heightOfSubRect = H() / (float) numSlices;
    float t = heightOfSubRect * (float) sliceIdx;
 
    return IRECT(L, T + t, R, T + t + heightOfSubRect);
  }
 
  inline IRECT SubRectHorizontal(int numSlices, int sliceIdx) const
  {
    float widthOfSubRect = W() / (float) numSlices;
    float l = widthOfSubRect * (float) sliceIdx;
 
    return IRECT(L + l, T, L + l + widthOfSubRect, B);
  }
  
  inline IRECT SubRect(EDirection layoutDir, int numSlices, int sliceIdx) const
  {
    if(layoutDir == EDirection::Vertical)
      return SubRectVertical(numSlices, sliceIdx);
    else
      return SubRectHorizontal(numSlices, sliceIdx);
  }
  
  inline IRECT GetFromTLHC(float w, float h) const { return IRECT(L, T, L+w, T+h); }
 
  inline IRECT GetFromBLHC(float w, float h) const { return IRECT(L, B-h, L+w, B); }
 
  inline IRECT GetFromTRHC(float w, float h) const { return IRECT(R-w, T, R, T+h); }
 
  inline IRECT GetFromBRHC(float w, float h) const { return IRECT(R-w, B-h, R, B); }
 
  inline IRECT GetFromTop(float amount) const { return IRECT(L, T, R, T+amount); }
 
  inline IRECT GetFromBottom(float amount) const { return IRECT(L, B-amount, R, B); }
 
  inline IRECT GetFromLeft(float amount) const { return IRECT(L, T, L+amount, B); }
 
  inline IRECT GetFromRight(float amount) const { return IRECT(R-amount, T, R, B); }
  
  inline IRECT GetReducedFromTop(float amount) const { return IRECT(L, T+amount, R, B); }
 
  inline IRECT GetReducedFromBottom(float amount) const { return IRECT(L, T, R, B-amount); }
 
  inline IRECT GetReducedFromLeft(float amount) const { return IRECT(L+amount, T, R, B); }
 
  inline IRECT GetReducedFromRight(float amount) const { return IRECT(L, T, R-amount, B); }
  
  inline IRECT ReduceFromTop(float amount) { IRECT r = GetFromTop(amount); T+=amount; return r; }
  
  inline IRECT ReduceFromBottom(float amount) { IRECT r = GetFromBottom(amount); B-=amount; return r; }
  
  inline IRECT ReduceFromLeft(float amount) { IRECT r = GetFromLeft(amount); L+=amount; return r; }
  
  inline IRECT ReduceFromRight(float amount) { IRECT r = GetFromRight(amount); R-=amount; return r; }
  
  inline IRECT GetGridCell(int row, int col, int nRows, int nColumns/*, EDirection = EDirection::Horizontal*/) const
  {
    assert(row * col <= nRows * nColumns); // not enough cells !
    
    const IRECT vrect = SubRectVertical(nRows, row);
    return vrect.SubRectHorizontal(nColumns, col);
  }
  
  inline IRECT GetGridCell(int cellIndex, int nRows, int nColumns, EDirection dir = EDirection::Horizontal, int nCells = 1) const
  {
    assert(cellIndex <= nRows * nColumns); // not enough cells !
 
    int cell = 0;
    
    if(dir == EDirection::Horizontal)
    {
      for(int row = 0; row < nRows; row++)
      {
        for(int col = 0; col < nColumns; col++)
        {
          if(cell == cellIndex)
          {
            const IRECT vrect = SubRectVertical(nRows, row);
            IRECT rect = vrect.SubRectHorizontal(nColumns, col);
 
            for (int n = 1; n < nCells && (col + n) < nColumns; n++)
            {
              rect = rect.Union(vrect.SubRectHorizontal(nColumns, col + n));
            }
            return rect;
          }
 
          cell++;
        }
      }
    }
    else
    {
      for(int col = 0; col < nColumns; col++)
      {
        for(int row = 0; row < nRows; row++)
        {
          if(cell == cellIndex)
          {
            const IRECT hrect = SubRectHorizontal(nColumns, col);
            IRECT rect = hrect.SubRectVertical(nRows, row);;
 
            for (int n = 1; n < nCells && (row + n) < nRows; n++)
            {
              rect = rect.Union(hrect.SubRectVertical(nRows, row + n));
            }
            return rect;
          }
          
          cell++;
        }
      }
    }
    
    return *this;
  }
  
  bool IsPixelAligned() const
  {
    // If all values are within 1/1000th of a pixel of an integer the IRECT is considered pixel aligned
      
    auto isInteger = [](float x){ return std::fabs(x - std::round(x)) <= static_cast<float>(1e-3); };
      
    return isInteger(L) && isInteger(T) && isInteger(R) && isInteger(B);
  }
  
  bool IsPixelAligned(float scale) const
  {
    IRECT r = *this;
    r.Scale(scale);
    return r.IsPixelAligned();
  }
  
  inline void PixelAlign() 
  {
    L = std::floor(L);
    T = std::floor(T);
    R = std::ceil(R);
    B = std::ceil(B);
  }
 
  inline void PixelAlign(float scale)
  {
    // N.B. - double precision is *required* for accuracy of the reciprocal
    Scale(scale);
    PixelAlign();
    Scale(static_cast<float>(1.0/static_cast<double>(scale)));
  }
 
  inline IRECT GetPixelAligned() const
  {
    IRECT r = *this;
    r.PixelAlign();
    return r;
  }
  
  inline IRECT GetPixelAligned(float scale) const
  {
    IRECT r = *this;
    r.PixelAlign(scale);
    return r;
  }
    
  inline void PixelSnap()
  {
    L = std::round(L);
    T = std::round(T);
    R = std::round(R);
    B = std::round(B);
  }
  
  inline void PixelSnap(float scale)
  {
    // N.B. - double precision is *required* for accuracy of the reciprocal
    Scale(scale);
    PixelSnap();
    Scale(static_cast<float>(1.0/static_cast<double>(scale)));
  }
  
  inline IRECT GetPixelSnapped() const
  {
    IRECT r = *this;
    r.PixelSnap();
    return r;
  }
  
  inline IRECT GetPixelSnapped(float scale) const
  {
    IRECT r = *this;
    r.PixelSnap(scale);
    return r;
  }
  
  inline void Pad(float padding)
  {
    L -= padding;
    T -= padding;
    R += padding;
    B += padding;
  }
  
  inline void Pad(float padL, float padT, float padR, float padB)
  {
    L -= padL;
    T -= padT;
    R += padR;
    B += padB;
  }
  
  inline void HPad(float padding)
  {
    L -= padding;
    R += padding;
  }
  
  inline void VPad(float padding)
  {
    T -= padding;
    B += padding;
  }
  
  inline void MidHPad(float padding)
  {
    const float mw = MW();
    L = mw - padding;
    R = mw + padding;
  }
  
  inline void MidVPad(float padding)
  {
    const float mh = MH();
    T = mh - padding;
    B = mh + padding;
  }
 
  inline IRECT GetPadded(float padding) const
  {
    return IRECT(L-padding, T-padding, R+padding, B+padding);
  }
 
  inline IRECT GetPadded(float padL, float padT, float padR, float padB) const
  {
    return IRECT(L-padL, T-padT, R+padR, B+padB);
  }
 
  inline IRECT GetHPadded(float padding) const
  {
    return IRECT(L-padding, T, R+padding, B);
  }
 
  inline IRECT GetVPadded(float padding) const
  {
    return IRECT(L, T-padding, R, B+padding);
  }
 
  inline IRECT GetMidHPadded(float padding) const
  {
    return IRECT(MW()-padding, T, MW()+padding, B);
  }
 
  inline IRECT GetMidVPadded(float padding) const
  {
    return IRECT(L, MH()-padding, R, MH()+padding);
  }
 
  inline IRECT GetHSliced(float w, bool rhs = false) const
  {
    if(rhs)
      return IRECT(R - w, T, R, B);
    else
      return IRECT(L, T, L + w, B);
  }
  
  inline IRECT GetVSliced(float h, bool bot = false) const
  {
    if(bot)
      return IRECT(L, B - h, R, B);
    else
      return IRECT(L, T, R, T + h);
  }
  
  void Clank(const IRECT& rhs)
  {
    if (L < rhs.L)
    {
      R = std::min(rhs.R - 1, R + rhs.L - L);
      L = rhs.L;
    }
    if (T < rhs.T)
    {
      B = std::min(rhs.B - 1, B + rhs.T - T);
      T = rhs.T;
    }
    if (R >= rhs.R)
    {
      L = std::max(rhs.L, L - (R - rhs.R + 1));
      R = rhs.R - 1;
    }
    if (B >= rhs.B)
    {
      T = std::max(rhs.T, T - (B - rhs.B + 1));
      B = rhs.B - 1;
    }
  }
  
  void Scale(float scale)
  {
    L *= scale;
    T *= scale;
    R *= scale;
    B *= scale;
  }
  
  void ScaleAboutCentre(float scale)
  {
    float x = MW();
    float y = MH();
    float hw = W() / 2.f;
    float hh = H() / 2.f;
    L = x - (hw * scale);
    T = y - (hh * scale);
    R = x + (hw * scale);
    B = y + (hh * scale);
  }
 
  IRECT GetScaled(float scale) const
  {
    IRECT r = *this;
    r.Scale(scale);
    return r;
  }
  
  IRECT GetScaledAboutCentre(float scale) const
  {
    IRECT r = *this;
    r.ScaleAboutCentre(scale);
    return r;
  }
  
  static IRECT LinearInterpolateBetween(const IRECT& start, const IRECT& dest, float progress)
  {
    IRECT result;
    result.L = start.L + progress * (dest.L -  start.L);
    result.T = start.T + progress * (dest.T -  start.T);
    result.R = start.R + progress * (dest.R -  start.R);
    result.B = start.B + progress * (dest.B -  start.B);
    return result;
  }
 
  void GetRandomPoint(float& x, float& y) const
  {
    const float r1 = static_cast<float>(std::rand()/(static_cast<float>(RAND_MAX)+1.f));
    const float r2 = static_cast<float>(std::rand()/(static_cast<float>(RAND_MAX)+1.f));
 
    x = L + r1 * W();
    y = T + r2 * H();
  }
 
  IRECT GetRandomSubRect() const
  {
    float l, t, r, b;
    GetRandomPoint(l, t);
    IRECT tmp = IRECT(l, t, R, B);
    tmp.GetRandomPoint(r, b);
 
    return IRECT(l, t, r, b);
  }
 
  void Offset(float l, float t, float r, float b)
  {
    L += l;
    T += t;
    R += r;
    B += b;
  }
  
  IRECT GetOffset(float l, float t, float r, float b) const
  {
    return IRECT(L + l, T + t, R + r, B + b);
  }
  
  void Translate(float x, float y)
  {
    L += x;
    T += y;
    R += x;
    B += y;
  }
  
  IRECT GetTranslated(float x, float y) const
  {
    return IRECT(L + x, T + y, R + x, B + y);
  }
  
  IRECT GetHShifted(float x) const
  {
    return GetTranslated(x, 0.f);
  }
  
  IRECT GetVShifted(float y) const
  {
    return GetTranslated(0.f, y);
  }
 
  IRECT GetCentredInside(const IRECT& sr) const
  {
    IRECT r;
    r.L = MW() - sr.W() / 2.f;
    r.T = MH() - sr.H() / 2.f;
    r.R = r.L + sr.W();
    r.B = r.T + sr.H();
 
    return r;
  }
  
  IRECT GetCentredInside(float w, float h = 0.f) const
  {
    w = std::max(w, 1.f);
    
    if(h <= 0.f)
      h = w;
    
    IRECT r;
    r.L = MW() - w / 2.f;
    r.T = MH() - h / 2.f;
    r.R = r.L + w;
    r.B = r.T + h;
    
    return r;
  }
 
  IRECT GetCentredInside(const IBitmap& bitmap) const
  {
    IRECT r;
    r.L = MW() - bitmap.FW() / 2.f;
    r.T = MH() - bitmap.FH() / 2.f;
    r.R = r.L + (float) bitmap.FW();
    r.B = r.T + (float) bitmap.FH();
 
    return r;
  }
  
  void VAlignTo(const IRECT& sr, EVAlign align)
  {
    const float height = H();
    switch (align)
    {
      case EVAlign::Top: T = sr.T; B = sr.T + height; break;
      case EVAlign::Bottom: T = sr.B - height; B = sr.B; break;
      case EVAlign::Middle: T = sr.T + (sr.H() * 0.5f) - (height * 0.5f); B = sr.T + (sr.H() * 0.5f) - (height * 0.5f) + height; break;
    }
  }
  
  void HAlignTo(const IRECT& sr, EAlign align)
  {
    const float width = W();
    switch (align)
    {
      case EAlign::Near: L = sr.L; R = sr.L + width; break;
      case EAlign::Far: L = sr.R - width; R = sr.R; break;
      case EAlign::Center: L = sr.L + (sr.W() * 0.5f) - (width * 0.5f); R = sr.L + (sr.W() * 0.5f) - (width * 0.5f) + width; break;
    }
  }
 
  IRECT GetVAlignedTo(const IRECT& sr, EVAlign align) const
  {
    IRECT result = *this;
    result.VAlignTo(sr, align);
    return result;
  }
  
  float GetLengthOfShortestSide() const
  {
    if(W() < H())
       return W();
    else
      return H();
  }
    
  IRECT GetHAlignedTo(const IRECT& sr, EAlign align) const
  {
    IRECT result = *this;
    result.HAlignTo(sr, align);
    return result;
  }
  
  void DBGPrint() { DBGMSG("L: %f, T: %f, R: %f, B: %f,: W: %f, H: %f\n", L, T, R, B, W(), H()); }
};
 
struct IMouseMod
{
  bool L, R, S, C, A;
  ITouchID touchID = 0;
  float touchRadius = 0.f;
  
  IMouseMod(bool l = false, bool r = false, bool s = false, bool c = false, bool a = false, ITouchID touchID = 0)
  : L(l), R(r), S(s), C(c), A(a), touchID(touchID)
  {}
 
  bool IsTouch() const { return touchID > 0; }
 
  void DBGPrint() { DBGMSG("L: %i, R: %i, S: %i, C: %i,: A: %i\n", L, R, S, C, A); }
};
 
struct IMouseInfo
{
  float x = 0.0, y = 0.0;
  float dX = 0.0, dY = 0.0;
  IMouseMod ms;
};
 
struct IGestureInfo
{
  float x = 0.f;
  float y = 0.f;
  float scale = 0.f; // pinch,
  float velocity = 0.f; // pinch, rotate
  float angle = 0.f; // rotate,
  EGestureState state = EGestureState::Unknown;
  EGestureType type = EGestureType::Unknown;
};
 
class IRECTList
{
public:
  IRECTList()
  {}
  
  IRECTList(const IRECTList&) = delete;
  IRECTList& operator=(const IRECTList&) = delete;
 
  int Size() const { return mRects.GetSize(); }
  
  void Add(const IRECT& rect)
  {
    mRects.Add(rect);
  }
  
  void Set(int idx, const IRECT& rect)
  {
    *(mRects.GetFast() + idx) = rect;
  }
  
  const IRECT& Get(int idx) const
  {
    return *(mRects.GetFast() + idx);
  }
  
  void Clear()
  {
    mRects.Resize(0);
  }
  
  IRECT Bounds()
  {
    IRECT r = Get(0);
    for (auto i = 1; i < mRects.GetSize(); i++)
      r = r.Union(Get(i));
    return r;
  }
  
  void PixelAlign()
  {
    for (auto i = 0; i < Size(); i++)
    {
      IRECT r = Get(i);
      r.PixelAlign();
      Set(i, r);
    }
  }
 
  void PixelAlign(float scale)
  {
    for (auto i = 0; i < Size(); i++)
    {
      IRECT r = Get(i);
      r.PixelAlign(scale);
      Set(i, r);
    }
  }
  
  int Find(float x, float y) const
  {
    for (auto i = 0; i < Size(); i++)
    {
      if(Get(i).Contains(x, y))
        return i;
    }
    
    return -1;
  }
  
  static bool GetFracGrid(const IRECT& input, IRECTList& rects, const std::initializer_list<float>& rowFractions, const std::initializer_list<float>& colFractions, EDirection layoutDir = EDirection::Horizontal)
  {
    IRECT spaceLeft = input;
    float y = 0.;
    float x = 0.;
 
    if(std::accumulate(rowFractions.begin(), rowFractions.end(), 0.f) != 1.)
      return false;
    
    if(std::accumulate(colFractions.begin(), colFractions.end(), 0.f) != 1.)
      return false;
 
    if (layoutDir == EDirection::Horizontal)
    {
      for (auto& rowFrac : rowFractions)
      {
        IRECT thisRow = input.FracRectVertical(rowFrac, true).GetTranslated(0, y);
        
        x = 0.;
 
        for (auto& colFrac : colFractions)
        {
          IRECT thisCell = thisRow.FracRectHorizontal(colFrac).GetTranslated(x, 0);
          
          rects.Add(thisCell);
          
          x += thisCell.W();
        }
        
        spaceLeft.Intersect(thisRow);
        
        y = rects.Bounds().H();
      }
    }
    
    if (layoutDir == EDirection::Vertical)
    {
      for (auto& colFrac : colFractions)
      {
        IRECT thisCol = input.FracRectHorizontal(colFrac).GetTranslated(x, 0);
        
        y = 0.;
 
        for (auto& rowFrac : rowFractions)
        {
          IRECT thisCell = thisCol.FracRectVertical(rowFrac, true).GetTranslated(0, y);
          
          rects.Add(thisCell);
          
          y += thisCell.H();
        }
        
        spaceLeft.Intersect(thisCol);
        
        x = rects.Bounds().W();
      }
    }
    
    return true;
  }
  
  void Optimize()
  {
    for (int i = 0; i < Size(); i++)
    {
      for (int j = i + 1; j < Size(); j++)
      {
        if (Get(i).Contains(Get(j)))
        {
          mRects.Delete(j);
          j--;
        }
        else if (Get(j).Contains(Get(i)))
        {
          mRects.Delete(i);
          i--;
          break;
        }
        else if (Get(i).Intersects(Get(j)))
        {
          IRECT intersection = Get(i).Intersect(Get(j));
            
          if (Get(i).Mergeable(intersection))
            Set(i, Shrink(Get(i), intersection));
          else if (Get(j).Mergeable(intersection))
            Set(j, Shrink(Get(j), intersection));
          else if (Get(i).Area() < Get(j).Area())
            Set(i, Split(Get(i), intersection));
          else
            Set(j, Split(Get(j), intersection));
        }
      }
    }
    
    for (int i = 0; i < Size(); i++)
    {
      for (int j = i + 1; j < Size(); j++)
      {
        if (Get(i).Mergeable(Get(j)))
        {
          Set(j, Get(i).Union(Get(j)));
          mRects.Delete(i);
          i = -1;
          break;
        }
      }
    }
  }
  
private:
  IRECT Shrink(const IRECT &r, const IRECT &i)
  {
    if (i.L != r.L)
      return IRECT(r.L, r.T, i.L, r.B);
    if (i.T != r.T)
      return IRECT(r.L, r.T, r.R, i.T);
    if (i.R != r.R)
      return IRECT(i.R, r.T, r.R, r.B);
    return IRECT(r.L, i.B, r.R, r.B);
  }
  
  IRECT Split(const IRECT r, const IRECT &i)
  {
    if (r.L == i.L)
    {
      if (r.T == i.T)
      {
        Add(IRECT(i.R, r.T, r.R, i.B));
        return IRECT(r.L, i.B, r.R, r.B);
      }
      else
      {
        Add(IRECT(r.L, r.T, r.R, i.T));
        return IRECT(i.R, i.T, r.R, r.B);
      }
    }
    
    if (r.T == i.T)
    {
      Add(IRECT(r.L, r.T, i.L, i.B));
      return IRECT(r.L, i.B, r.R, r.B);
    }
    else
    {
      Add(IRECT(r.L, r.T, r.R, i.T));
      return IRECT(r.L, i.T, i.L, r.B);
    }
  }
  
  WDL_TypedBuf<IRECT> mRects;
};
 
struct IMatrix
{
  IMatrix(double xx, double yx, double xy, double yy, double tx, double ty)
  : mXX(xx), mYX(yx), mXY(xy), mYY(yy), mTX(tx), mTY(ty)
  {}
  
  IMatrix() : IMatrix(1.0, 0.0, 0.0, 1.0, 0.0, 0.0)
  {}
  
  IMatrix& Translate(float x, float y)
  {
    return Transform(IMatrix(1.0, 0.0, 0.0, 1.0, x, y));
  }
  
  IMatrix& Scale(float x, float y)
  {
    return Transform(IMatrix(x, 0.0, 0.0, y, 0.0, 0.0));
  }
  
  IMatrix& Rotate(float a)
  {
    const double rad = DegToRad(a);
    const double c = std::cos(rad);
    const double s = std::sin(rad);
    
    return Transform(IMatrix(c, s, -s, c, 0.0, 0.0));
  }
  
  IMatrix& Skew(float xa, float ya)
  {
    return Transform(IMatrix(1.0, std::tan(DegToRad(ya)), std::tan(DegToRad(xa)), 1.0, 0.0, 0.0));
  }
  
  void TransformPoint(double& x, double& y, double x0, double y0) const
  {
    x = x0 * mXX + y0 * mXY + mTX;
    y = x0 * mYX + y0 * mYY + mTY;
  };
  
  void TransformPoint(double& x, double& y) const
  {
    TransformPoint(x, y, x, y);
  };
  
  IMatrix& Transform(const IRECT& before, const IRECT& after)
  {
    const double sx = after.W() / before.W();
    const double sy = after.H() / before.H();
    const double tx = after.L - before.L * sx;
    const double ty = after.T - before.T * sy;
    
    return *this = IMatrix(sx, 0.0, 0.0, sy, tx, ty);
  }
  
  IMatrix& Transform(const IMatrix& m)
  {
    IMatrix p = *this;
    
    mXX = m.mXX * p.mXX + m.mYX * p.mXY;
    mYX = m.mXX * p.mYX + m.mYX * p.mYY;
    mXY = m.mXY * p.mXX + m.mYY * p.mXY;
    mYY = m.mXY * p.mYX + m.mYY * p.mYY;
    mTX = m.mTX * p.mXX + m.mTY * p.mXY + p.mTX;
    mTY = m.mTX * p.mYX + m.mTY * p.mYY + p.mTY;
    
    return *this;
  }
  
  IMatrix& Invert()
  {
    IMatrix m = *this;
    
    double d = 1.0 / (m.mXX * m.mYY - m.mYX * m.mXY);
    
    mXX =  m.mYY * d;
    mYX = -m.mYX * d;
    mXY = -m.mXY * d;
    mYY =  m.mXX * d;
    mTX = (-(m.mTX * mXX) - (m.mTY * mXY));
    mTY = (-(m.mTX * mYX) - (m.mTY * mYY));
    
    return *this;
  }
  
  double mXX, mYX, mXY, mYY, mTX, mTY;
};
 
struct IColorStop
{
  IColorStop()
  : mOffset(0.f)
  {}
  
  IColorStop(IColor color, float offset)
  : mColor(color)
  , mOffset(offset)
  {
    assert(offset >= 0.0 && offset <= 1.0);
  }
  
  IColor mColor;
  float mOffset;
};
 
struct IPattern
{
  EPatternType mType;
  EPatternExtend mExtend;
  IColorStop mStops[16];
  int mNStops;
  IMatrix mTransform;
  
  IPattern(EPatternType type)
  : mType(type), mExtend(EPatternExtend::Pad), mNStops(0)
  {}
  
  IPattern(const IColor& color)
  : mType(EPatternType::Solid), mExtend(EPatternExtend::Pad), mNStops(1)
  {
    mStops[0] = IColorStop(color, 0.0);
  }
  
  static IPattern CreateLinearGradient(float x1, float y1, float x2, float y2, const std::initializer_list<IColorStop>& stops = {})
  {
    IPattern pattern(EPatternType::Linear);
    
    // Calculate the affine transform from one line segment to another!
    const double xd = double(x2 - x1);
    const double yd = double(y2 - y1);
    const double d = sqrt(xd * xd + yd * yd);
    const double a = atan2(xd, yd);
    const double s = std::sin(a) / d;
    const double c = std::cos(a) / d;
      
    const double x0 = -(x1 * c - y1 * s);
    const double y0 = -(x1 * s + y1 * c);
    
    pattern.SetTransform(static_cast<float>(c),
                         static_cast<float>(s),
                         static_cast<float>(-s),
                         static_cast<float>(c),
                         static_cast<float>(x0),
                         static_cast<float>(y0));
    
    for (auto& stop : stops)
      pattern.AddStop(stop.mColor, stop.mOffset);
    
    return pattern;
  }
  
  static IPattern CreateLinearGradient(const IRECT& bounds, EDirection direction, const std::initializer_list<IColorStop>& stops = {})
  {
    float x1, y1, x2, y2;
    
    if(direction == EDirection::Horizontal)
    {
      y1 = bounds.MH(); y2 = y1;
      x1 = bounds.L;
      x2 = bounds.R;
    }
    else//(direction == EDirection::Vertical)
    {
      x1 = bounds.MW(); x2 = x1;
      y1 = bounds.T;
      y2 = bounds.B;
    }
    
    return CreateLinearGradient(x1, y1, x2, y2, stops);
  }
  
  static IPattern CreateRadialGradient(float x1, float y1, float r, const std::initializer_list<IColorStop>& stops = {})
  {
    IPattern pattern(EPatternType::Radial);
    
    const float s = 1.f / r;
 
    pattern.SetTransform(s, 0, 0, s, -(x1 * s), -(y1 * s));
    
    for (auto& stop : stops)
      pattern.AddStop(stop.mColor, stop.mOffset);
    
    return pattern;
  }
 
  static IPattern CreateSweepGradient(float x1, float y1, const std::initializer_list<IColorStop>& stops = {},
    float angleStart = 0.f, float angleEnd = 360.f)
  {
    IPattern pattern(EPatternType::Sweep);
 
    #ifdef IGRAPHICS_SKIA
      angleStart -= 90;
      angleEnd -= 90;
    #endif
 
    float rad = DegToRad(angleStart);
    float c = std::cos(rad);
    float s = std::sin(rad);
 
    pattern.SetTransform(c, s, -s, c, -x1, -y1);
 
    for (auto& stop : stops)
    {
      pattern.AddStop(stop.mColor, stop.mOffset * (angleEnd - angleStart) / 360.f);
    }
    return pattern;
  }
  
  int NStops() const
  {
    return mNStops;
  }
  
  const IColorStop& GetStop(int idx) const
  {
    return mStops[idx];
  }
  
  void AddStop(IColor color, float offset)
  {
    assert(mType != EPatternType::Solid && mNStops < 16);
    assert(!mNStops || GetStop(mNStops - 1).mOffset < offset);
    if (mNStops < 16)
      mStops[mNStops++] = IColorStop(color, offset);
  }
  
  void SetTransform(float xx, float yx, float xy, float yy, float tx, float ty)
  {
    mTransform = IMatrix(xx, yx, xy, yy, tx, ty);
  }
  
  void SetTransform(const IMatrix& transform)
  {
    mTransform = transform;
  }
};
 
class ILayer
{
  friend IGraphics;
  
public:
  ILayer(APIBitmap* pBitmap, const IRECT& layerRect, IControl* pControl, const IRECT& controlRect)
  : mBitmap(pBitmap)
  , mControl(pControl)
  , mControlRECT(controlRect)
  , mRECT(layerRect)
  , mInvalid(false)
  {}
 
  ILayer(const ILayer&) = delete;
  ILayer operator=(const ILayer&) = delete;
  
  void Invalidate() { mInvalid = true; }
 
  const APIBitmap* GetAPIBitmap() const { return mBitmap.get(); }
 
  IBitmap GetBitmap() const { return IBitmap(mBitmap.get(), 1, false); }
 
  const IRECT& Bounds() const { return mRECT; }
  
private:
  std::unique_ptr<APIBitmap> mBitmap;
  IControl* mControl;
  IRECT mControlRECT;
  IRECT mRECT;
  bool mInvalid;
};
 
using ILayerPtr = std::unique_ptr<ILayer>;
 
struct IShadow
{
  IShadow() {}
 
  IShadow(const IPattern& pattern, float blurSize, float xOffset, float yOffset, float opacity, bool drawForeground = true)
  : mPattern(pattern)
  , mBlurSize(blurSize)
  , mXOffset(xOffset)
  , mYOffset(yOffset)
  , mOpacity(opacity)
  , mDrawForeground(drawForeground)
  {}
  
  IPattern mPattern = COLOR_BLACK;
  float mBlurSize = 0.f;
  float mXOffset = 0.f;
  float mYOffset = 0.f;
  float mOpacity = 1.f;
  bool mDrawForeground = true;
};
 
struct IVColorSpec
{
  IColor mColors[kNumVColors];
  
  const IColor& GetColor(EVColor color) const
  {
    return mColors[(int) color];
  }
  
  static const IColor& GetDefaultColor(EVColor idx)
  {
    switch(idx)
    {
      case kBG: return DEFAULT_BGCOLOR; // Background
      case kFG: return DEFAULT_FGCOLOR; // OFF/Foreground
      case kPR: return DEFAULT_PRCOLOR; // ON/Pressed
      case kFR: return DEFAULT_FRCOLOR; // Frame
      case kHL: return DEFAULT_HLCOLOR; // Highlight
      case kSH: return DEFAULT_SHCOLOR; // Shadow
      case kX1: return DEFAULT_X1COLOR; // Extra 1
      case kX2: return DEFAULT_X2COLOR; // Extra 2
      case kX3: return DEFAULT_X3COLOR; // Extra 3
      default:
        return COLOR_TRANSPARENT;
    };
  }
 
  IVColorSpec()
  {
    ResetColors();
  }
 
  IVColorSpec(const std::initializer_list<IColor>& colors)
  {
    assert(colors.size() <= kNumVColors);
    
    int i = 0;
    
    for(auto& c : colors)
    {
      mColors[i++] = c;
    }
    
    for(; i<kNumVColors; i++)
    {
      mColors[i] = GetDefaultColor((EVColor) i);
    }
  }
  
  void ResetColors()
  {
    for (int i=0; i<kNumVColors; i++)
    {
      mColors[i] = GetDefaultColor((EVColor) i);
    }
  }
};
 
const IVColorSpec DEFAULT_COLOR_SPEC = IVColorSpec();
 
static constexpr bool DEFAULT_HIDE_CURSOR = true;
static constexpr bool DEFAULT_SHOW_VALUE = true;
static constexpr bool DEFAULT_SHOW_LABEL = true;
static constexpr bool DEFAULT_DRAW_FRAME = true;
static constexpr bool DEFAULT_DRAW_SHADOWS = true;
static constexpr bool DEFAULT_EMBOSS = false;
static constexpr float DEFAULT_ROUNDNESS = 0.f;
static constexpr float DEFAULT_FRAME_THICKNESS = 1.f;
static constexpr float DEFAULT_SHADOW_OFFSET = 3.f;
static constexpr float DEFAULT_WIDGET_FRAC = 1.f;
static constexpr float DEFAULT_WIDGET_ANGLE = 0.f;
static constexpr EOrientation DEFAULT_LABEL_ORIENTATION = EOrientation::North;
const IText DEFAULT_LABEL_TEXT {DEFAULT_TEXT_SIZE + 5.f, EVAlign::Top};
const IText DEFAULT_VALUE_TEXT {DEFAULT_TEXT_SIZE, EVAlign::Bottom};
 
struct IVStyle
{
  bool hideCursor = DEFAULT_HIDE_CURSOR;
  bool showLabel = DEFAULT_SHOW_LABEL;
  bool showValue = DEFAULT_SHOW_VALUE;
  bool drawFrame = DEFAULT_DRAW_FRAME;
  bool drawShadows = DEFAULT_DRAW_SHADOWS;
  bool emboss = DEFAULT_EMBOSS;
  float roundness = DEFAULT_ROUNDNESS;
  float frameThickness = DEFAULT_FRAME_THICKNESS;
  float shadowOffset = DEFAULT_SHADOW_OFFSET;
  float widgetFrac = DEFAULT_WIDGET_FRAC;
  float angle = DEFAULT_WIDGET_ANGLE;
  IVColorSpec colorSpec = DEFAULT_COLOR_SPEC;
  IText labelText = DEFAULT_LABEL_TEXT;
  IText valueText = DEFAULT_VALUE_TEXT;
  EOrientation labelOrientation = DEFAULT_LABEL_ORIENTATION;
  
  IVStyle(bool showLabel = DEFAULT_SHOW_LABEL,
          bool showValue = DEFAULT_SHOW_VALUE,
          const IVColorSpec& colors = {DEFAULT_BGCOLOR, DEFAULT_FGCOLOR, DEFAULT_PRCOLOR, DEFAULT_FRCOLOR, DEFAULT_HLCOLOR, DEFAULT_SHCOLOR, DEFAULT_X1COLOR, DEFAULT_X2COLOR, DEFAULT_X3COLOR},
          const IText& labelText = DEFAULT_LABEL_TEXT,
          const IText& valueText = DEFAULT_VALUE_TEXT,
          bool hideCursor = DEFAULT_HIDE_CURSOR,
          bool drawFrame = DEFAULT_DRAW_FRAME,
          bool drawShadows = DEFAULT_DRAW_SHADOWS,
          bool emboss = DEFAULT_EMBOSS,
          float roundness = DEFAULT_ROUNDNESS,
          float frameThickness = DEFAULT_FRAME_THICKNESS,
          float shadowOffset = DEFAULT_SHADOW_OFFSET,
          float widgetFrac = DEFAULT_WIDGET_FRAC,
          float angle = DEFAULT_WIDGET_ANGLE,
          EOrientation labelOrientation = DEFAULT_LABEL_ORIENTATION)
  : hideCursor(hideCursor)
  , showLabel(showLabel)
  , showValue(showValue)
  , drawFrame(drawFrame)
  , drawShadows(drawShadows)
  , emboss(emboss)
  , roundness(roundness)
  , frameThickness(frameThickness)
  , shadowOffset(shadowOffset)
  , widgetFrac(widgetFrac)
  , angle(angle)
  , colorSpec(colors)
  , labelText(labelText)
  , valueText(valueText)
  {
  }
  
  IVStyle(const std::initializer_list<IColor>& colors)
  : colorSpec(colors)
  {
  }
  
  IVStyle WithShowLabel(bool show = true) const { IVStyle newStyle = *this; newStyle.showLabel = show; return newStyle; }
  IVStyle WithShowValue(bool show = true) const { IVStyle newStyle = *this; newStyle.showValue = show; return newStyle; }
  IVStyle WithLabelText(const IText& text) const { IVStyle newStyle = *this; newStyle.labelText = text; return newStyle;}
  IVStyle WithValueText(const IText& text) const { IVStyle newStyle = *this; newStyle.valueText = text; return newStyle; }
  IVStyle WithHideCursor(bool hide = true) const { IVStyle newStyle = *this; newStyle.hideCursor = hide; return newStyle; }
  IVStyle WithColor(EVColor idx, IColor color) const { IVStyle newStyle = *this; newStyle.colorSpec.mColors[idx] = color; return newStyle; }
  IVStyle WithColors(const IVColorSpec& spec) const { IVStyle newStyle = *this; newStyle.colorSpec = spec; return newStyle; }
  IVStyle WithRoundness(float v) const { IVStyle newStyle = *this; newStyle.roundness = Clip(v, 0.f, 1.f); return newStyle; }
  IVStyle WithFrameThickness(float v) const { IVStyle newStyle = *this; newStyle.frameThickness = v; return newStyle; }
  IVStyle WithShadowOffset(float v) const { IVStyle newStyle = *this; newStyle.shadowOffset = v; return newStyle; }
  IVStyle WithDrawShadows(bool v = true) const { IVStyle newStyle = *this; newStyle.drawShadows = v; return newStyle; }
  IVStyle WithDrawFrame(bool v = true) const { IVStyle newStyle = *this; newStyle.drawFrame = v; return newStyle; }
  IVStyle WithWidgetFrac(float v) const { IVStyle newStyle = *this; newStyle.widgetFrac = Clip(v, 0.f, 1.f); return newStyle; }
  IVStyle WithAngle(float v) const { IVStyle newStyle = *this; newStyle.angle = Clip(v, 0.f, 360.f); return newStyle; }
  IVStyle WithEmboss(bool v = true) const { IVStyle newStyle = *this; newStyle.emboss = v; return newStyle; }
  IVStyle WithLabelOrientation(EOrientation v) const { IVStyle newStyle = *this; newStyle.labelOrientation = v; return newStyle; }
};
 
const IVStyle DEFAULT_STYLE = IVStyle();
 
END_IGRAPHICS_NAMESPACE
END_IPLUG_NAMESPACE