IGraphics.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

#ifndef NO_IGRAPHICS
#if defined(IGRAPHICS_NANOVG) + defined(IGRAPHICS_CANVAS) + defined(IGRAPHICS_SKIA) != 1
#error Either NO_IGRAPHICS or one and only one choice of graphics library must be defined!
#endif
#endif

#ifdef AAX_API
#include "IPlugAAX_view_interface.h"
#endif

#include "IPlugConstants.h"
#include "IPlugLogger.h"
#include "IPlugPaths.h"

#include "IGraphicsConstants.h"
#include "IGraphicsStructs.h"
#include "IGraphicsPopupMenu.h"
#include "IGraphicsEditorDelegate.h"

#ifdef IGRAPHICS_IMGUI
#include "IGraphicsImGui.h"
#endif

#include "nanosvg.h"

#include <stack>
#include <memory>
#include <vector>
#include <unordered_map>

#ifdef FillRect
#undef FillRect
#endif

#ifdef DrawText
#undef DrawText
#endif

#ifdef LoadBitmap
#undef LoadBitmap
#endif

BEGIN_IPLUG_NAMESPACE
class IParam;
BEGIN_IGRAPHICS_NAMESPACE
class IControl;
class IPopupMenuControl;
class ITextEntryControl;
class ICornerResizerControl;
class IFPSDisplayControl;
class IBubbleControl;

class IGraphics
#ifdef AAX_API
: public IPlugAAXView_Interface
#endif
{
public:
#pragma mark - Drawing API implementation

  virtual void BeginFrame();
  
  virtual void OnViewInitialized(void* pContext) {};
  
  virtual void OnViewDestroyed() {};

  virtual void EndFrame() {};

  virtual void DrawSVG(const ISVG& svg, const IRECT& bounds, const IBlend* pBlend = 0);

  virtual void DrawRotatedSVG(const ISVG& svg, float destCentreX, float destCentreY, float width, float height, double angle, const IBlend* pBlend = 0);

  virtual void DrawBitmap(const IBitmap& bitmap, const IRECT& bounds, int srcX, int srcY, const IBlend* pBlend = 0) = 0;

  virtual void DrawFittedBitmap(const IBitmap& bitmap, const IRECT& bounds, const IBlend* pBlend = 0);
  
  virtual void DrawRotatedBitmap(const IBitmap& bitmap, float destCentreX, float destCentreY, double angle, const IBlend* pBlend = 0);

  virtual void DrawPoint(const IColor& color, float x, float y, const IBlend* pBlend = 0);

  virtual void DrawLine(const IColor& color, float x1, float y1, float x2, float y2, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawDottedLine(const IColor& color, float x1, float y1, float x2, float y2, const IBlend* pBlend = 0, float thickness = 1.f, float dashLen = 2.f);
  
  virtual void DrawTriangle(const IColor& color, float x1, float y1, float x2, float y2, float x3, float y3, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawRect(const IColor& color, const IRECT& bounds, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawRoundRect(const IColor& color, const IRECT& bounds, float cornerRadius = 5.f, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawRoundRect(const IColor& color, const IRECT& bounds, float cRTL, float cRTR, float cRBR, float cRBL, const IBlend* pBlend = 0, float thickness = 1.f);
  
  virtual void DrawArc(const IColor& color, float cx, float cy, float r, float a1, float a2, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawCircle(const IColor& color, float cx, float cy, float r, const IBlend* pBlend = 0, float thickness = 1.f);
  
  virtual void DrawEllipse(const IColor& color, const IRECT& bounds, const IBlend* pBlend = 0, float thickness = 1.f);
  
  virtual void DrawEllipse(const IColor& color, float x, float y, float r1, float r2, float angle = 0.0, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawConvexPolygon(const IColor& color, float* x, float* y, int nPoints, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawDottedRect(const IColor& color, const IRECT& bounds, const IBlend* pBlend = 0, float thickness = 1.f, float dashLen = 2.f);

  virtual void FillTriangle(const IColor& color, float x1, float y1, float x2, float y2, float x3, float y3, const IBlend* pBlend = 0);

  virtual void FillRect(const IColor& color, const IRECT& bounds, const IBlend* pBlend = 0);

  virtual void FillRoundRect(const IColor& color, const IRECT& bounds, float cornerRadius = 5.f, const IBlend* pBlend = 0);

  virtual void FillRoundRect(const IColor& color, const IRECT& bounds, float cRTL, float cRTR, float cRBR, float cRBL, const IBlend* pBlend = 0);
  
  virtual void FillCircle(const IColor& color, float cx, float cy, float r, const IBlend* pBlend = 0);

  virtual void FillEllipse(const IColor& color, const IRECT& bounds, const IBlend* pBlend = 0);
  
  virtual void FillEllipse(const IColor& color, float x, float y, float r1, float r2, float angle = 0.0, const IBlend* pBlend = 0);
  
  virtual void FillArc(const IColor& color, float cx, float cy, float r, float a1, float a2, const IBlend* pBlend = 0);

  virtual void FillConvexPolygon(const IColor& color, float* x, float* y, int nPoints, const IBlend* pBlend = 0);

  void DrawText(const IText& text, const char* str, const IRECT& bounds, const IBlend* pBlend = 0);

  void DrawText(const IText& text, const char* str, float x, float y, const IBlend* pBlend = 0);
  
  virtual float MeasureText(const IText& text, const char* str, IRECT& bounds) const;

  virtual IColor GetPoint(int x, int y)  = 0;

  virtual void* GetDrawContext() = 0;

  virtual const char* GetDrawingAPIStr() = 0;
  
  virtual IBitmap ScaleBitmap(const IBitmap& inBitmap, const char* cacheName, int targetScale);

  virtual void RetainBitmap(const IBitmap& bitmap, const char* cacheName);

  virtual void ReleaseBitmap(const IBitmap& bitmap);

  IBitmap GetScaledBitmap(IBitmap& inBitmap);
  
  virtual bool BitmapExtSupported(const char* ext) = 0;
  
  virtual void DrawFastDropShadow(const IRECT& innerBounds, const IRECT& outerBounds, float xyDrop = 5.f, float roundness = 0.f, float blur = 10.f, IBlend* pBlend = nullptr) { /* NO-OP*/ }
  
#pragma mark - Base implementation - drawing helpers

  void DrawBitmap(const IBitmap& bitmap, const IRECT& bounds, int frame = 1, const IBlend* pBlend = 0);

  void DrawBitmapedText(const IBitmap& bitmap, const IRECT& bounds, IText& text, IBlend* pBlend, const char* str, bool vCenter = true, bool multiline = false, int charWidth = 6, int charHeight = 12, int charOffset = 0);

  void DrawVerticalLine(const IColor& color, const IRECT& bounds, float x, const IBlend* pBlend = 0, float thickness = 1.f);

  void DrawHorizontalLine(const IColor& color, const IRECT& bounds, float y, const IBlend* pBlend = 0, float thickness = 1.f);

  void DrawVerticalLine(const IColor& color, float xi, float yLo, float yHi, const IBlend* pBlend = 0, float thickness = 1.f);

  void DrawHorizontalLine(const IColor& color, float yi, float xLo, float xHi, const IBlend* pBlend = 0, float thickness = 1.f);

  void DrawRadialLine(const IColor& color, float cx, float cy, float angle, float rMin, float rMax, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawGrid(const IColor& color, const IRECT& bounds, float gridSizeH, float gridSizeV, const IBlend* pBlend = 0, float thickness = 1.f);

  virtual void DrawData(const IColor& color, const IRECT& bounds, float* normYPoints, int nPoints, float* normXPoints = nullptr, const IBlend* pBlend = 0, float thickness = 1.f);
  
  virtual bool LoadFont(const char* fontID, const char* fileNameOrResID);

  virtual bool LoadFont(const char* fontID, void* pData, int dataSize);
    
  bool LoadFont(const char* fontID, const char* fontName, ETextStyle style);

#pragma mark - Layer management
  
  void StartLayer(IControl* pOwner, const IRECT& r, bool cacheable = false);
  
  void ResumeLayer(ILayerPtr& layer);

  ILayerPtr EndLayer();

  bool CheckLayer(const ILayerPtr& layer);

  void DrawLayer(const ILayerPtr& layer, const IBlend* pBlend = nullptr);

  void DrawFittedLayer(const ILayerPtr& layer, const IRECT& bounds, const IBlend* pBlend);

  void DrawRotatedLayer(const ILayerPtr& layer, double angle);
    
  void ApplyLayerDropShadow(ILayerPtr& layer, const IShadow& shadow);

protected:
  virtual void GetLayerBitmapData(const ILayerPtr& layer, RawBitmapData& data) = 0;
  
  virtual void ApplyShadowMask(ILayerPtr& layer, RawBitmapData& mask, const IShadow& shadow) = 0;
  
  virtual void UpdateLayer() {}

  void PushLayer(ILayer* pLayer);
  
  ILayer* PopLayer();
  
#pragma mark - Drawing API path support
public:
  virtual void PathClear() = 0;

  virtual void PathClose() = 0;

  void PathLine(float x1, float y1, float x2, float y2)
  {
    PathMoveTo(x1, y1);
    PathLineTo(x2, y2);
  }

  void PathRadialLine(float cx, float cy, float angle, float rMin, float rMax);

  void PathTriangle(float x1, float y1, float x2, float y2, float x3, float y3);

  void PathRect(const IRECT& bounds);

  void PathRoundRect(const IRECT& bounds, float ctl, float ctr, float cbl, float cbr);

  void PathRoundRect(const IRECT& bounds, float cornerRadius = 5.f);

  virtual void PathArc(float cx, float cy, float r, float a1, float a2, EWinding winding = EWinding::CW) = 0;

  void PathCircle(float cx, float cy, float r);

   void PathEllipse(const IRECT& bounds);
  
  void PathEllipse(float x, float y, float r1, float r2, float angle = 0.0);

  void PathConvexPolygon(float* x, float* y, int nPoints);

  virtual void PathMoveTo(float x, float y) = 0;

  virtual void PathLineTo(float x, float y) = 0;

  virtual void PathSetWinding(bool clockwise) {};

  virtual void PathCubicBezierTo(float c1x, float c1y, float c2x, float c2y, float x2, float y2) = 0;

  virtual void PathQuadraticBezierTo(float cx, float cy, float x2, float y2) = 0;
  
  virtual void PathStroke(const IPattern& pattern, float thickness, const IStrokeOptions& options = IStrokeOptions(), const IBlend* pBlend = 0) = 0;

  virtual void PathFill(const IPattern& pattern, const IFillOptions& options = IFillOptions(), const IBlend* pBlend = 0) = 0;

  void PathTransformSave();

  void PathTransformRestore();

  void PathTransformReset(bool clearStates = false);

  void PathTransformTranslate(float x, float y);

  void PathTransformScale(float x, float y);

  void PathTransformScale(float scale);

  void PathTransformRotate(float angle);

  void PathTransformSkew(float xAngle, float yAngle);

  void PathTransformMatrix(const IMatrix& matrix);

  void PathClipRegion(const IRECT r = IRECT());
  
  virtual void PathTransformSetMatrix(const IMatrix& matrix) = 0;

  void DoTextRotation(const IText& text, const IRECT& bounds, const IRECT& rect)
  {
    if (!text.mAngle)
      return;
    
    IRECT rotated = rect;
    double tx, ty;
    
    CalculateTextRotation(text, bounds, rotated, tx, ty);
    PathTransformTranslate(static_cast<float>(tx), static_cast<float>(ty));
    PathTransformRotate(text.mAngle);
  }
  
private:
  IPattern GetSVGPattern(const NSVGpaint& paint, float opacity);

  void DoDrawSVG(const ISVG& svg, const IBlend* pBlend = nullptr);
  
  void PrepareRegion(const IRECT& bounds)
  {
    PathTransformReset(true);
    PathClear();
    SetClipRegion(bounds);
    mClipRECT = bounds;
  }

  virtual void CompleteRegion(const IRECT& bounds) {}

  virtual void SetClipRegion(const IRECT& r) = 0;

public:
#pragma mark - Platform implementation
  
  virtual void AttachPlatformView(const IRECT& r, void* pView) {};
  
  virtual void RemovePlatformView(void* pView) {};

  virtual void GetMouseLocation(float& x, float&y) const = 0;
  
  virtual void HideMouseCursor(bool hide = true, bool lock = true) = 0;

  virtual void MoveMouseCursor(float x, float y) = 0;
  
  virtual ECursor SetMouseCursor(ECursor cursorType = ECursor::ARROW)
  {
    ECursor oldCursorType = mCursorType;
    mCursorType = cursorType;
    return oldCursorType;
  }

  virtual void ForceEndUserEdit() = 0;
    
  virtual void* OpenWindow(void* pParentWnd) = 0;

  virtual void CloseWindow() = 0;

  virtual void* GetWindow() = 0;

  virtual bool WindowIsOpen() { return GetWindow(); }

  virtual bool GetTextFromClipboard(WDL_String& str) = 0;

  virtual bool SetTextInClipboard(const char* str) = 0;

  virtual void UpdateTooltips() = 0;

  virtual EMsgBoxResult ShowMessageBox(const char* str, const char* caption, EMsgBoxType type, IMsgBoxCompletionHanderFunc completionHandler = nullptr) = 0;

  virtual void PromptForFile(WDL_String& fileName, WDL_String& path, EFileAction action = EFileAction::Open, const char* extensions = 0) = 0;

  virtual void PromptForDirectory(WDL_String& dir) = 0;

  virtual bool PromptForColor(IColor& color, const char* str = "", IColorPickerHandlerFunc func = nullptr) = 0;

  virtual bool OpenURL(const char* url, const char* msgWindowTitle = 0, const char* confirmMsg = 0, const char* errMsgOnFailure = 0) = 0;

  virtual const char* GetPlatformAPIStr() { return ""; }

  virtual bool RevealPathInExplorerOrFinder(WDL_String& path, bool select = false) { return false; }

  virtual void SetWinModuleHandle(void* pHinstance) {}

  virtual void* GetWinModuleHandle() { return nullptr; }

  void SetPlatformContext(void* pContext) { mPlatformContext = pContext; }

  void* GetPlatformContext() { return mPlatformContext; }
  
  virtual void ClientToScreen(float& x, float& y) {};

  virtual PlatformFontPtr LoadPlatformFont(const char* fontID, const char* fileNameOrResID) = 0;

  virtual PlatformFontPtr LoadPlatformFont(const char* fontID, void* pData, int dataSize) = 0;
  
  virtual PlatformFontPtr LoadPlatformFont(const char* fontID, const char* fontName, ETextStyle style) = 0;

  virtual void CachePlatformFont(const char* fontID, const PlatformFontPtr& font) = 0;

  virtual const char* GetBundleID() { return ""; }

protected:
  /* Implemented on Windows to store previously active GLContext and HDC for restoring, calls GetDC */
  virtual void ActivateGLContext() {}; 

  /* Implemented on Windows to restore previous GL context calls ReleaseDC */
  virtual void DeactivateGLContext() {};

  virtual void CreatePlatformTextEntry(int paramIdx, const IText& text, const IRECT& bounds, int length, const char* str) = 0;
  
  virtual IPopupMenu* CreatePlatformPopupMenu(IPopupMenu& menu, const IRECT& bounds, bool& isAsync) = 0;

#pragma mark - Base implementation
public:
  IGraphics(IGEditorDelegate& dlg, int w, int h, int fps = DEFAULT_FPS, float scale = 1.);

  virtual ~IGraphics();
    
  IGraphics(const IGraphics&) = delete;
  IGraphics& operator=(const IGraphics&) = delete;
    
  void SetScreenScale(float scale);

  void SetTranslation(float x, float y) { mXTranslation = x; mYTranslation = y; }
  
  bool IsDirty(IRECTList& rects);

  void Draw(IRECTList& rects);

  void PromptUserInput(IControl& control, const IRECT& bounds, int valIdx = 0);

  void CreatePopupMenu(IControl& control, IPopupMenu& menu, const IRECT& bounds, int valIdx = 0);

  void CreatePopupMenu(IControl& control, IPopupMenu& menu, float x, float y, int valIdx = 0)
  {
    return CreatePopupMenu(control, menu, IRECT(x, y, x, y), valIdx);
  }
    
  void CreateTextEntry(IControl& control, const IText& text, const IRECT& bounds, const char* str = "", int valIdx = 0);

  void SetControlValueAfterTextEdit(const char* str);
    
  void SetControlValueAfterPopupMenu(IPopupMenu* pMenu);
    
  void SetScaleConstraints(float lo, float hi)
  {
    mMinScale = std::min(lo, hi);
    mMaxScale = std::max(lo, hi);
  }
  
  void Resize(int w, int h, float scale, bool needsPlatformResize = true);
  
  void SetStrictDrawing(bool strict);

  /* Enables layout on resize. This means IGEditorDelegate:LayoutUI() will be called when the GUI is resized */
  void SetLayoutOnResize(bool layoutOnResize);

  int Width() const { return mWidth; }

  int Height() const { return mHeight; }

  int WindowWidth() const { return static_cast<int>(static_cast<float>(mWidth) * mDrawScale); }

  int WindowHeight() const { return static_cast<int>(static_cast<float>(mHeight) * mDrawScale); }

  int FPS() const { return mFPS; }

  float GetDrawScale() const { return mDrawScale; }

  float GetScreenScale() const { return mScreenScale; }

  int GetRoundedScreenScale() const { return static_cast<int>(std::ceil(GetScreenScale())); }

  float GetTotalScale() const { return mDrawScale * mScreenScale; }

  IRECT GetPixelSnapped(IRECT &r) const { return r.GetPixelSnapped(GetBackingPixelScale()); }
    
  IGEditorDelegate* GetDelegate() { return mDelegate; }

  IPopupMenu& GetPromptMenu() { return mPromptPopupMenu; }
  
  bool IsInPlatformTextEntry() { return mInTextEntry != nullptr && !mTextEntryControl; }
  
  IControl* GetControlInTextEntry() { return mInTextEntry; }
  
  inline bool TooltipsEnabled() const { return mEnableTooltips; }
  
  EUIResizerMode GetResizerMode() const { return mGUISizeMode; }

  bool GetResizingInProcess() const { return mResizingInProcess; }

  bool EnableMultiTouch(bool enable)
  {
    if (PlatformSupportsMultiTouch())
    {
      mEnableMultiTouch = enable;
      return true;
    }
    else
      mEnableMultiTouch = false;

    return false;
  }
  
  bool MultiTouchEnabled() const { return mEnableMultiTouch; }

  virtual bool PlatformSupportsMultiTouch() const { return false; }
  
  void EnableTooltips(bool enable);
  
  void AssignParamNameToolTips();
  
  inline void ShowControlBounds(bool enable) { mShowControlBounds = enable; SetAllControlsDirty(); }
  
  inline void ShowAreaDrawn(bool enable) { mShowAreaDrawn = enable; if(!enable) SetAllControlsDirty(); }
  
  bool ShowAreaDrawnEnabled() const { return mShowAreaDrawn; }
  
  bool ShowControlBoundsEnabled() const { return mShowControlBounds; }
  
  void EnableLiveEdit(bool enable);

  bool LiveEditEnabled() const { return mLiveEdit != nullptr; }
  
  IRECT GetBounds() const { return IRECT(0.f, 0.f, (float) Width(), (float) Height()); }

  void SetDisplayTickFunc(IDisplayTickFunc func) { mDisplayTickFunc = func; }

  void SetKeyHandlerFunc(IKeyHandlerFunc func) { mKeyHandlerFunc = func; }

  void SetQwertyMidiKeyHandlerFunc(std::function<void(const IMidiMsg& msg)> func = nullptr);
  
  void AttachImGui(std::function<void(IGraphics*)> drawFunc, std::function<void()> setupFunc = nullptr);
  
  bool RespondsToGesture(float x, float y);
  
  void OnGestureRecognized(const IGestureInfo& info);

  virtual float GetPlatformWindowScale() const { return 1.f; }

private:
  /* NO-OP to create ImGui when IGRAPHICS_IMGUI is defined */
  virtual void CreatePlatformImGui() {}
  
  virtual void PlatformResize(bool parentHasResized) {}
  
  virtual void DrawResize() {}
  
  void Draw(const IRECT& bounds, float scale);
  
  void DrawControl(IControl* pControl, const IRECT& bounds, float scale);
  
  void DoCreatePopupMenu(IControl& control, IPopupMenu& menu, const IRECT& bounds, int valIdx, bool isContext);
  
  void StartDragResize() { mResizingInProcess = true; }
  
  void EndDragResize();

#pragma mark - Control management
public:
  void ForAllControlsFunc(std::function<void(IControl* pControl)> func);
  
  template<typename T, typename... Args>
  void ForAllControls(T method, Args... args);
  
  void ForStandardControlsFunc(std::function<void(IControl* pControl)> func);
  
  template<typename T, typename... Args>
  void ForMatchingControls(T method, int paramIdx, Args... args);

  void ForControlWithParam(int paramIdx, std::function<void(IControl* pControl)> func);
  
  void ForControlInGroup(const char* group, std::function<void(IControl* pControl)> func);
  
  void AttachBackground(const char* fileName);

  void AttachSVGBackground(const char* fileName);
  
  void AttachPanelBackground(const IPattern& color);
  
  void AttachCornerResizer(EUIResizerMode sizeMode = EUIResizerMode::Scale, bool layoutOnResize = false, const IColor& color = COLOR_TRANSLUCENT, const IColor& mouseOverColor = COLOR_BLACK, const IColor& dragColor = COLOR_BLACK, float size = 20.f);

  void AttachCornerResizer(ICornerResizerControl* pControl, EUIResizerMode sizeMode = EUIResizerMode::Scale, bool layoutOnResize = false);

  void AttachPopupMenuControl(const IText& text = DEFAULT_TEXT, const IRECT& bounds = IRECT());
  
  void RemovePopupMenuControl();
  
  void AttachTextEntryControl();
  
  void RemoveTextEntryControl();
  
  void AttachBubbleControl(const IText& text = DEFAULT_TEXT);

  void AttachBubbleControl(IBubbleControl* pControl);
  
  /* Called by controls to display text in the bubble control */
  void ShowBubbleControl(IControl* pCaller, float x, float y, const char* str, EDirection dir = EDirection::Horizontal, IRECT minimumContentBounds = IRECT());

  void ShowFPSDisplay(bool enable);
  
  bool ShowingFPSDisplay() { return mPerfDisplay != nullptr; }
  
  IControl* AttachControl(IControl* pControl, int ctrlTag = kNoTag, const char* group = "");

  IControl* GetControl(int idx) { return mControls.Get(idx); }

  int GetControlIdx(IControl* pControl) const { return mControls.Find(pControl); }
  
  int GetIdxOfTaggedControl(int ctrlTag) const
  {
    IControl* pControl = GetControlWithTag(ctrlTag);
    return pControl ? GetControlIdx(pControl) : -1;
  }
  
  IControl* GetControlWithTag(int ctrlTag) const;
  
  int GetControlTag(const IControl* pControl) const
  {
    for (auto itr = mCtrlTags.begin(); itr != mCtrlTags.end(); ++itr)
    {
      if (itr->second == pControl)
        return itr->first;
    }
    
    return kNoTag;
  }
  
  bool ControlIsCaptured() const { return mCapturedMap.size() > 0; }
  
  bool ControlIsCaptured(IControl* pControl) const
  {
    return std::find_if(std::begin(mCapturedMap), std::end(mCapturedMap), [pControl](auto&& press) { return press.second == pControl; }) != mCapturedMap.end();
  }

  void GetTouches(IControl* pControl, std::vector<ITouchID>& touchesOnThisControl) const
  {
    for (auto i = mCapturedMap.begin(), j = mCapturedMap.end(); i != j; ++i)
      if (i->second == pControl)
        touchesOnThisControl.push_back(i->first);
  }
  
  /* Get the first control in the control list, the background */
  IControl* GetBackgroundControl() { return GetControl(0);  }
  
  IPopupMenuControl* GetPopupMenuControl() { return mPopupControl.get(); }
  
  ITextEntryControl* GetTextEntryControl() { return mTextEntryControl.get(); }
  
  IBubbleControl* GetBubbleControl(int i = 0) { return mBubbleControls.Get(i); }
  
  int NBubbleControls() const { return mBubbleControls.GetSize(); }
  
  void StyleAllVectorControls(const IVStyle& style);
  
  void UpdatePeers(IControl* pCaller, int callerValIdx);
  
  int NControls() const { return mControls.GetSize(); }

  void RemoveControlWithTag(int ctrlTag);
  
  void RemoveControls(int fromIdx);

  void RemoveControl(int idx);
  
  void RemoveControl(IControl* pControl);
  
  void RemoveAllControls();
  
  void HideControl(int paramIdx, bool hide);

  void DisableControl(int paramIdx, bool diable);

  void SetAllControlsDirty();
  
  void SetAllControlsClean();
    
  void SetControlPosition(int idx, float x, float y);
  
  void SetControlSize(int idx, float w, float h);
  
  void SetControlBounds(int idx, const IRECT& r);
  
private:
  int GetMouseControlIdx(float x, float y, bool mouseOver = false);
  
  IControl* GetMouseControl(float x, float y, bool capture, bool mouseOver = false, ITouchID touchID = 0);
  
#pragma mark - Event handling
public:
  void OnMouseDown(const std::vector<IMouseInfo>& points);

  void OnMouseUp(const std::vector<IMouseInfo>& points);

  void OnMouseDrag(const std::vector<IMouseInfo>& points);
  
  void OnTouchCancelled(const std::vector<IMouseInfo>& points);

  bool OnMouseDblClick(float x, float y, const IMouseMod& mod);

  void OnMouseWheel(float x, float y, const IMouseMod& mod, float delta);

  bool OnKeyDown(float x, float y, const IKeyPress& key);

  bool OnKeyUp(float x, float y, const IKeyPress& key);
  
  bool OnMouseOver(float x, float y, const IMouseMod& mod);

  void OnMouseOut();
  
  void OnSetCursor() { SetMouseCursor(mCursorType); }

  void OnDrop(const char* str, float x, float y);

  void OnGUIIdle();
  
  void OnDragResize(float x, float y);

  void EnableMouseOver(bool enable) { mEnableMouseOver = enable; }

  void ReleaseMouseCapture();

  bool CanEnableMouseOver() const { return mEnableMouseOver; }

  inline int GetMouseOver() const { return mMouseOverIdx; }

  void GetMouseDownPoint(float& x, float&y) const { x = mMouseDownX; y = mMouseDownY; }
  
  void SetTabletInput(bool tablet) { mTabletInput = tablet; }
#pragma mark - Plug-in API Specific

  int GetParamIdxForPTAutomation(float x, float y);

  int GetLastClickedParamForPTAutomation();

  void SetPTParameterHighlight(int paramIdx, bool isHighlighted, int color);

  void PopupHostContextMenuForParam(int controlIdx, int paramIdx, float x, float y);

  void PopupHostContextMenuForParam(IControl* pControl, int paramIdx, float x, float y);
  
#pragma mark - Resource/File Loading
  
  const char* GetSharedResourcesSubPath() const { return mSharedResourcesSubPath.Get(); }
  
  void SetSharedResourcesSubPath(const char* sharedResourcesSubPath) { mSharedResourcesSubPath.Set(sharedResourcesSubPath); }
  
  virtual IBitmap LoadBitmap(const char* fileNameOrResID, int nStates = 1, bool framesAreHorizontal = false, int targetScale = 0);

  virtual IBitmap LoadBitmap(const char *name, const void* pData, int dataSize, int nStates = 1, bool framesAreHorizontal = false, int targetScale = 0);

  virtual ISVG LoadSVG(const char* fileNameOrResID, const char* units = "px", float dpi = 72.f);

  virtual ISVG LoadSVG(const char* name, const void* pData, int dataSize, const char* units = "px", float dpi = 72.f);

  virtual WDL_TypedBuf<uint8_t> LoadResource(const char* fileNameOrResID, const char* fileType);

  virtual void AttachGestureRecognizer(EGestureType type); //TODO: should be protected?
  
  void AttachGestureRecognizerToRegion(const IRECT& bounds, EGestureType type, IGestureFunc func);
  
  void ClearGestureRegions();

protected:
  virtual APIBitmap* LoadAPIBitmap(const char* fileNameOrResID, int scale, EResourceLocation location, const char* ext) = 0;

  virtual APIBitmap* LoadAPIBitmap(const char* name, const void* pData, int dataSize, int scale) = 0;

  virtual APIBitmap* CreateAPIBitmap(int width, int height, int scale, double drawScale, bool cacheable = false) = 0;

  virtual bool LoadAPIFont(const char* fontID, const PlatformFontPtr& font) = 0;

  virtual bool AssetsLoaded() { return true; }
    
  virtual int AlphaChannel() const = 0;

  virtual bool FlippedBitmap() const = 0;

  inline void SearchNextScale(int& sourceScale, int targetScale);

  EResourceLocation SearchImageResource(const char* fileName, const char* type, WDL_String& result, int targetScale, int& sourceScale);

  APIBitmap* SearchBitmapInCache(const char* fileName, int targetScale, int& sourceScale);

  virtual float DoMeasureText(const IText& text, const char* str, IRECT& bounds) const = 0;
    
  virtual void DoDrawText(const IText& text, const char* str, const IRECT& bounds, const IBlend* pBlend = nullptr) = 0;

  void DoMeasureTextRotation(const IText& text, const IRECT& bounds, IRECT& rect) const;
  
  void CalculateTextRotation(const IText& text, const IRECT& bounds, IRECT& rect, double& tx, double& ty) const;
  
  virtual float GetBackingPixelScale() const { return GetScreenScale() * GetDrawScale(); };

  IMatrix GetTransformMatrix() const { return mTransform; }
#pragma mark -

private:
  void ClearMouseOver()
  {
    mMouseOver = nullptr;
    mMouseOverIdx = -1;
  }
  
  WDL_PtrList<IControl> mControls;
  std::unordered_map<int, IControl*> mCtrlTags;

  // Order (front-to-back) ToolTip / PopUp / TextEntry / LiveEdit / Corner / PerfDisplay
  std::unique_ptr<ICornerResizerControl> mCornerResizer;
  WDL_PtrList<IBubbleControl> mBubbleControls;
  std::unique_ptr<IPopupMenuControl> mPopupControl;
  std::unique_ptr<IFPSDisplayControl> mPerfDisplay;
  std::unique_ptr<ITextEntryControl> mTextEntryControl;
  std::unique_ptr<IControl> mLiveEdit;
  
  IPopupMenu mPromptPopupMenu;
  
  WDL_String mSharedResourcesSubPath;
  
  ECursor mCursorType = ECursor::ARROW;
  int mWidth;
  int mHeight;
  int mFPS;
  float mScreenScale = 1.f; // the scaling of the display that the UI is currently on e.g. 2 for retina
  float mDrawScale = 1.f; // scale deviation from  default width and height i.e stretching the UI by dragging bottom right hand corner

  int mIdleTicks = 0;
  
  std::vector<EGestureType> mRegisteredGestures; // All the types of gesture registered with the graphics context
  IRECTList mGestureRegions; // Rectangular regions linked to gestures (excluding IControls)
  std::unordered_map<int, IGestureFunc> mGestureRegionFuncs; // Map of gesture region index to gesture function
  std::unordered_map<ITouchID, IControl*> mCapturedMap; // associative array of touch ids to control pointers, the same control can be touched multiple times
  IControl* mMouseOver = nullptr;
  IControl* mInTextEntry = nullptr;
  IControl* mInPopupMenu = nullptr;
  void* mPlatformContext = nullptr;
  bool mIsContextMenu = false;
  int mTextEntryValIdx = kNoValIdx;
  int mPopupMenuValIdx = kNoValIdx;
  int mMouseOverIdx = -1;
  float mMouseDownX = -1.f;
  float mMouseDownY = -1.f;
  float mMinScale;
  float mMaxScale;
  int mLastClickedParam = kNoParameter;
  bool mEnableMouseOver = false;
  bool mStrict = false;
  bool mEnableTooltips = false;
  bool mShowControlBounds = false;
  bool mShowAreaDrawn = false;
  bool mResizingInProcess = false;
  bool mLayoutOnResize = false;
  bool mEnableMultiTouch = false;
  EUIResizerMode mGUISizeMode = EUIResizerMode::Scale;
  double mPrevTimestamp = 0.;
  IKeyHandlerFunc mKeyHandlerFunc = nullptr;
  IDisplayTickFunc mDisplayTickFunc = nullptr;

protected:
  IGEditorDelegate* mDelegate;
  bool mCursorHidden = false;
  bool mCursorLock = false;
  bool mTabletInput = false;
  float mCursorX = -1.f;
  float mCursorY = -1.f;
  float mXTranslation = 0.f;
  float mYTranslation = 0.f;
  
  friend class IGraphicsLiveEdit;
  friend class ICornerResizerControl;
  friend class ITextEntryControl;
  
  std::stack<ILayer*> mLayers;

  IRECT mClipRECT;
  IMatrix mTransform;
  std::stack<IMatrix> mTransformStates;
  
#ifdef IGRAPHICS_IMGUI
public:
  std::unique_ptr<ImGuiRenderer> mImGuiRenderer;
#endif
};

END_IGRAPHICS_NAMESPACE
END_IPLUG_NAMESPACE