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_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"
 
#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, const IColor* pStrokeColor = nullptr, const IColor* pFillColor = nullptr);
 
  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 void DrawMultiLineText(const IText& text, const char* str, const IRECT& bounds, const IBlend* pBlend = 0) { DrawText(text, "Unsupported", bounds, pBlend); }
 
  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 DrawLineAcross(const IColor& color, const IRECT& bounds, EDirection dir, float pos, const IBlend* pBlend = 0, float thickness = 1.f);
 
  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, const IColor* pFillColor = nullptr);
  
  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);
    
  virtual void ApplyLayerDropShadow(ILayerPtr& layer, const IShadow& shadow);
 
  virtual void GetLayerBitmapData(const ILayerPtr& layer, RawBitmapData& data) = 0;
  
protected:
  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, const IColor* pStrokeColor = nullptr, const IColor* pFillColor = 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 HidePlatformView(void* pView, bool hide) {};
 
  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 bool SetFilePathInClipboard(const char* path) { return false; }
 
  virtual bool InitiateExternalFileDragDrop(const char* path, const IRECT& iconBounds) { return false; };
 
  virtual void UpdateTooltips() = 0;
 
  virtual EMsgBoxResult ShowMessageBox(const char* str, const char* title, EMsgBoxType type, IMsgBoxCompletionHandlerFunc completionHandler = nullptr) = 0;
 
  virtual void PromptForFile(WDL_String& fileName, WDL_String& path, EFileAction action = EFileAction::Open, const char* ext = "", IFileDialogCompletionHandlerFunc completionHandler = nullptr) = 0;
 
  virtual void PromptForDirectory(WDL_String& dir, IFileDialogCompletionHandlerFunc completionHandler = nullptr) = 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() const { return ""; }
 
  virtual const char* GetAppGroupID() const { return ""; }
 
  // An RAII helper to manage the IGraphics GL context
  class ScopedGLContext
  {
  public:
    ScopedGLContext(IGraphics* pGraphics)
    : mIGraphics(*pGraphics) { mIGraphics.ActivateGLContext(); }
    ~ScopedGLContext() { mIGraphics.DeactivateGLContext(); }
  private:
    IGraphics& mIGraphics;
  };
  
protected:
  /* Activate the context for the view (GL only) */
  virtual void ActivateGLContext() {};
 
  /* Deactivate the context for the view (GL only) */
  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 DeleteFromPopupMenu(IPopupMenu* pMenu, int itemIdx);
 
  void SetScaleConstraints(float lo, float 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; }
  
  void ClearInTextEntryControl() { mInTextEntry = nullptr; }
  
  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; }
 
  void SetLiveEditEventFunc(ILiveEditEventFunc func) { mLiveEditEventFunc = func; }
  
  IRECT GetBounds() const { return IRECT(0.f, 0.f, (float) Width(), (float) Height()); }
 
  void SetDisplayTickFunc(IDisplayTickFunc func) { mDisplayTickFunc = func; }
 
  void SetUIAppearanceChangedFunc(IUIAppearanceChangedFunc func) { mAppearanceChangedFunc = func; }
  
  void SetKeyHandlerFunc(IKeyHandlerFunc func) { mKeyHandlerFunc = func; }
 
  void SetQwertyMidiKeyHandlerFunc(std::function<void(const IMidiMsg& msg)> func = nullptr);
  
  bool RespondsToGesture(float x, float y);
  
  void OnGestureRecognized(const IGestureInfo& info);
 
  virtual float GetPlatformWindowScale() const { return 1.f; }
 
private:
  
  virtual void PlatformResize(bool parentHasResized) {}
  
  virtual void DrawResize() {}
 
  virtual void PostResize() {}
 
  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(IControlFunction func);
  
  template<typename T, typename... Args>
  void ForAllControls(T method, Args... args);
  
  void ForStandardControlsFunc(IControlFunction func);
  
  template<typename T, typename... Args>
  void ForMatchingControls(T method, int paramIdx, Args... args);
 
  void ForControlWithParam(int paramIdx, IControlFunction func);
  
  void ForControlWithParam(const std::initializer_list<int>& params, IControlFunction func);
 
  void ForControlInGroup(const char* group, IControlFunction 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());
  
  /* Sets the region of the IGraphics context that should be used for the FPS display */
  void SetFPSDisplayBounds(const IRECT& bounds) { mPerfDisplayBounds = bounds; }
 
  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;
  }
  
  IControl* GetControlWithParamIdx(int paramIdx);
  
  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(IControl* pControl, float x, float y);
  
  void SetControlSize(IControl* pControl, float w, float h);
  
  void SetControlBounds(IControl* pControl, 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);
 
  bool 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 OnDropMultiple(const std::vector<const char*>& paths, float x, float y);
 
  void OnGUIIdle();
  
  void OnDragResize(float x, float y);
 
  void OnAppearanceChanged(EUIAppearance appearance);
  
  virtual EUIAppearance GetUIAppearance() const { return EUIAppearance::Light; }
  
  void EnableMouseOver(bool enable) { mEnableMouseOver = enable; }
 
  void ReleaseMouseCapture();
 
  bool MouseOverEnabled() 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);
  
  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, float scale, double drawScale, bool cacheable = false) = 0;
 
  virtual bool LoadAPIFont(const char* fontID, const PlatformFontPtr& font) = 0;
    
  virtual int AlphaChannel() const = 0;
 
  virtual bool FlippedBitmap() const = 0;
 
  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;
  }
 
  bool HasLiveEditEventFunc() const { return static_cast<bool>(mLiveEditEventFunc); }
 
  void EmitLiveEditEvent(const char* eventJson) const
  {
    if (mLiveEditEventFunc)
      mLiveEditEventFunc(eventJson);
  }
  
  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;
  
  IRECT mPerfDisplayBounds;
  
  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;
  IUIAppearanceChangedFunc mAppearanceChangedFunc = nullptr;
  ILiveEditEventFunc mLiveEditEventFunc = 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;
};
 
END_IGRAPHICS_NAMESPACE
END_IPLUG_NAMESPACE