DISTRHO
/
DPF-Plugins
mirror of https://github.com/DISTRHO/DPF-Plugins
1
0
Fork 0
Code Releases 8 Activity
Collection of DPF-based plugins for packaging
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
191 Commits
1 Branch
299MB
Tree: f42469deb2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f42469deb2'
${ noResults }
DPF-Plugins/dpf/distrho/extra/choc/choc.patch

2804 lines
98KB
Raw Blame History 

  1. diff --git a/choc_DesktopWindow.h b/choc_DesktopWindow.h

  2. index b948042..55e7305 100644

  3. --- a/choc_DesktopWindow.h

  4. +++ b/choc_DesktopWindow.h

  5. @@ -19,100 +19,7 @@

  6.  #ifndef CHOC_DESKTOPWINDOW_HEADER_INCLUDED

  7.  #define CHOC_DESKTOPWINDOW_HEADER_INCLUDED

  8.  

  9. -#include "../platform/choc_Platform.h"

  10. -

  11. -

  12. -//==============================================================================

  13. -namespace choc::ui

  14. -{

  15. -

  16. -/// Represents the position and size of a DesktopWindow or other UI elements.

  17. -struct Bounds

  18. -{

  19. -    int x = 0, y = 0, width = 0, height = 0;

  20. -};

  21. -

  22. -/**

  23. -    A very basic desktop window class.

  24. -

  25. -    The main use-case for this is as a simple way to host other UI elements

  26. -    such as the choc::ui::WebView.

  27. -

  28. -    Because this is a GUI, it needs a message loop to be running. If you're using

  29. -    it inside an app which already runs a message loop, it should just work,

  30. -    or you can use choc::messageloop::run() and choc::messageloop::stop() for an easy

  31. -    but basic loop.

  32. -

  33. -    Note that on Linux this uses GTK, so to build it you'll need to:

  34. -       1. Install the libgtk-3-dev package.

  35. -       2. Link the gtk+3.0 library in your build.

  36. -          You might want to have a look inside choc/tests/CMakeLists.txt for

  37. -          an example of how to add this packages to your build without too

  38. -          much fuss.

  39. -

  40. -    For an example of how to use this class, see `choc/tests/main.cpp` where

  41. -    there's a simple demo.

  42. -*/

  43. -struct DesktopWindow

  44. -{

  45. -    DesktopWindow (Bounds);

  46. -    ~DesktopWindow();

  47. -

  48. -    /// Sets the title of the window that the browser is inside

  49. -    void setWindowTitle (const std::string& newTitle);

  50. -

  51. -    /// Gives the window a child/content view to display.

  52. -    /// The pointer being passed in will be a platform-specific native handle,

  53. -    /// so a HWND on Windows, an NSView* on OSX, etc.

  54. -    void setContent (void* nativeView);

  55. -

  56. -    /// Shows or hides the window. It's visible by default when created.

  57. -    void setVisible (bool visible);

  58. -

  59. -    /// Changes the window's position

  60. -    void setBounds (Bounds);

  61. -

  62. -    /// Enables/disables user resizing of the window

  63. -    void setResizable (bool);

  64. -

  65. -    /// Enables/disables the window's close button (if applicable).

  66. -    void setClosable (bool);

  67. -

  68. -    /// Gives the window a given size and positions it in the middle of the

  69. -    /// default monitor

  70. -    void centreWithSize (int width, int height);

  71. -

  72. -    /// Sets a minimum size below which the user can't shrink the window

  73. -    void setMinimumSize (int minWidth, int minHeight);

  74. -    /// Sets a maximum size above which the user can't grow the window

  75. -    void setMaximumSize (int maxWidth, int maxHeight);

  76. -

  77. -    /// Tries to bring this window to the front of the Z-order.

  78. -    void toFront();

  79. -

  80. -    /// Returns the native OS handle, which may be a HWND on Windows, an

  81. -    /// NSWindow* on OSX or a GtkWidget* on linux.

  82. -    void* getWindowHandle() const;

  83. -

  84. -    /// An optional callback that will be called when the parent window is resized

  85. -    std::function<void()> windowResized;

  86. -    /// An optional callback that will be called when the parent window is closed

  87. -    std::function<void()> windowClosed;

  88. -

  89. -private:

  90. -    struct Pimpl;

  91. -    std::unique_ptr<Pimpl> pimpl;

  92. -};

  93. -

  94. -//==============================================================================

  95. -/// This Windows-only function turns on high-DPI awareness for the current

  96. -/// process. On other OSes where no equivalent call is needed, this function is

  97. -/// just a stub.

  98. -void setWindowsDPIAwareness();

  99. -

  100. -

  101. -} // namespace choc::ui

  102. -

  103. +#include "choc_Platform.h"

  104.  

  105.  //==============================================================================

  106.  //        _        _           _  _

  107. @@ -125,326 +32,6 @@ void setWindowsDPIAwareness();

  108.  //

  109.  //==============================================================================

  110.  

  111. -#if CHOC_LINUX

  112. -

  113. -struct choc::ui::DesktopWindow::Pimpl

  114. -{

  115. -    Pimpl (DesktopWindow& w, Bounds bounds)  : owner (w)

  116. -    {

  117. -        if (! gtk_init_check (nullptr, nullptr))

  118. -            return;

  119. -

  120. -        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  121. -        g_object_ref_sink (G_OBJECT (window));

  122. -

  123. -        destroyHandlerID = g_signal_connect (G_OBJECT (window), "destroy",

  124. -                                             G_CALLBACK (+[](GtkWidget*, gpointer arg)

  125. -                                             {

  126. -                                                 static_cast<Pimpl*> (arg)->windowDestroyEvent();

  127. -                                             }),

  128. -                                             this);

  129. -        setBounds (bounds);

  130. -        setVisible (true);

  131. -    }

  132. -

  133. -    ~Pimpl()

  134. -    {

  135. -        if (destroyHandlerID != 0 && window != nullptr)

  136. -            g_signal_handler_disconnect (G_OBJECT (window), destroyHandlerID);

  137. -

  138. -        g_clear_object (&window);

  139. -    }

  140. -

  141. -    void windowDestroyEvent()

  142. -    {

  143. -        g_clear_object (&window);

  144. -

  145. -        if (owner.windowClosed != nullptr)

  146. -            owner.windowClosed();

  147. -    }

  148. -

  149. -    void* getWindowHandle() const     { return (void*) window; }

  150. -

  151. -    void setWindowTitle (const std::string& newTitle)

  152. -    {

  153. -        gtk_window_set_title (GTK_WINDOW (window), newTitle.c_str());

  154. -    }

  155. -

  156. -    void setContent (void* view)

  157. -    {

  158. -        if (content != nullptr)

  159. -            gtk_container_remove (GTK_CONTAINER (window), content);

  160. -

  161. -        content = GTK_WIDGET (view);

  162. -        gtk_container_add (GTK_CONTAINER (window), content);

  163. -        gtk_widget_grab_focus (content);

  164. -    }

  165. -

  166. -    void setVisible (bool visible)

  167. -    {

  168. -        if (visible)

  169. -            gtk_widget_show_all (window);

  170. -        else

  171. -            gtk_widget_hide (window);

  172. -    }

  173. -

  174. -    void setResizable (bool b) { gtk_window_set_resizable (GTK_WINDOW (window), b); }

  175. -    void setClosable (bool b)  { gtk_window_set_deletable (GTK_WINDOW (window), b); }

  176. -

  177. -    void setMinimumSize (int w, int h)

  178. -    {

  179. -        GdkGeometry g;

  180. -        g.min_width = w;

  181. -        g.min_height = h;

  182. -        gtk_window_set_geometry_hints (GTK_WINDOW (window), nullptr, &g, GDK_HINT_MIN_SIZE);

  183. -    }

  184. -

  185. -    void setMaximumSize (int w, int h)

  186. -    {

  187. -        GdkGeometry g;

  188. -        g.max_width = w;

  189. -        g.max_height = h;

  190. -        gtk_window_set_geometry_hints (GTK_WINDOW (window), nullptr, &g, GDK_HINT_MAX_SIZE);

  191. -    }

  192. -

  193. -    void setBounds (Bounds b)

  194. -    {

  195. -        setSize (b.width, b.height);

  196. -        gtk_window_move (GTK_WINDOW (window), b.x, b.y);

  197. -    }

  198. -

  199. -    void setSize (int w, int h)

  200. -    {

  201. -        if (gtk_window_get_resizable (GTK_WINDOW (window)))

  202. -            gtk_window_resize (GTK_WINDOW (window), w, h);

  203. -        else

  204. -            gtk_widget_set_size_request (window, w, h);

  205. -    }

  206. -

  207. -    void centreWithSize (int w, int h)

  208. -    {

  209. -        setSize (w, h);

  210. -        gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);

  211. -    }

  212. -

  213. -    void toFront()

  214. -    {

  215. -        gtk_window_activate_default (GTK_WINDOW (window));

  216. -    }

  217. -

  218. -    DesktopWindow& owner;

  219. -    GtkWidget* window = {};

  220. -    GtkWidget* content = {};

  221. -    unsigned long destroyHandlerID = 0;

  222. -};

  223. -

  224. -inline void choc::ui::setWindowsDPIAwareness() {}

  225. -

  226. -//==============================================================================

  227. -#elif CHOC_APPLE

  228. -

  229. -#include "choc_MessageLoop.h"

  230. -

  231. -namespace choc::ui

  232. -{

  233. -

  234. -namespace macos_ui_helpers

  235. -{

  236. -    // Including CodeGraphics.h can create all kinds of messy C/C++ symbol clashes

  237. -    // with other headers, but all we actually need are these coordinate structs:

  238. -   #if defined (__LP64__) && __LP64__

  239. -    using CGFloat = double;

  240. -   #else

  241. -    using CGFloat = float;

  242. -   #endif

  243. -

  244. -    struct CGPoint { CGFloat x = 0, y = 0; };

  245. -    struct CGSize  { CGFloat width = 0, height = 0; };

  246. -    struct CGRect  { CGPoint origin; CGSize size; };

  247. -

  248. -    inline CGSize createCGSize (double w, double h)  { return { (CGFloat) w, (CGFloat) h }; }

  249. -    inline CGRect createCGRect (choc::ui::Bounds b)  { return { { (CGFloat) b.x, (CGFloat) b.y }, { (CGFloat) b.width, (CGFloat) b.height } }; }

  250. -

  251. -    static constexpr long NSWindowStyleMaskTitled = 1;

  252. -    static constexpr long NSWindowStyleMaskMiniaturizable = 4;

  253. -    static constexpr long NSWindowStyleMaskResizable = 8;

  254. -    static constexpr long NSWindowStyleMaskClosable = 2;

  255. -    static constexpr long NSBackingStoreBuffered = 2;

  256. -    static constexpr long NSApplicationActivationPolicyRegular = 0;

  257. -}

  258. -

  259. -using namespace macos_ui_helpers;

  260. -

  261. -inline void setWindowsDPIAwareness() {}

  262. -

  263. -struct DesktopWindow::Pimpl

  264. -{

  265. -    Pimpl (DesktopWindow& w, Bounds bounds)  : owner (w)

  266. -    {

  267. -        using namespace choc::objc;

  268. -        CHOC_AUTORELEASE_BEGIN

  269. -        call<void> (getSharedNSApplication(), "setActivationPolicy:", NSApplicationActivationPolicyRegular);

  270. -

  271. -        window = call<id> (call<id> (getClass ("NSWindow"), "alloc"),

  272. -                           "initWithContentRect:styleMask:backing:defer:",

  273. -                           createCGRect (bounds),

  274. -                           NSWindowStyleMaskTitled, NSBackingStoreBuffered, (int) 0);

  275. -

  276. -        delegate = createDelegate();

  277. -        setStyleBit (NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable, true);

  278. -        objc_setAssociatedObject (delegate, "choc_window", (CHOC_OBJC_CAST_BRIDGED id) this, OBJC_ASSOCIATION_ASSIGN);

  279. -        call<void> (window, "setDelegate:", delegate);

  280. -        CHOC_AUTORELEASE_END

  281. -    }

  282. -

  283. -    ~Pimpl()

  284. -    {

  285. -        CHOC_AUTORELEASE_BEGIN

  286. -        objc::call<void> (window, "setDelegate:", nullptr);

  287. -        objc::call<void> (window, "close");

  288. -        objc::call<void> (delegate, "release");

  289. -        CHOC_AUTORELEASE_END

  290. -    }

  291. -

  292. -    void* getWindowHandle() const     { return (CHOC_OBJC_CAST_BRIDGED void*) window; }

  293. -

  294. -    void setWindowTitle (const std::string& newTitle)

  295. -    {

  296. -        CHOC_AUTORELEASE_BEGIN

  297. -        objc::call<void> (window, "setTitle:", objc::getNSString (newTitle));

  298. -        CHOC_AUTORELEASE_END

  299. -    }

  300. -

  301. -    void setContent (void* view)

  302. -    {

  303. -        CHOC_AUTORELEASE_BEGIN

  304. -        objc::call<void> (window, "setContentView:", (CHOC_OBJC_CAST_BRIDGED id) view);

  305. -        CHOC_AUTORELEASE_END

  306. -    }

  307. -

  308. -    void setVisible (bool visible)

  309. -    {

  310. -        CHOC_AUTORELEASE_BEGIN

  311. -        objc::call<void> (window, "setIsVisible:", (BOOL) visible);

  312. -        CHOC_AUTORELEASE_END

  313. -    }

  314. -

  315. -    void setStyleBit (long bit, bool shouldEnable)

  316. -    {

  317. -        CHOC_AUTORELEASE_BEGIN

  318. -        auto style = objc::call<unsigned long> (window, "styleMask");

  319. -        style = shouldEnable ? (style | (unsigned long) bit) : (style & ~(unsigned long) bit);

  320. -        objc::call<void> (window, "setStyleMask:", style);

  321. -        CHOC_AUTORELEASE_END

  322. -    }

  323. -

  324. -    void setResizable (bool b) { setStyleBit (NSWindowStyleMaskResizable, b); }

  325. -    void setClosable (bool b)  { setStyleBit (NSWindowStyleMaskClosable, b); }

  326. -

  327. -    void setMinimumSize (int w, int h) { CHOC_AUTORELEASE_BEGIN objc::call<void> (window, "setContentMinSize:", createCGSize (w, h)); CHOC_AUTORELEASE_END }

  328. -    void setMaximumSize (int w, int h) { CHOC_AUTORELEASE_BEGIN objc::call<void> (window, "setContentMaxSize:", createCGSize (w, h)); CHOC_AUTORELEASE_END }

  329. -

  330. -    CGRect getFrameRectForContent (Bounds b)

  331. -    {

  332. -        return objc::call<CGRect> (window, "frameRectForContentRect:", createCGRect (b));

  333. -    }

  334. -

  335. -    void centreWithSize (int w, int h)

  336. -    {

  337. -        CHOC_AUTORELEASE_BEGIN

  338. -        objc::call<void> (window, "setFrame:display:animate:", getFrameRectForContent ({ 0, 0, w, h }), (BOOL) 1, (BOOL) 0);

  339. -        objc::call<void> (window, "center");

  340. -        CHOC_AUTORELEASE_END

  341. -    }

  342. -

  343. -    void setBounds (Bounds b)

  344. -    {

  345. -        CHOC_AUTORELEASE_BEGIN

  346. -        objc::call<void> (window, "setFrame:display:animate:", getFrameRectForContent (b), (BOOL) 1, (BOOL) 0);

  347. -        CHOC_AUTORELEASE_END

  348. -    }

  349. -

  350. -    void toFront()

  351. -    {

  352. -        CHOC_AUTORELEASE_BEGIN

  353. -        objc::call<void> (objc::getSharedNSApplication(), "activateIgnoringOtherApps:", (BOOL) 1);

  354. -        objc::call<void> (window, "makeKeyAndOrderFront:", (id) nullptr);

  355. -        CHOC_AUTORELEASE_END

  356. -    }

  357. -

  358. -    static Pimpl& getPimplFromContext (id self)

  359. -    {

  360. -        auto view = (CHOC_OBJC_CAST_BRIDGED Pimpl*) objc_getAssociatedObject (self, "choc_window");

  361. -        CHOC_ASSERT (view != nullptr);

  362. -        return *view;

  363. -    }

  364. -

  365. -    id createDelegate()

  366. -    {

  367. -        static DelegateClass dc;

  368. -        return objc::call<id> ((id) dc.delegateClass, "new");

  369. -    }

  370. -

  371. -    DesktopWindow& owner;

  372. -    id window = {}, delegate = {};

  373. -

  374. -    struct DelegateClass

  375. -    {

  376. -        DelegateClass()

  377. -        {

  378. -            delegateClass = choc::objc::createDelegateClass ("NSResponder", "CHOCDesktopWindowDelegate_");

  379. -

  380. -            if (auto* p = objc_getProtocol ("NSWindowDelegate"))

  381. -                class_addProtocol (delegateClass, p);

  382. -

  383. -            class_addMethod (delegateClass, sel_registerName ("windowShouldClose:"),

  384. -                            (IMP) (+[](id self, SEL, id) -> BOOL

  385. -                            {

  386. -                                CHOC_AUTORELEASE_BEGIN

  387. -                                auto& p = getPimplFromContext (self);

  388. -                                p.window = {};

  389. -

  390. -                                if (auto callback = p.owner.windowClosed)

  391. -                                    choc::messageloop::postMessage ([callback] { callback(); });

  392. -

  393. -                                CHOC_AUTORELEASE_END

  394. -                                return TRUE;

  395. -                            }),

  396. -                            "c@:@");

  397. -

  398. -            class_addMethod (delegateClass, sel_registerName ("windowDidResize:"),

  399. -                            (IMP) (+[](id self, SEL, id)

  400. -                            {

  401. -                                CHOC_AUTORELEASE_BEGIN

  402. -

  403. -                                if (auto callback = getPimplFromContext (self).owner.windowResized)

  404. -                                    callback();

  405. -

  406. -                                CHOC_AUTORELEASE_END

  407. -                            }),

  408. -                            "v@:@");

  409. -

  410. -            class_addMethod (delegateClass, sel_registerName ("applicationShouldTerminateAfterLastWindowClosed:"),

  411. -                            (IMP) (+[](id, SEL, id) -> BOOL { return 0; }),

  412. -                            "c@:@");

  413. -

  414. -            objc_registerClassPair (delegateClass);

  415. -        }

  416. -

  417. -        ~DelegateClass()

  418. -        {

  419. -            objc_disposeClassPair (delegateClass);

  420. -        }

  421. -

  422. -        Class delegateClass = {};

  423. -    };

  424. -};

  425. -

  426. -} // namespace choc::ui

  427. -

  428. -//==============================================================================

  429. -#elif CHOC_WINDOWS

  430. -

  431.  #undef  WIN32_LEAN_AND_MEAN

  432.  #define WIN32_LEAN_AND_MEAN

  433.  #undef  NOMINMAX

  434. @@ -453,27 +40,7 @@ struct DesktopWindow::Pimpl

  435.  #include <windows.h>

  436.  #undef Rectangle

  437.  

  438. -namespace choc::ui

  439. -{

  440. -

  441. -static RECT boundsToRect (Bounds b)

  442. -{

  443. -    RECT r;

  444. -    r.left = b.x;

  445. -    r.top = b.y;

  446. -    r.right = b.x + b.width;

  447. -    r.bottom = b.y + b.height;

  448. -    return r;

  449. -}

  450. -

  451. -template <typename FunctionType>

  452. -FunctionType getUser32Function (const char* name)

  453. -{

  454. -    if (auto user32 = choc::file::DynamicLibrary ("user32.dll"))

  455. -        return reinterpret_cast<FunctionType> (user32.findFunction (name));

  456. -

  457. -    return {};

  458. -}

  459. +START_NAMESPACE_DISTRHO

  460.  

  461.  struct HWNDHolder

  462.  {

  463. @@ -516,7 +83,7 @@ struct WindowClass

  464.          wc.lpfnWndProc = wndProc;

  465.  

  466.          classAtom = (LPCWSTR) (uintptr_t) RegisterClassExW (&wc);

  467. -        CHOC_ASSERT (classAtom != 0);

  468. +        DISTRHO_SAFE_ASSERT (classAtom != 0);

  469.      }

  470.  

  471.      ~WindowClass()

  472. @@ -582,250 +149,6 @@ static std::wstring createUTF16StringFromUTF8 (std::string_view utf8)

  473.      return {};

  474.  }

  475.  

  476. -inline void setWindowsDPIAwareness()

  477. -{

  478. -    if (auto setProcessDPIAwarenessContext = getUser32Function<int(__stdcall *)(void*)> ("SetProcessDpiAwarenessContext"))

  479. -        setProcessDPIAwarenessContext (/*DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2*/ (void*) -4);

  480. -}

  481. -

  482. -//==============================================================================

  483. -struct DesktopWindow::Pimpl

  484. -{

  485. -    Pimpl (DesktopWindow& w, Bounds b)  : owner (w)

  486. -    {

  487. -        hwnd = windowClass.createWindow (WS_OVERLAPPEDWINDOW, 640, 480, this);

  488. -

  489. -        if (hwnd.hwnd == nullptr)

  490. -            return;

  491. -

  492. -        setBounds (b);

  493. -        ShowWindow (hwnd, SW_SHOW);

  494. -        UpdateWindow (hwnd);

  495. -        SetFocus (hwnd);

  496. -    }

  497. -

  498. -    ~Pimpl()

  499. -    {

  500. -        hwnd.reset();

  501. -    }

  502. -

  503. -    void* getWindowHandle() const     { return hwnd; }

  504. -

  505. -    void setWindowTitle (const std::string& newTitle)

  506. -    {

  507. -        SetWindowTextW (hwnd, createUTF16StringFromUTF8 (newTitle).c_str());

  508. -    }

  509. -

  510. -    void setContent (void* childHandle)

  511. -    {

  512. -        if (auto child = getFirstChildWindow())

  513. -        {

  514. -            ShowWindow (child, SW_HIDE);

  515. -            SetParent (child, nullptr);

  516. -        }

  517. -

  518. -        auto child = (HWND) childHandle;

  519. -        auto flags = GetWindowLongPtr (child, -16);

  520. -        flags = (flags & ~(decltype (flags)) WS_POPUP) | (decltype (flags)) WS_CHILD;

  521. -        SetWindowLongPtr (child, -16, flags);

  522. -

  523. -        SetParent (child, hwnd);

  524. -        resizeContentToFit();

  525. -        ShowWindow (child, IsWindowVisible (hwnd) ? SW_SHOW : SW_HIDE);

  526. -    }

  527. -

  528. -    void setVisible (bool visible)

  529. -    {

  530. -        ShowWindow (hwnd, visible ? SW_SHOW : SW_HIDE);

  531. -

  532. -        if (visible)

  533. -            InvalidateRect (hwnd, nullptr, 0);

  534. -    }

  535. -

  536. -    void setResizable (bool b)

  537. -    {

  538. -        auto style = GetWindowLong (hwnd, GWL_STYLE);

  539. -

  540. -        if (b)

  541. -            style |= (WS_THICKFRAME | WS_MAXIMIZEBOX);

  542. -        else

  543. -            style &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);

  544. -

  545. -        SetWindowLong (hwnd, GWL_STYLE, style);

  546. -    }

  547. -

  548. -    void setClosable (bool closable)

  549. -    {

  550. -        EnableMenuItem (GetSystemMenu (hwnd, FALSE), SC_CLOSE,

  551. -                        closable ? (MF_BYCOMMAND | MF_ENABLED)

  552. -                                 : (MF_BYCOMMAND | MF_DISABLED | MF_GRAYED));

  553. -    }

  554. -

  555. -    void setMinimumSize (int w, int h)

  556. -    {

  557. -        minimumSize.x = w;

  558. -        minimumSize.y = h;

  559. -    }

  560. -

  561. -    void setMaximumSize (int w, int h)

  562. -    {

  563. -        maximumSize.x = w;

  564. -        maximumSize.y = h;

  565. -    }

  566. -

  567. -    void getMinMaxInfo (MINMAXINFO& m) const

  568. -    {

  569. -        if (maximumSize.x > 0 && maximumSize.y > 0)

  570. -        {

  571. -            m.ptMaxSize = maximumSize;

  572. -            m.ptMaxTrackSize = maximumSize;

  573. -        }

  574. -

  575. -        if (minimumSize.x > 0 && minimumSize.y > 0)

  576. -            m.ptMinTrackSize = minimumSize;

  577. -    }

  578. -

  579. -    void centreWithSize (int w, int h)

  580. -    {

  581. -        auto dpi = static_cast<int> (getWindowDPI());

  582. -        auto screenW = (GetSystemMetrics(SM_CXSCREEN) * 96) / dpi;

  583. -        auto screenH = (GetSystemMetrics(SM_CYSCREEN) * 96) / dpi;

  584. -        auto x = (screenW - w) / 2;

  585. -        auto y = (screenH - h) / 2;

  586. -        setBounds ({ x, y, w, h }, SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);

  587. -    }

  588. -

  589. -    void setBounds (Bounds b)

  590. -    {

  591. -        setBounds (b, SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);

  592. -    }

  593. -

  594. -    void setBounds (Bounds b, DWORD flags)

  595. -    {

  596. -        auto r = boundsToRect (scaleBounds (b, getWindowDPI() / 96.0));

  597. -        AdjustWindowRect (&r, WS_OVERLAPPEDWINDOW, 0);

  598. -        SetWindowPos (hwnd, nullptr, r.left, r.top, r.right - r.left, r.bottom - r.top, flags);

  599. -        resizeContentToFit();

  600. -    }

  601. -

  602. -    void toFront()

  603. -    {

  604. -        BringWindowToTop (hwnd);

  605. -    }

  606. -

  607. -private:

  608. -    DesktopWindow& owner;

  609. -    HWNDHolder hwnd;

  610. -    POINT minimumSize = {}, maximumSize = {};

  611. -    WindowClass windowClass { L"CHOCWindow", (WNDPROC) wndProc };

  612. -

  613. -    Bounds scaleBounds (Bounds b, double scale)

  614. -    {

  615. -        b.x      = static_cast<decltype(b.x)> (b.x * scale);

  616. -        b.y      = static_cast<decltype(b.y)> (b.y * scale);

  617. -        b.width  = static_cast<decltype(b.width)> (b.width * scale);

  618. -        b.height = static_cast<decltype(b.height)> (b.height * scale);

  619. -

  620. -        return b;

  621. -    }

  622. -

  623. -    HWND getFirstChildWindow()

  624. -    {

  625. -        HWND result = {};

  626. -

  627. -        if (IsWindow (hwnd))

  628. -        {

  629. -            EnumChildWindows (hwnd, +[](HWND w, LPARAM context)

  630. -            {

  631. -                *reinterpret_cast<HWND*> (context) = w;

  632. -                return FALSE;

  633. -            }, (LPARAM) &result);

  634. -        }

  635. -

  636. -        return result;

  637. -    }

  638. -

  639. -    void resizeContentToFit()

  640. -    {

  641. -        if (auto child = getFirstChildWindow())

  642. -        {

  643. -            RECT r;

  644. -            GetClientRect (hwnd, &r);

  645. -            SetWindowPos (child, nullptr, r.left, r.top, r.right - r.left, r.bottom - r.top,

  646. -                          SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE | SWP_FRAMECHANGED);

  647. -        }

  648. -    }

  649. -

  650. -    void handleClose()

  651. -    {

  652. -        if (owner.windowClosed != nullptr)

  653. -            owner.windowClosed();

  654. -    }

  655. -

  656. -    void handleSizeChange()

  657. -    {

  658. -        resizeContentToFit();

  659. -

  660. -        if (owner.windowResized != nullptr)

  661. -            owner.windowResized();

  662. -    }

  663. -

  664. -    static void enableNonClientDPIScaling (HWND h)

  665. -    {

  666. -        if (auto fn = getUser32Function<BOOL(__stdcall*)(HWND)> ("EnableNonClientDpiScaling"))

  667. -            fn (h);

  668. -    }

  669. -

  670. -    uint32_t getWindowDPI() const

  671. -    {

  672. -        if (auto getDpiForWindow = getUser32Function<UINT(__stdcall*)(HWND)> ("GetDpiForWindow"))

  673. -            return getDpiForWindow (hwnd);

  674. -

  675. -        return 96;

  676. -    }

  677. -

  678. -    static Pimpl* getPimpl (HWND h)     { return (Pimpl*) GetWindowLongPtr (h, GWLP_USERDATA); }

  679. -

  680. -    static LRESULT wndProc (HWND h, UINT msg, WPARAM wp, LPARAM lp)

  681. -    {

  682. -        switch (msg)

  683. -        {

  684. -            case WM_NCCREATE:        enableNonClientDPIScaling (h); break;

  685. -            case WM_SIZE:            if (auto w = getPimpl (h)) w->handleSizeChange(); break;

  686. -            case WM_CLOSE:           if (auto w = getPimpl (h)) w->handleClose(); return 0;

  687. -            case WM_GETMINMAXINFO:   if (auto w = getPimpl (h)) w->getMinMaxInfo (*(LPMINMAXINFO) lp); return 0;

  688. -            default:                 break;

  689. -        }

  690. -

  691. -        return DefWindowProcW (h, msg, wp, lp);

  692. -    }

  693. -};

  694. -

  695. -} // namespace choc::ui

  696. -

  697. -#else

  698. - #error "choc DesktopWindow only supports OSX, Windows or Linux!"

  699. -#endif

  700. -

  701. -namespace choc::ui

  702. -{

  703. -

  704. -//==============================================================================

  705. -inline DesktopWindow::DesktopWindow (Bounds b) { pimpl = std::make_unique<Pimpl> (*this, b); }

  706. -inline DesktopWindow::~DesktopWindow()  {}

  707. -

  708. -inline void* DesktopWindow::getWindowHandle() const                        { return pimpl->getWindowHandle(); }

  709. -inline void DesktopWindow::setContent (void* view)                         { pimpl->setContent (view); }

  710. -inline void DesktopWindow::setVisible (bool visible)                       { pimpl->setVisible (visible); }

  711. -inline void DesktopWindow::setWindowTitle (const std::string& title)       { pimpl->setWindowTitle (title); }

  712. -inline void DesktopWindow::setMinimumSize (int w, int h)                   { pimpl->setMinimumSize (w, h); }

  713. -inline void DesktopWindow::setMaximumSize (int w, int h)                   { pimpl->setMaximumSize (w, h); }

  714. -inline void DesktopWindow::setResizable (bool b)                           { pimpl->setResizable (b); }

  715. -inline void DesktopWindow::setClosable (bool b)                            { pimpl->setClosable (b); }

  716. -inline void DesktopWindow::setBounds (Bounds b)                            { pimpl->setBounds (b); }

  717. -inline void DesktopWindow::centreWithSize (int w, int h)                   { pimpl->centreWithSize (w, h); }

  718. -inline void DesktopWindow::toFront()                                       { pimpl->toFront(); }

  719. -

  720. -} // namespace choc::ui

  721. +END_NAMESPACE_DISTRHO

  722.  

  723.  #endif // CHOC_DESKTOPWINDOW_HEADER_INCLUDED

  724. diff --git a/choc_DynamicLibrary.h b/choc_DynamicLibrary.h

  725. index 85b2cfd..ef8c282 100644

  726. --- a/choc_DynamicLibrary.h

  727. +++ b/choc_DynamicLibrary.h

  728. @@ -21,8 +21,7 @@

  729.  

  730.  #include <string>

  731.  

  732. -namespace choc::file

  733. -{

  734. +START_NAMESPACE_DISTRHO

  735.  

  736.  //==============================================================================

  737.  /**

  738. @@ -87,38 +86,8 @@ inline DynamicLibrary& DynamicLibrary::operator= (DynamicLibrary&& other)

  739.      return *this;

  740.  }

  741.  

  742. -} // namespace choc::file

  743. -

  744. -#if ! (defined (_WIN32) || defined (_WIN64))

  745. -

  746. -#include <dlfcn.h>

  747. -

  748. -inline choc::file::DynamicLibrary::DynamicLibrary (std::string_view library)

  749. -{

  750. -    handle = ::dlopen (std::string (library).c_str(), RTLD_LOCAL | RTLD_NOW);

  751. -}

  752. -

  753. -inline void choc::file::DynamicLibrary::close()

  754. -{

  755. -    if (handle != nullptr)

  756. -    {

  757. -        ::dlclose (handle);

  758. -        handle = nullptr;

  759. -    }

  760. -}

  761. -

  762. -inline void* choc::file::DynamicLibrary::findFunction (std::string_view name)

  763. -{

  764. -    if (handle != nullptr)

  765. -        return ::dlsym (handle, std::string (name).c_str());

  766. -

  767. -    return {};

  768. -}

  769. -

  770. -#else

  771. -

  772.  //==============================================================================

  773. -namespace choc::win32_defs

  774. +namespace win32_defs

  775.  {

  776.  #if ! (defined (_WINDOWS_) || defined (_APISETLIBLOADER_)) // only use these local definitions if windows.h isn't already included

  777.    using CHOC_HMODULE = void*;

  778. @@ -145,12 +114,12 @@ namespace choc::win32_defs

  779.  #endif

  780.  }

  781.  

  782. -inline choc::file::DynamicLibrary::DynamicLibrary (std::string_view library)

  783. +inline DynamicLibrary::DynamicLibrary (std::string_view library)

  784.  {

  785.      handle = (void*) win32_defs::LoadLibraryA (std::string (library).c_str());

  786.  }

  787.  

  788. -inline void choc::file::DynamicLibrary::close()

  789. +inline void DynamicLibrary::close()

  790.  {

  791.      if (handle != nullptr)

  792.      {

  793. @@ -159,7 +128,7 @@ inline void choc::file::DynamicLibrary::close()

  794.      }

  795.  }

  796.  

  797. -inline void* choc::file::DynamicLibrary::findFunction (std::string_view name)

  798. +inline void* DynamicLibrary::findFunction (std::string_view name)

  799.  {

  800.      if (handle != nullptr)

  801.          return (void*) win32_defs::GetProcAddress ((win32_defs::CHOC_HMODULE) handle, std::string (name).c_str());

  802. @@ -167,6 +136,6 @@ inline void* choc::file::DynamicLibrary::findFunction (std::string_view name)

  803.      return {};

  804.  }

  805.  

  806. -#endif

  807. +END_NAMESPACE_DISTRHO

  808.  

  809.  #endif  // CHOC_DYNAMIC_LIBRARY_HEADER_INCLUDED

  810. diff --git a/choc_FloatToString.h b/choc_FloatToString.h

  811. index bf89933..586ecca 100644

  812. --- a/choc_FloatToString.h

  813. +++ b/choc_FloatToString.h

  814. @@ -21,7 +21,7 @@

  815.  

  816.  #include <cstring>

  817.  #include <string>

  818. -#include "../math/choc_MathHelpers.h"

  819. +#include "choc_MathHelpers.h"

  820.  

  821.  namespace choc::text

  822.  {

  823. diff --git a/choc_JSON.h b/choc_JSON.h

  824. index dbea379..617e2af 100644

  825. --- a/choc_JSON.h

  826. +++ b/choc_JSON.h

  827. @@ -26,7 +26,7 @@

  828.  

  829.  #include "choc_UTF8.h"

  830.  #include "choc_FloatToString.h"

  831. -#include "../containers/choc_Value.h"

  832. +#include "choc_Value.h"

  833.  

  834.  #undef max   // It's never a smart idea to include any C headers before your C++ ones, as it

  835.  #undef min   // risks polluting your namespace with all kinds of dangerous macros like these ones.

  836. diff --git a/choc_MemoryDLL.h b/choc_MemoryDLL.h

  837. index 00c3caa..f60eea1 100644

  838. --- a/choc_MemoryDLL.h

  839. +++ b/choc_MemoryDLL.h

  840. @@ -23,8 +23,7 @@

  841.  #include <memory>

  842.  #include <string>

  843.  

  844. -namespace choc::memory

  845. -{

  846. +START_NAMESPACE_DISTRHO

  847.  

  848.  /**

  849.      MemoryDLL is an egregious hack that allows you to load DLL files from a chunk

  850. @@ -62,7 +61,7 @@ private:

  851.      std::unique_ptr<Pimpl> pimpl;

  852.  };

  853.  

  854. -} // namespace choc::memory

  855. +END_NAMESPACE_DISTRHO

  856.  

  857.  

  858.  

  859. @@ -77,8 +76,6 @@ private:

  860.  //

  861.  //==============================================================================

  862.  

  863. -#if defined (_WIN32) || defined (_WIN64)

  864. -

  865.  #include <vector>

  866.  #include <unordered_map>

  867.  #undef WIN32_LEAN_AND_MEAN

  868. @@ -89,8 +86,7 @@ private:

  869.  #include <windows.h>

  870.  #undef Rectangle

  871.  

  872. -namespace choc::memory

  873. -{

  874. +START_NAMESPACE_DISTRHO

  875.  

  876.  struct MemoryDLL::Pimpl

  877.  {

  878. @@ -497,20 +493,6 @@ private:

  879.      }

  880.  };

  881.  

  882. -#else

  883. -

  884. -#include "choc_Assert.h"

  885. -

  886. -namespace choc::memory

  887. -{

  888. -struct MemoryDLL::Pimpl

  889. -{

  890. -    bool initialise (const void*, size_t)   { CHOC_ASSERT (false); return {}; } // Only available on Windows!

  891. -    void* findFunction (std::string_view)   { CHOC_ASSERT (false); return {}; } // Only available on Windows!

  892. -};

  893. -

  894. -#endif

  895. -

  896.  inline MemoryDLL::~MemoryDLL() = default;

  897.  

  898.  inline MemoryDLL::MemoryDLL (const void* data, size_t size) : pimpl (std::make_unique<Pimpl>())

  899. @@ -524,6 +506,6 @@ inline void* MemoryDLL::findFunction (std::string_view name)

  900.      return pimpl != nullptr ? pimpl->findFunction (name) : nullptr;

  901.  }

  902.  

  903. -} // namespace choc::memory

  904. +END_NAMESPACE_DISTRHO

  905.  

  906.  #endif // CHOC_MEMORYDLL_HEADER_INCLUDED

  907. diff --git a/choc_StringUtilities.h b/choc_StringUtilities.h

  908. index 3122f83..4cd54c6 100644

  909. --- a/choc_StringUtilities.h

  910. +++ b/choc_StringUtilities.h

  911. @@ -27,125 +27,14 @@

  912.  #include <memory>

  913.  #include <algorithm>

  914.  #include <cwctype>

  915. -#include "../platform/choc_Assert.h"

  916.  

  917. -namespace choc::text

  918. -{

  919. +START_NAMESPACE_DISTRHO

  920.  

  921.  //==============================================================================

  922. -inline bool isWhitespace (char c)                               { return c == ' ' || (c <= 13 && c >= 9); }

  923. -inline bool isDigit (char c)                                    { return static_cast<uint32_t> (c - '0') < 10; }

  924. -

  925. -/// Replaces all occurrences of a one or more substrings.

  926. -/// The arguments must be a sequence of pairs of strings, where the first of each pair is the string to

  927. -/// look for, followed by its replacement.

  928. -template <typename StringType, typename... OtherReplacements>

  929. -std::string replace (StringType textToSearch,

  930. -                     std::string_view firstSubstringToReplace, std::string_view firstReplacement,

  931. -                     OtherReplacements&&... otherPairsOfStringsToReplace);

  932. -

  933. -/// Returns a string with any whitespace trimmed from its start and end.

  934. -std::string trim (std::string textToTrim);

  935. -

  936. -/// Returns a string with any whitespace trimmed from its start and end.

  937. -std::string_view trim (std::string_view textToTrim);

  938. -

  939. -/// Returns a string with any whitespace trimmed from its start and end.

  940. -std::string_view trim (const char* textToTrim);

  941. -

  942. -/// Returns a string with any whitespace trimmed from its start.

  943. -std::string trimStart (std::string textToTrim);

  944. -

  945. -/// Returns a string with any whitespace trimmed from its start.

  946. -std::string_view trimStart (std::string_view textToTrim);

  947. -

  948. -/// Returns a string with any whitespace trimmed from its start.

  949. -std::string_view trimStart (const char* textToTrim);

  950. -

  951. -/// Returns a string with any whitespace trimmed from its end.

  952. -std::string trimEnd (std::string textToTrim);

  953. -

  954. -/// Returns a string with any whitespace trimmed from its end.

  955. -std::string_view trimEnd (std::string_view textToTrim);

  956. -

  957. -/// Returns a string with any whitespace trimmed from its end.

  958. -std::string_view trimEnd (const char* textToTrim);

  959. -

  960. -/// If the string begins with one or more instances of the given character, this

  961. -/// skips past them, returning the remainder of the string.

  962. -std::string_view trimCharacterAtStart (std::string_view textToTrim, char characterToSkip);

  963. -

  964. -/// If the given character is at the start and end of the string, it trims it away.

  965. -std::string removeOuterCharacter (std::string text, char outerChar);

  966. -

  967. -inline std::string removeDoubleQuotes (std::string text)       { return removeOuterCharacter (std::move (text), '"'); }

  968. -inline std::string removeSingleQuotes (std::string text)       { return removeOuterCharacter (std::move (text), '\''); }

  969. -

  970. -inline std::string addDoubleQuotes (std::string text)          { return "\"" + std::move (text) + "\""; }

  971. -inline std::string addSingleQuotes (std::string text)          { return "'" + std::move (text) + "'"; }

  972. -

  973. -std::string toLowerCase (std::string);

  974. -std::string toUpperCase (std::string);

  975. -

  976. -template <typename IsDelimiterChar>

  977. -std::vector<std::string> splitString (std::string_view textToSplit,

  978. -                                      IsDelimiterChar&& isDelimiterChar,

  979. -                                      bool includeDelimitersInResult);

  980. -

  981. -template <typename CharStartsDelimiter, typename CharIsInDelimiterBody>

  982. -std::vector<std::string> splitString (std::string_view textToSplit,

  983. -                                      CharStartsDelimiter&& isDelimiterStart,

  984. -                                      CharIsInDelimiterBody&& isDelimiterBody,

  985. -                                      bool includeDelimitersInResult);

  986. -

  987. -std::vector<std::string> splitString (std::string_view textToSplit,

  988. -                                      char delimiterCharacter,

  989. -                                      bool includeDelimitersInResult);

  990. -

  991. -std::vector<std::string> splitAtWhitespace (std::string_view text, bool keepDelimiters = false);

  992. -

  993. -/// Splits a string at newline characters, returning an array of strings.

  994. -std::vector<std::string> splitIntoLines (std::string_view text, bool includeNewLinesInResult);

  995. -

  996. -/// Joins some kind of array of strings into a single string, adding the given separator

  997. -/// between them (but not adding it at the start or end)

  998. -template <typename ArrayOfStrings>

  999. -std::string joinStrings (const ArrayOfStrings& strings, std::string_view separator);

  1000. -

  1001. -/// Returns true if this text contains the given sub-string.

  1002. -bool contains (std::string_view text, std::string_view possibleSubstring);

  1003. -/// Returns true if this text starts with the given character.

  1004. -bool startsWith (std::string_view text, char possibleStart);

  1005. -/// Returns true if this text starts with the given sub-string.

  1006. -bool startsWith (std::string_view text, std::string_view possibleStart);

  1007. -/// Returns true if this text ends with the given sub-string.

  1008. -bool endsWith (std::string_view text, char possibleEnd);

  1009. -/// Returns true if this text ends with the given sub-string.

  1010. -bool endsWith (std::string_view text, std::string_view possibleEnd);

  1011. -

  1012. -/// Calculates the Levenstein distance between two strings.

  1013. -template <typename StringType>

  1014. -size_t getLevenshteinDistance (const StringType& string1,

  1015. -                               const StringType& string2);

  1016. -

  1017. -/// Converts a hex character to a number 0-15, or -1 if it's not a valid hex digit.

  1018. -int hexDigitToInt (uint32_t unicodeChar);

  1019. -

  1020.  /// Returns a hex string for the given value.

  1021.  /// If the minimum number of digits is non-zero, it will be zero-padded to fill this length;

  1022.  template <typename IntegerType>

  1023. -std::string createHexString (IntegerType value, int minNumDigits = 0);

  1024. -

  1025. -/// Returns a truncated, easy-to-read version of a time as hours, seconds or milliseconds,

  1026. -/// depending on its magnitude. The use-cases include things like logging or console app output.

  1027. -std::string getDurationDescription (std::chrono::duration<double, std::micro>);

  1028. -

  1029. -/// Returns an easy-to-read description of a size in bytes. Depending on the magnitude,

  1030. -/// it might choose different units such as GB, MB, KB or just bytes.

  1031. -std::string getByteSizeDescription (uint64_t sizeInBytes);

  1032. -

  1033. -/// Encodes a string as a legal URI, using percent-encoding (aka URL encoding)

  1034. -std::string percentEncodeURI (std::string_view text);

  1035. +std::string createHexString (IntegerType value);

  1036.  

  1037.  

  1038.  //==============================================================================

  1039. @@ -159,20 +48,11 @@ std::string percentEncodeURI (std::string_view text);

  1040.  //

  1041.  //==============================================================================

  1042.  

  1043. -inline int hexDigitToInt (uint32_t c)

  1044. -{

  1045. -    auto d1 = c -  static_cast<uint32_t> ('0');         if (d1 < 10u)  return static_cast<int> (d1);

  1046. -    auto d2 = d1 + static_cast<uint32_t> ('0' - 'a');   if (d2 < 6u)   return static_cast<int> (d2 + 10);

  1047. -    auto d3 = d2 + static_cast<uint32_t> ('a' - 'A');   if (d3 < 6u)   return static_cast<int> (d3 + 10);

  1048. -    return -1;

  1049. -}

  1050. -

  1051.  template <typename IntegerType>

  1052. -std::string createHexString (IntegerType v, int minNumDigits)

  1053. +std::string createHexString (IntegerType v)

  1054.  {

  1055.      static_assert (std::is_integral<IntegerType>::value, "Need to pass integers into this method");

  1056.      auto value = static_cast<typename std::make_unsigned<IntegerType>::type> (v);

  1057. -    CHOC_ASSERT (minNumDigits <= 32);

  1058.  

  1059.      char hex[40];

  1060.      const auto end = hex + sizeof (hex) - 1;

  1061. @@ -183,415 +63,12 @@ std::string createHexString (IntegerType v, int minNumDigits)

  1062.      {

  1063.          *--d = "0123456789abcdef"[static_cast<uint32_t> (value) & 15u];

  1064.          value = static_cast<decltype (value)> (value >> 4);

  1065. -        --minNumDigits;

  1066.  

  1067. -        if (value == 0 && minNumDigits <= 0)

  1068. +        if (value == 0)

  1069.              return std::string (d, end);

  1070.      }

  1071.  }

  1072.  

  1073. -template <typename StringType, typename... OtherReplacements>

  1074. -std::string replace (StringType textToSearch, std::string_view firstToReplace, std::string_view firstReplacement,

  1075. -                     OtherReplacements&&... otherPairsOfStringsToReplace)

  1076. -{

  1077. -    static_assert ((sizeof... (otherPairsOfStringsToReplace) & 1u) == 0,

  1078. -                   "This function expects a list of pairs of strings as its arguments");

  1079. -

  1080. -    if constexpr (std::is_same<const StringType, const std::string_view>::value || std::is_same<const StringType, const char* const>::value)

  1081. -    {

  1082. -        return replace (std::string (textToSearch), firstToReplace, firstReplacement,

  1083. -                        std::forward<OtherReplacements> (otherPairsOfStringsToReplace)...);

  1084. -    }

  1085. -    else if constexpr (sizeof... (otherPairsOfStringsToReplace) == 0)

  1086. -    {

  1087. -        size_t pos = 0;

  1088. -

  1089. -        for (;;)

  1090. -        {

  1091. -            pos = textToSearch.find (firstToReplace, pos);

  1092. -

  1093. -            if (pos == std::string::npos)

  1094. -                return textToSearch;

  1095. -

  1096. -            textToSearch.replace (pos, firstToReplace.length(), firstReplacement);

  1097. -            pos += firstReplacement.length();

  1098. -        }

  1099. -    }

  1100. -    else

  1101. -    {

  1102. -        return replace (replace (std::move (textToSearch), firstToReplace, firstReplacement),

  1103. -                        std::forward<OtherReplacements> (otherPairsOfStringsToReplace)...);

  1104. -    }

  1105. -}

  1106. -

  1107. -inline std::string      trim (std::string      text)    { return trimStart (trimEnd (std::move (text))); }

  1108. -inline std::string_view trim (std::string_view text)    { return trimStart (trimEnd (std::move (text))); }

  1109. -

  1110. -inline std::string_view trim      (const char* text)    { return trim      (std::string_view (text)); }

  1111. -inline std::string_view trimStart (const char* text)    { return trimStart (std::string_view (text)); }

  1112. -inline std::string_view trimEnd   (const char* text)    { return trimEnd   (std::string_view (text)); }

  1113. -

  1114. -inline std::string trimStart (std::string text)

  1115. -{

  1116. -    auto i = text.begin();

  1117. -

  1118. -    if (i == text.end())        return {};

  1119. -    if (! isWhitespace (*i))    return text;

  1120. -

  1121. -    for (;;)

  1122. -    {

  1123. -        ++i;

  1124. -

  1125. -        if (i == text.end())        return {};

  1126. -        if (! isWhitespace (*i))    return { i, text.end() };

  1127. -    }

  1128. -}

  1129. -

  1130. -inline std::string_view trimStart (std::string_view text)

  1131. -{

  1132. -    size_t i = 0;

  1133. -

  1134. -    for (auto c : text)

  1135. -    {

  1136. -        if (! isWhitespace (c))

  1137. -        {

  1138. -            text.remove_prefix (i);

  1139. -            return text;

  1140. -        }

  1141. -

  1142. -        ++i;

  1143. -    }

  1144. -

  1145. -    return {};

  1146. -}

  1147. -

  1148. -inline std::string trimEnd (std::string text)

  1149. -{

  1150. -    for (auto i = text.end();;)

  1151. -    {

  1152. -        if (i == text.begin())

  1153. -            return {};

  1154. -

  1155. -        --i;

  1156. -

  1157. -        if (! isWhitespace (*i))

  1158. -        {

  1159. -            text.erase (i + 1, text.end());

  1160. -            return text;

  1161. -        }

  1162. -    }

  1163. -}

  1164. -

  1165. -inline std::string_view trimEnd (std::string_view text)

  1166. -{

  1167. -    for (auto i = text.length(); i != 0; --i)

  1168. -        if (! isWhitespace (text[i - 1]))

  1169. -            return text.substr (0, i);

  1170. -

  1171. -    return {};

  1172. -}

  1173. -

  1174. -inline std::string_view trimCharacterAtStart (std::string_view textToTrim, char characterToSkip)

  1175. -{

  1176. -    for (size_t i = 0; i < textToTrim.length(); ++i)

  1177. -        if (textToTrim[i] != characterToSkip)

  1178. -            return textToTrim.substr (i);

  1179. -

  1180. -    return {};

  1181. -}

  1182. -

  1183. -inline std::string removeOuterCharacter (std::string t, char outerChar)

  1184. -{

  1185. -    if (t.length() >= 2 && t.front() == outerChar && t.back() == outerChar)

  1186. -        return t.substr (1, t.length() - 2);

  1187. -

  1188. -    return t;

  1189. -}

  1190. -

  1191. -inline std::string toLowerCase (std::string s)

  1192. -{

  1193. -    std::transform (s.begin(), s.end(), s.begin(), [] (auto c) { return static_cast<char> (std::tolower (static_cast<unsigned char> (c))); });

  1194. -    return s;

  1195. -}

  1196. -

  1197. -inline std::string toUpperCase (std::string s)

  1198. -{

  1199. -    std::transform (s.begin(), s.end(), s.begin(), [] (auto c) { return static_cast<char> (std::toupper (static_cast<unsigned char> (c))); });

  1200. -    return s;

  1201. -}

  1202. -

  1203. -template <typename CharStartsDelimiter, typename CharIsInDelimiterBody>

  1204. -std::vector<std::string> splitString (std::string_view source,

  1205. -                                      CharStartsDelimiter&& isDelimiterStart,

  1206. -                                      CharIsInDelimiterBody&& isDelimiterBody,

  1207. -                                      bool keepDelimiters)

  1208. -{

  1209. -    std::vector<std::string> tokens;

  1210. -    auto tokenStart = source.begin();

  1211. -    auto pos = tokenStart;

  1212. -

  1213. -    while (pos != source.end())

  1214. -    {

  1215. -        if (isDelimiterStart (*pos))

  1216. -        {

  1217. -            auto delimiterStart = pos++;

  1218. -

  1219. -            while (pos != source.end() && isDelimiterBody (*pos))

  1220. -                ++pos;

  1221. -

  1222. -            if (pos != source.begin())

  1223. -                tokens.push_back ({ tokenStart, keepDelimiters ? pos : delimiterStart });

  1224. -

  1225. -            tokenStart = pos;

  1226. -        }

  1227. -        else

  1228. -        {

  1229. -            ++pos;

  1230. -        }

  1231. -    }

  1232. -

  1233. -    if (pos != source.begin())

  1234. -        tokens.push_back ({ tokenStart, pos });

  1235. -

  1236. -    return tokens;

  1237. -}

  1238. -

  1239. -template <typename IsDelimiterChar>

  1240. -std::vector<std::string> splitString (std::string_view source, IsDelimiterChar&& isDelimiterChar, bool keepDelimiters)

  1241. -{

  1242. -    std::vector<std::string> tokens;

  1243. -    auto tokenStart = source.begin();

  1244. -    auto pos = tokenStart;

  1245. -

  1246. -    while (pos != source.end())

  1247. -    {

  1248. -        if (isDelimiterChar (*pos))

  1249. -        {

  1250. -            tokens.push_back ({ tokenStart, keepDelimiters ? pos + 1 : pos });

  1251. -            tokenStart = ++pos;

  1252. -        }

  1253. -        else

  1254. -        {

  1255. -            ++pos;

  1256. -        }

  1257. -    }

  1258. -

  1259. -    if (pos != source.begin())

  1260. -        tokens.push_back ({ tokenStart, pos });

  1261. -

  1262. -    return tokens;

  1263. -}

  1264. -

  1265. -inline std::vector<std::string> splitString (std::string_view text, char delimiterCharacter, bool keepDelimiters)

  1266. -{

  1267. -    return splitString (text, [=] (char c) { return c == delimiterCharacter; }, keepDelimiters);

  1268. -}

  1269. -

  1270. -inline std::vector<std::string> splitAtWhitespace (std::string_view text, bool keepDelimiters)

  1271. -{

  1272. -    return splitString (text,

  1273. -                        [] (char c) { return isWhitespace (c); },

  1274. -                        [] (char c) { return isWhitespace (c); },

  1275. -                        keepDelimiters);

  1276. -}

  1277. -

  1278. -inline std::vector<std::string> splitIntoLines (std::string_view text, bool includeNewLinesInResult)

  1279. -{

  1280. -    return splitString (text, '\n', includeNewLinesInResult);

  1281. -}

  1282. -

  1283. -template <typename ArrayOfStrings>

  1284. -inline std::string joinStrings (const ArrayOfStrings& strings, std::string_view sep)

  1285. -{

  1286. -    if (strings.empty())

  1287. -        return {};

  1288. -

  1289. -    auto spaceNeeded = sep.length() * strings.size();

  1290. -

  1291. -    for (auto& s : strings)

  1292. -        spaceNeeded += s.length();

  1293. -

  1294. -    std::string result (strings.front());

  1295. -    result.reserve (spaceNeeded);

  1296. -

  1297. -    for (size_t i = 1; i < strings.size(); ++i)

  1298. -    {

  1299. -        result += sep;

  1300. -        result += strings[i];

  1301. -    }

  1302. -

  1303. -    return result;

  1304. -}

  1305. -

  1306. -inline bool contains   (std::string_view t, std::string_view s)   { return t.find (s) != std::string::npos; }

  1307. -inline bool startsWith (std::string_view t, char s)               { return ! t.empty() && t.front() == s; }

  1308. -inline bool endsWith   (std::string_view t, char s)               { return ! t.empty() && t.back()  == s; }

  1309. -

  1310. -inline bool startsWith (std::string_view t, std::string_view s)

  1311. -{

  1312. -    auto len = s.length();

  1313. -    return t.length() >= len && t.substr (0, len) == s;

  1314. -}

  1315. -

  1316. -inline bool endsWith (std::string_view t, std::string_view s)

  1317. -{

  1318. -    auto len1 = t.length(), len2 = s.length();

  1319. -    return len1 >= len2 && t.substr (len1 - len2) == s;

  1320. -}

  1321. -

  1322. -inline std::string getDurationDescription (std::chrono::duration<double, std::micro> d)

  1323. -{

  1324. -    auto microseconds = std::chrono::duration_cast<std::chrono::microseconds> (d).count();

  1325. -

  1326. -    if (microseconds < 0)    return "-" + getDurationDescription (-d);

  1327. -    if (microseconds == 0)   return "0 sec";

  1328. -

  1329. -    std::string result;

  1330. -

  1331. -    auto addLevel = [&] (int64_t size, std::string_view units, int64_t decimalScale, int64_t modulo) -> bool

  1332. -    {

  1333. -        if (microseconds < size)

  1334. -            return false;

  1335. -

  1336. -        if (! result.empty())

  1337. -            result += ' ';

  1338. -

  1339. -        auto scaled = (microseconds * decimalScale + size / 2) / size;

  1340. -        auto whole = scaled / decimalScale;

  1341. -

  1342. -        if (modulo != 0)

  1343. -            whole = whole % modulo;

  1344. -

  1345. -        result += std::to_string (whole);

  1346. -

  1347. -        if (auto fraction = scaled % decimalScale)

  1348. -        {

  1349. -            result += '.';

  1350. -            result += static_cast<char> ('0' + (fraction / 10));

  1351. -

  1352. -            if (fraction % 10 != 0)

  1353. -                result += static_cast<char> ('0' + (fraction % 10));

  1354. -        }

  1355. -

  1356. -        result += (whole == 1 && units.length() > 3 && units.back() == 's') ? units.substr (0, units.length() - 1) : units;

  1357. -        return true;

  1358. -    };

  1359. -

  1360. -    bool hours = addLevel (60000000ll * 60ll, " hours", 1, 0);

  1361. -    bool mins  = addLevel (60000000ll,        " min", 1, hours ? 60 : 0);

  1362. -

  1363. -    if (hours)

  1364. -        return result;

  1365. -

  1366. -    if (mins)

  1367. -    {

  1368. -        addLevel (1000000, " sec", 1, 60);

  1369. -    }

  1370. -    else

  1371. -    {

  1372. -        if (! addLevel (1000000,   " sec", 100, 0))

  1373. -            if (! addLevel (1000,  " ms", 100, 0))

  1374. -                addLevel (1,       " microseconds", 100, 0);

  1375. -    }

  1376. -

  1377. -    return result;

  1378. -}

  1379. -

  1380. -template <typename StringType>

  1381. -size_t getLevenshteinDistance (const StringType& string1, const StringType& string2)

  1382. -{

  1383. -    if (string1.empty())  return string2.length();

  1384. -    if (string2.empty())  return string1.length();

  1385. -

  1386. -    auto calculate = [] (size_t* costs, size_t numCosts, const StringType& s1, const StringType& s2) -> size_t

  1387. -    {

  1388. -        for (size_t i = 0; i < numCosts; ++i)

  1389. -            costs[i] = i;

  1390. -

  1391. -        size_t p1 = 0;

  1392. -

  1393. -        for (auto c1 : s1)

  1394. -        {

  1395. -            auto corner = p1;

  1396. -            *costs = p1 + 1;

  1397. -            size_t p2 = 0;

  1398. -

  1399. -            for (auto c2 : s2)

  1400. -            {

  1401. -                auto upper = costs[p2 + 1];

  1402. -                costs[p2 + 1] = c1 == c2 ? corner : (std::min (costs[p2], std::min (upper, corner)) + 1);

  1403. -                ++p2;

  1404. -                corner = upper;

  1405. -            }

  1406. -

  1407. -            ++p1;

  1408. -        }

  1409. -

  1410. -        return costs[numCosts - 1];

  1411. -    };

  1412. -

  1413. -    auto sizeNeeded = string2.length() + 1;

  1414. -    constexpr size_t maxStackSize = 96;

  1415. -

  1416. -    if (sizeNeeded <= maxStackSize)

  1417. -    {

  1418. -        size_t costs[maxStackSize];

  1419. -        return calculate (costs, sizeNeeded, string1, string2);

  1420. -    }

  1421. -

  1422. -    std::unique_ptr<size_t[]> costs (new size_t[sizeNeeded]);

  1423. -    return calculate (costs.get(), sizeNeeded, string1, string2);

  1424. -}

  1425. -

  1426. -inline std::string getByteSizeDescription (uint64_t size)

  1427. -{

  1428. -    auto intToStringWith1DecPlace = [] (uint64_t n, uint64_t divisor) -> std::string

  1429. -    {

  1430. -        auto scaled = (n * 10 + divisor / 2) / divisor;

  1431. -        auto result = std::to_string (scaled / 10);

  1432. -

  1433. -        if (auto fraction = scaled % 10)

  1434. -        {

  1435. -            result += '.';

  1436. -            result += static_cast<char> ('0' + fraction);

  1437. -        }

  1438. -

  1439. -        return result;

  1440. -    };

  1441. -

  1442. -    static constexpr uint64_t maxValue = std::numeric_limits<uint64_t>::max() / 10;

  1443. -

  1444. -    if (size >= 0x40000000)  return intToStringWith1DecPlace (std::min (maxValue, size), 0x40000000) + " GB";

  1445. -    if (size >= 0x100000)    return intToStringWith1DecPlace (size, 0x100000) + " MB";

  1446. -    if (size >= 0x400)       return intToStringWith1DecPlace (size, 0x400)    + " KB";

  1447. -    if (size != 1)           return std::to_string (size) + " bytes";

  1448. -

  1449. -    return "1 byte";

  1450. -}

  1451. -

  1452. -inline std::string percentEncodeURI (std::string_view text)

  1453. -{

  1454. -    std::string result;

  1455. -    result.reserve (text.length());

  1456. -

  1457. -    for (auto c : text)

  1458. -    {

  1459. -        if (std::string_view ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-.~").find (c) != std::string_view::npos)

  1460. -        {

  1461. -            result += c;

  1462. -        }

  1463. -        else

  1464. -        {

  1465. -            result += '%';

  1466. -            result += "0123456789abcdef"[static_cast<uint8_t> (c) >> 4];

  1467. -            result += "0123456789abcdef"[static_cast<uint8_t> (c) & 15u];

  1468. -        }

  1469. -    }

  1470. -

  1471. -    return result;

  1472. -}

  1473. -

  1474. -

  1475. -} // namespace choc::text

  1476. +END_NAMESPACE_DISTRHO

  1477.  

  1478.  #endif

  1479. diff --git a/choc_Value.h b/choc_Value.h

  1480. index bd27f7a..5df22c4 100644

  1481. --- a/choc_Value.h

  1482. +++ b/choc_Value.h

  1483. @@ -25,7 +25,7 @@

  1484.  #include <algorithm>

  1485.  #include <memory>

  1486.  #include <exception>

  1487. -#include "../platform/choc_Assert.h"

  1488. +#include "choc_Assert.h"

  1489.  

  1490.  namespace choc::value

  1491.  {

  1492. diff --git a/choc_WebView.h b/choc_WebView.h

  1493. index 3ddf610..935dce1 100644

  1494. --- a/choc_WebView.h

  1495. +++ b/choc_WebView.h

  1496. @@ -23,46 +23,18 @@

  1497.  #include <unordered_map>

  1498.  #include <vector>

  1499.  #include <functional>

  1500. -#include "../platform/choc_Platform.h"

  1501. -#include "../text/choc_JSON.h"

  1502. +#include <memory>

  1503. +#include <string>

  1504. +#include "choc_Platform.h"

  1505. +#include "choc_StringUtilities.h"

  1506.  

  1507. -//==============================================================================

  1508. -namespace choc::ui

  1509. -{

  1510. +START_NAMESPACE_DISTRHO

  1511.  

  1512.  /**

  1513.      Creates an embedded browser which can be placed inside some kind of parent window.

  1514.  

  1515.      After creating a WebView object, its getViewHandle() returns a platform-specific

  1516. -    handle that can be added to whatever kind of window is appropriate. The

  1517. -    choc::ui::DesktopWindow class is an example of a window that can have the

  1518. -    webview added to it via its choc::ui::DesktopWindow::setContent() method.

  1519. -

  1520. -    There are unfortunately a few extra build steps needed for using WebView

  1521. -    in your projects:

  1522. -

  1523. -    - On OSX, you'll need to add the `WebKit` framework to your project

  1524. -

  1525. -    - On Linux, you'll need to:

  1526. -       1. Install the libgtk-3-dev and libwebkit2gtk-4.0-dev packages.

  1527. -       2. Link the gtk+3.0 and webkit2gtk-4.0 libraries in your build.

  1528. -          You might want to have a look inside choc/tests/CMakeLists.txt for

  1529. -          an example of how to add those packages to your build without too

  1530. -          much fuss.

  1531. -

  1532. -    - On Windows, no extra build steps needed!! This is a bigger deal than it

  1533. -      sounds, because normally to use an embedded Edge browser on Windows is a

  1534. -      total PITA, involving downloading a special Microsoft SDK with redistributable

  1535. -      DLLs, etc, but I've jumped through many ugly hoops to make this class

  1536. -      fully self-contained.

  1537. -

  1538. -    Because this is a GUI, it needs a message loop to be running. If you're using

  1539. -    it inside an app which already runs a message loop, it should just work,

  1540. -    or you can use choc::messageloop::run() and choc::messageloop::stop() for an easy

  1541. -    but basic loop.

  1542. -

  1543. -    For an example of how to use this class, see `choc/tests/main.cpp` where

  1544. -    there's a simple demo.

  1545. +    handle that can be added to whatever kind of window is appropriate.

  1546.  */

  1547.  class WebView

  1548.  {

  1549. @@ -82,34 +54,6 @@ public:

  1550.          // this empty for default behaviour.

  1551.          std::string customUserAgent;

  1552.  

  1553. -        /// If you provide a fetchResource function, it is expected to return this

  1554. -        /// object, which is simply the raw content of the resource, and its MIME type.

  1555. -        struct Resource

  1556. -        {

  1557. -            Resource() = default;

  1558. -            Resource (std::string_view content, std::string mimeType);

  1559. -

  1560. -            std::vector<uint8_t> data;

  1561. -            std::string mimeType;

  1562. -        };

  1563. -

  1564. -        using FetchResource = std::function<std::optional<Resource>(const std::string& path)>;

  1565. -

  1566. -        /// Serve resources to the browser from a C++ callback function.

  1567. -        /// This can effectively be used to implement a basic web server,

  1568. -        /// serving resources to the browser in any way the client code chooses.

  1569. -        /// Given the path URL component (i.e. starting from "/"), the client should

  1570. -        /// return some bytes, and the associated MIME type, for that resource.

  1571. -        /// When provided, this function will initially be called with the root path

  1572. -        /// ("/") in order to serve the initial content for the page (or if the

  1573. -        /// customSchemeURI property is also set, it will navigate to that URI).

  1574. -        /// When this happens, the client should return some HTML with a "text/html"

  1575. -        /// MIME type.

  1576. -        /// Subsequent relative requests made from the page (e.g. via `img` tags,

  1577. -        /// `fetch` calls from javascript etc) will all invoke calls to this callback

  1578. -        /// with the requested path as their argument.

  1579. -        FetchResource fetchResource;

  1580. -

  1581.          /// If fetchResource is being used to serve custom data, you can choose to

  1582.          /// override the default URI scheme by providing a home URI here, e.g. if

  1583.          /// you wanted a scheme called `foo:`, you might set this to `foo://myname.com`

  1584. @@ -132,31 +76,18 @@ public:

  1585.      /// fail on some systems if the OS doesn't provide a suitable component.

  1586.      bool loadedOK() const;

  1587.  

  1588. -    /// Directly sets the HTML content of the browser

  1589. -    bool setHTML (const std::string& html);

  1590. -

  1591. -    /// This function type is used by evaluateJavascript().

  1592. -    using CompletionHandler = std::function<void(const std::string& error,

  1593. -                                                 const choc::value::ValueView& result)>;

  1594. -

  1595.      /// Asynchronously evaluates some javascript.

  1596. -    /// If you want to find out the result of the expression (or whether there

  1597. -    /// was a compile error etc), then provide a callback function which will be

  1598. -    /// invoked when the script is complete.

  1599.      /// This will return true if the webview is in a state that lets it run code, or

  1600.      /// false if something prevents that.

  1601. -    bool evaluateJavascript (const std::string& script, CompletionHandler completionHandler = {});

  1602. +    bool evaluateJavascript (const std::string& script);

  1603.  

  1604.      /// Sends the browser to this URL

  1605.      bool navigate (const std::string& url);

  1606.  

  1607.      /// A callback function which can be passed to bind().

  1608. -    using CallbackFn = std::function<choc::value::Value(const choc::value::ValueView& args)>;

  1609. -    /// Binds a C++ function to a named javascript function that can be called

  1610. -    /// by code running in the browser.

  1611. -    bool bind (const std::string& functionName, CallbackFn&& function);

  1612. -    /// Removes a previously-bound function.

  1613. -    bool unbind (const std::string& functionName);

  1614. +    using CallbackFn = std::function<void(const std::string& msg)>;

  1615. +    /// Set the C++ callback function.

  1616. +    bool bind (CallbackFn&& function);

  1617.  

  1618.      /// Adds a script to run when the browser loads a page

  1619.      bool addInitScript (const std::string& script);

  1620. @@ -169,14 +100,11 @@ private:

  1621.      struct Pimpl;

  1622.      std::unique_ptr<Pimpl> pimpl;

  1623.  

  1624. -    std::unordered_map<std::string, CallbackFn> bindings;

  1625. +    CallbackFn binding {};

  1626.      void invokeBinding (const std::string&);

  1627. -    static std::string getURIScheme (const Options&);

  1628. -    static std::string getURIHome (const Options&);

  1629. -    struct DeletionChecker { bool deleted = false; };

  1630.  };

  1631.  

  1632. -} // namespace choc::ui

  1633. +END_NAMESPACE_DISTRHO

  1634.  

  1635.  

  1636.  //==============================================================================

  1637. @@ -190,737 +118,14 @@ private:

  1638.  //

  1639.  //==============================================================================

  1640.  

  1641. -#if CHOC_LINUX

  1642. -

  1643. -#include "../platform/choc_DisableAllWarnings.h"

  1644. -#include <JavaScriptCore/JavaScript.h>

  1645. -#include <webkit2/webkit2.h>

  1646. -#include "../platform/choc_ReenableAllWarnings.h"

  1647. -

  1648. -struct choc::ui::WebView::Pimpl

  1649. -{

  1650. -    Pimpl (WebView& v, const Options& options)

  1651. -        : owner (v), fetchResource (options.fetchResource)

  1652. -    {

  1653. -        if (! gtk_init_check (nullptr, nullptr))

  1654. -            return;

  1655. -

  1656. -        defaultURI = getURIHome (options);

  1657. -        webviewContext = webkit_web_context_new();

  1658. -        g_object_ref_sink (G_OBJECT (webviewContext));

  1659. -        webview = webkit_web_view_new_with_context (webviewContext);

  1660. -        g_object_ref_sink (G_OBJECT (webview));

  1661. -        manager = webkit_web_view_get_user_content_manager (WEBKIT_WEB_VIEW (webview));

  1662. -

  1663. -        signalHandlerID = g_signal_connect (manager, "script-message-received::external",

  1664. -                                            G_CALLBACK (+[] (WebKitUserContentManager*, WebKitJavascriptResult* r, gpointer arg)

  1665. -                                            {

  1666. -                                                static_cast<Pimpl*> (arg)->invokeCallback (r);

  1667. -                                            }),

  1668. -                                            this);

  1669. -

  1670. -        webkit_user_content_manager_register_script_message_handler (manager, "external");

  1671. -

  1672. -        WebKitSettings* settings = webkit_web_view_get_settings (WEBKIT_WEB_VIEW (webview));

  1673. -        webkit_settings_set_javascript_can_access_clipboard (settings, true);

  1674. -

  1675. -        if (options.enableDebugMode)

  1676. -        {

  1677. -            webkit_settings_set_enable_write_console_messages_to_stdout (settings, true);

  1678. -            webkit_settings_set_enable_developer_extras (settings, true);

  1679. -

  1680. -            if (auto inspector = WEBKIT_WEB_INSPECTOR (webkit_web_view_get_inspector (WEBKIT_WEB_VIEW (webview))))

  1681. -                webkit_web_inspector_show (inspector);

  1682. -        }

  1683. -

  1684. -        if (! options.customUserAgent.empty())

  1685. -            webkit_settings_set_user_agent (settings, options.customUserAgent.c_str());

  1686. -

  1687. -        if (options.fetchResource)

  1688. -        {

  1689. -            const auto onResourceRequested = [] (auto* request, auto* context)

  1690. -            {

  1691. -                try

  1692. -                {

  1693. -                    const auto* path = webkit_uri_scheme_request_get_path (request);

  1694. -

  1695. -                    if (const auto resource = static_cast<Pimpl*> (context)->fetchResource (path))

  1696. -                    {

  1697. -                        const auto& [bytes, mimeType] = *resource;

  1698. -

  1699. -                        auto* streamBytes = g_bytes_new (bytes.data(), static_cast<gsize> (bytes.size()));

  1700. -                        auto* stream = g_memory_input_stream_new_from_bytes (streamBytes);

  1701. -                        g_bytes_unref (streamBytes);

  1702. -

  1703. -                        auto* response = webkit_uri_scheme_response_new (stream, static_cast<gint64> (bytes.size()));

  1704. -                        webkit_uri_scheme_response_set_status (response, 200, nullptr);

  1705. -                        webkit_uri_scheme_response_set_content_type (response, mimeType.c_str());

  1706. -

  1707. -                        auto* headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE);

  1708. -                        soup_message_headers_append (headers, "Cache-Control", "no-store");

  1709. -                        soup_message_headers_append (headers, "Access-Control-Allow-Origin", "*");

  1710. -                        webkit_uri_scheme_response_set_http_headers (response, headers); // response takes ownership of the headers

  1711. -

  1712. -                        webkit_uri_scheme_request_finish_with_response (request, response);

  1713. -

  1714. -                        g_object_unref (stream);

  1715. -                        g_object_unref (response);

  1716. -                    }

  1717. -                    else

  1718. -                    {

  1719. -                        auto* stream = g_memory_input_stream_new();

  1720. -                        auto* response = webkit_uri_scheme_response_new (stream, -1);

  1721. -                        webkit_uri_scheme_response_set_status (response, 404, nullptr);

  1722. -

  1723. -                        webkit_uri_scheme_request_finish_with_response (request, response);

  1724. -

  1725. -                        g_object_unref (stream);

  1726. -                        g_object_unref (response);

  1727. -                    }

  1728. -                }

  1729. -                catch (...)

  1730. -                {

  1731. -                    auto* error = g_error_new (WEBKIT_NETWORK_ERROR, WEBKIT_NETWORK_ERROR_FAILED, "Something went wrong");

  1732. -                    webkit_uri_scheme_request_finish_error (request, error);

  1733. -                    g_error_free (error);

  1734. -                }

  1735. -            };

  1736. -

  1737. -            webkit_web_context_register_uri_scheme (webviewContext, getURIScheme (options).c_str(), onResourceRequested, this, nullptr);

  1738. -            navigate ({});

  1739. -        }

  1740. -

  1741. -        gtk_widget_show_all (webview);

  1742. -    }

  1743. -

  1744. -    ~Pimpl()

  1745. -    {

  1746. -        deletionChecker->deleted = true;

  1747. -

  1748. -        if (signalHandlerID != 0 && webview != nullptr)

  1749. -            g_signal_handler_disconnect (manager, signalHandlerID);

  1750. -

  1751. -        g_clear_object (&webview);

  1752. -        g_clear_object (&webviewContext);

  1753. -    }

  1754. -

  1755. -    static constexpr const char* postMessageFn = "window.webkit.messageHandlers.external.postMessage";

  1756. -

  1757. -    bool loadedOK() const           { return getViewHandle() != nullptr; }

  1758. -    void* getViewHandle() const     { return (void*) webview; }

  1759. -

  1760. -    std::shared_ptr<DeletionChecker> deletionChecker { std::make_shared<DeletionChecker>() };

  1761. -

  1762. -    bool evaluateJavascript (const std::string& js, CompletionHandler&& completionHandler)

  1763. -    {

  1764. -        GAsyncReadyCallback callback = {};

  1765. -        gpointer userData = {};

  1766. -

  1767. -        if (completionHandler)

  1768. -        {

  1769. -            callback = evaluationCompleteCallback;

  1770. -            userData = new CompletionHandler (std::move (completionHandler));

  1771. -        }

  1772. -

  1773. -       #if WEBKIT_CHECK_VERSION (2, 40, 0)

  1774. -        webkit_web_view_evaluate_javascript (WEBKIT_WEB_VIEW (webview), js.c_str(), static_cast<gssize> (js.length()),

  1775. -                                             nullptr, nullptr, nullptr, callback, userData);

  1776. -       #else

  1777. -        webkit_web_view_run_javascript (WEBKIT_WEB_VIEW (webview), js.c_str(), nullptr, callback, userData);

  1778. -       #endif

  1779. -        return true;

  1780. -    }

  1781. -

  1782. -    static void evaluationCompleteCallback (GObject* object, GAsyncResult* result, gpointer userData)

  1783. -    {

  1784. -        std::unique_ptr<CompletionHandler> completionHandler (reinterpret_cast<CompletionHandler*> (userData));

  1785. -        choc::value::Value value;

  1786. -        std::string errorMessage;

  1787. -        GError* error = {};

  1788. -

  1789. -       #if WEBKIT_CHECK_VERSION (2, 40, 0)

  1790. -        if (auto js_result = webkit_web_view_evaluate_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error))

  1791. -       #else

  1792. -        if (auto js_result = webkit_web_view_run_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error))

  1793. -       #endif

  1794. -        {

  1795. -            if (error != nullptr)

  1796. -            {

  1797. -                errorMessage = error->message;

  1798. -                g_error_free (error);

  1799. -            }

  1800. -

  1801. -           #if WEBKIT_CHECK_VERSION (2, 40, 0)

  1802. -            if (auto js_value = js_result)

  1803. -           #else

  1804. -            if (auto js_value = webkit_javascript_result_get_js_value (js_result))

  1805. -           #endif

  1806. -            {

  1807. -                if (auto json = jsc_value_to_json (js_value, 0))

  1808. -                {

  1809. -                    try

  1810. -                    {

  1811. -                        auto jsonView = std::string_view (json);

  1812. -

  1813. -                        if (! jsonView.empty())

  1814. -                            value = choc::json::parseValue (jsonView);

  1815. -                    }

  1816. -                    catch (const std::exception& e)

  1817. -                    {

  1818. -                        if (errorMessage.empty())

  1819. -                            errorMessage = e.what();

  1820. -                    }

  1821. -

  1822. -                    g_free (json);

  1823. -                }

  1824. -                else

  1825. -                {

  1826. -                    if (errorMessage.empty())

  1827. -                        errorMessage = "Failed to convert result to JSON";

  1828. -                }

  1829. -

  1830. -               #if WEBKIT_CHECK_VERSION (2, 40, 0)

  1831. -                g_object_unref (js_value);

  1832. -               #endif

  1833. -            }

  1834. -            else

  1835. -            {

  1836. -                if (errorMessage.empty())

  1837. -                    errorMessage = "Failed to fetch result";

  1838. -            }

  1839. -

  1840. -           #if ! WEBKIT_CHECK_VERSION (2, 40, 0)

  1841. -            webkit_javascript_result_unref (js_result);

  1842. -           #endif

  1843. -        }

  1844. -        else

  1845. -        {

  1846. -            errorMessage = "Failed to fetch result";

  1847. -        }

  1848. -

  1849. -        (*completionHandler) (errorMessage, value);

  1850. -    }

  1851. -

  1852. -    bool navigate (const std::string& url)

  1853. -    {

  1854. -        if (url.empty())

  1855. -            return navigate (defaultURI);

  1856. -

  1857. -        webkit_web_view_load_uri (WEBKIT_WEB_VIEW (webview), url.c_str());

  1858. -        return true;

  1859. -    }

  1860. -

  1861. -    bool setHTML (const std::string& html)

  1862. -    {

  1863. -        webkit_web_view_load_html (WEBKIT_WEB_VIEW (webview), html.c_str(), nullptr);

  1864. -        return true;

  1865. -    }

  1866. -

  1867. -    bool addInitScript (const std::string& js)

  1868. -    {

  1869. -        if (manager != nullptr)

  1870. -        {

  1871. -            webkit_user_content_manager_add_script (manager, webkit_user_script_new (js.c_str(),

  1872. -                                                                                     WEBKIT_USER_CONTENT_INJECT_TOP_FRAME,

  1873. -                                                                                     WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,

  1874. -                                                                                     nullptr, nullptr));

  1875. -            return true;

  1876. -        }

  1877. -

  1878. -        return false;

  1879. -    }

  1880. -

  1881. -    void invokeCallback (WebKitJavascriptResult* r)

  1882. -    {

  1883. -        auto s = jsc_value_to_string (webkit_javascript_result_get_js_value (r));

  1884. -        owner.invokeBinding (s);

  1885. -        g_free (s);

  1886. -    }

  1887. -

  1888. -    WebView& owner;

  1889. -    Options::FetchResource fetchResource;

  1890. -    WebKitWebContext* webviewContext = {};

  1891. -    GtkWidget* webview = {};

  1892. -    WebKitUserContentManager* manager = {};

  1893. -    std::string defaultURI;

  1894. -    unsigned long signalHandlerID = 0;

  1895. -};

  1896. -

  1897. -//==============================================================================

  1898. -#elif CHOC_APPLE

  1899. -

  1900. -#include "choc_MessageLoop.h"

  1901. -

  1902. -struct choc::ui::WebView::Pimpl

  1903. -{

  1904. -    Pimpl (WebView& v, const Options& optionsToUse)

  1905. -        : owner (v), options (std::make_unique<Options> (optionsToUse))

  1906. -    {

  1907. -        using namespace choc::objc;

  1908. -        CHOC_AUTORELEASE_BEGIN

  1909. -

  1910. -        defaultURI = getURIHome (*options);

  1911. -

  1912. -        id config = call<id> (getClass ("WKWebViewConfiguration"), "new");

  1913. -

  1914. -        id prefs = call<id> (config, "preferences");

  1915. -        call<void> (prefs, "setValue:forKey:", getNSNumberBool (true), getNSString ("fullScreenEnabled"));

  1916. -        call<void> (prefs, "setValue:forKey:", getNSNumberBool (true), getNSString ("DOMPasteAllowed"));

  1917. -        call<void> (prefs, "setValue:forKey:", getNSNumberBool (true), getNSString ("javaScriptCanAccessClipboard"));

  1918. -

  1919. -        if (options->enableDebugMode)

  1920. -            call<void> (prefs, "setValue:forKey:", getNSNumberBool (true), getNSString ("developerExtrasEnabled"));

  1921. -

  1922. -        delegate = createDelegate();

  1923. -        objc_setAssociatedObject (delegate, "choc_webview", (CHOC_OBJC_CAST_BRIDGED id) this, OBJC_ASSOCIATION_ASSIGN);

  1924. -

  1925. -        manager = call<id> (config, "userContentController");

  1926. -        call<void> (manager, "retain");

  1927. -        call<void> (manager, "addScriptMessageHandler:name:", delegate, getNSString ("external"));

  1928. -

  1929. -        if (options->fetchResource)

  1930. -            call<void> (config, "setURLSchemeHandler:forURLScheme:", delegate, getNSString (getURIScheme (*options)));

  1931. -

  1932. -        webview = call<id> (allocateWebview(), "initWithFrame:configuration:", CGRect(), config);

  1933. -        objc_setAssociatedObject (webview, "choc_webview", (CHOC_OBJC_CAST_BRIDGED id) this, OBJC_ASSOCIATION_ASSIGN);

  1934. -

  1935. -        if (! options->customUserAgent.empty())

  1936. -            call<void> (webview, "setValue:forKey:", getNSString (options->customUserAgent), getNSString ("customUserAgent"));

  1937. -

  1938. -        call<void> (webview, "setUIDelegate:", delegate);

  1939. -        call<void> (webview, "setNavigationDelegate:", delegate);

  1940. -

  1941. -        call<void> (config, "release");

  1942. -

  1943. -        if (options->fetchResource)

  1944. -            navigate ({});

  1945. -

  1946. -        CHOC_AUTORELEASE_END

  1947. -    }

  1948. -

  1949. -    ~Pimpl()

  1950. -    {

  1951. -        CHOC_AUTORELEASE_BEGIN

  1952. -        deletionChecker->deleted = true;

  1953. -        objc_setAssociatedObject (delegate, "choc_webview", nil, OBJC_ASSOCIATION_ASSIGN);

  1954. -        objc_setAssociatedObject (webview, "choc_webview", nil, OBJC_ASSOCIATION_ASSIGN);

  1955. -        objc::call<void> (webview, "release");

  1956. -        webview = {};

  1957. -        objc::call<void> (manager, "removeScriptMessageHandlerForName:", objc::getNSString ("external"));

  1958. -        objc::call<void> (manager, "release");

  1959. -        manager = {};

  1960. -        objc::call<void> (delegate, "release");

  1961. -        delegate = {};

  1962. -        CHOC_AUTORELEASE_END

  1963. -    }

  1964. -

  1965. -    static constexpr const char* postMessageFn = "window.webkit.messageHandlers.external.postMessage";

  1966. -

  1967. -    bool loadedOK() const           { return getViewHandle() != nullptr; }

  1968. -    void* getViewHandle() const     { return (CHOC_OBJC_CAST_BRIDGED void*) webview; }

  1969. -

  1970. -    std::shared_ptr<DeletionChecker> deletionChecker { std::make_shared<DeletionChecker>() };

  1971. -

  1972. -    bool addInitScript (const std::string& script)

  1973. -    {

  1974. -        using namespace choc::objc;

  1975. -        CHOC_AUTORELEASE_BEGIN

  1976. -

  1977. -        if (id s = call<id> (call<id> (getClass ("WKUserScript"), "alloc"), "initWithSource:injectionTime:forMainFrameOnly:",

  1978. -                                       getNSString (script), WKUserScriptInjectionTimeAtDocumentStart, (BOOL) 1))

  1979. -        {

  1980. -            call<void> (manager, "addUserScript:", s);

  1981. -            call<void> (s, "release");

  1982. -            return true;

  1983. -        }

  1984. -

  1985. -        CHOC_AUTORELEASE_END

  1986. -        return false;

  1987. -    }

  1988. -

  1989. -    bool navigate (const std::string& url)

  1990. -    {

  1991. -        if (url.empty())

  1992. -            return navigate (defaultURI);

  1993. -

  1994. -        using namespace choc::objc;

  1995. -        CHOC_AUTORELEASE_BEGIN

  1996. -

  1997. -        if (id nsURL = call<id> (getClass ("NSURL"), "URLWithString:", getNSString (url)))

  1998. -            return call<id> (webview, "loadRequest:", call<id> (getClass ("NSURLRequest"), "requestWithURL:", nsURL)) != nullptr;

  1999. -

  2000. -        CHOC_AUTORELEASE_END

  2001. -        return false;

  2002. -    }

  2003. -

  2004. -    bool setHTML (const std::string& html)

  2005. -    {

  2006. -        CHOC_AUTORELEASE_BEGIN

  2007. -        return objc::call<id> (webview, "loadHTMLString:baseURL:", objc::getNSString (html), (id) nullptr) != nullptr;

  2008. -        CHOC_AUTORELEASE_END

  2009. -    }

  2010. -

  2011. -    bool evaluateJavascript (const std::string& script, CompletionHandler completionHandler)

  2012. -    {

  2013. -        CHOC_AUTORELEASE_BEGIN

  2014. -        auto s = objc::getNSString (script);

  2015. -

  2016. -        if (completionHandler)

  2017. -        {

  2018. -            objc::call<void> (webview, "evaluateJavaScript:completionHandler:", s,

  2019. -                              ^(id result, id error)

  2020. -                              {

  2021. -                                  CHOC_AUTORELEASE_BEGIN

  2022. -

  2023. -                                  auto errorMessage = getMessageFromNSError (error);

  2024. -                                  choc::value::Value value;

  2025. -

  2026. -                                  try

  2027. -                                  {

  2028. -                                      if (auto json = convertNSObjectToJSON (result); ! json.empty())

  2029. -                                          value = choc::json::parseValue (json);

  2030. -                                  }

  2031. -                                  catch (const std::exception& e)

  2032. -                                  {

  2033. -                                      errorMessage = e.what();

  2034. -                                  }

  2035. -

  2036. -                                  completionHandler (errorMessage, value);

  2037. -                                  CHOC_AUTORELEASE_END

  2038. -                              });

  2039. -        }

  2040. -        else

  2041. -        {

  2042. -            objc::call<void> (webview, "evaluateJavaScript:completionHandler:", s, (id) nullptr);

  2043. -        }

  2044. -

  2045. -        return true;

  2046. -        CHOC_AUTORELEASE_END

  2047. -    }

  2048. -

  2049. -    static std::string convertNSObjectToJSON (id value)

  2050. -    {

  2051. -        if (value)

  2052. -        {

  2053. -            if (id nsData = objc::call<id> (objc::getClass ("NSJSONSerialization"), "dataWithJSONObject:options:error:",

  2054. -                                            value, 12, (id) nullptr))

  2055. -            {

  2056. -                auto data = objc::call<void*> (nsData, "bytes");

  2057. -                auto length = objc::call<unsigned long> (nsData, "length");

  2058. -                return std::string (static_cast<const char*> (data), static_cast<size_t> (length));

  2059. -            }

  2060. -        }

  2061. -

  2062. -        return {};

  2063. -    }

  2064. -

  2065. -private:

  2066. -    id createDelegate()

  2067. -    {

  2068. -        static DelegateClass dc;

  2069. -        return objc::call<id> ((id) dc.delegateClass, "new");

  2070. -    }

  2071. -

  2072. -    id allocateWebview()

  2073. -    {

  2074. -        static WebviewClass c;

  2075. -        return objc::call<id> ((id) c.webviewClass, "alloc");

  2076. -    }

  2077. -

  2078. -    static std::string getMessageFromNSError (id nsError)

  2079. -    {

  2080. -        if (nsError)

  2081. -        {

  2082. -            if (id userInfo = objc::call<id> (nsError, "userInfo"))

  2083. -                if (id message = objc::call<id> (userInfo, "objectForKey:", objc::getNSString ("WKJavaScriptExceptionMessage")))

  2084. -                    if (auto s = objc::getString (message); ! s.empty())

  2085. -                        return s;

  2086. -

  2087. -            return objc::getString (objc::call<id> (nsError, "localizedDescription"));

  2088. -        }

  2089. -

  2090. -        return {};

  2091. -    }

  2092. -

  2093. -    void onResourceRequested (id task)

  2094. -    {

  2095. -        using namespace choc::objc;

  2096. -        CHOC_AUTORELEASE_BEGIN

  2097. -

  2098. -        try

  2099. -        {

  2100. -            id requestUrl = call<id> (call<id> (task, "request"), "URL");

  2101. -

  2102. -            auto makeResponse = [&] (auto responseCode, id headerFields)

  2103. -            {

  2104. -                return call<id> (call<id> (call<id> (getClass ("NSHTTPURLResponse"), "alloc"),

  2105. -                                           "initWithURL:statusCode:HTTPVersion:headerFields:",

  2106. -                                           requestUrl,

  2107. -                                           responseCode,

  2108. -                                           getNSString ("HTTP/1.1"),

  2109. -                                           headerFields),

  2110. -                                 "autorelease");

  2111. -            };

  2112. -

  2113. -            auto path = objc::getString (call<id> (requestUrl, "path"));

  2114. -

  2115. -            if (auto resource = options->fetchResource (path))

  2116. -            {

  2117. -                const auto& [bytes, mimeType] = *resource;

  2118. -

  2119. -                auto contentLength = std::to_string (bytes.size());

  2120. -                id headerKeys[]    = { getNSString ("Content-Length"), getNSString ("Content-Type"), getNSString ("Cache-Control"), getNSString ("Access-Control-Allow-Origin") };

  2121. -                id headerObjects[] = { getNSString (contentLength),    getNSString (mimeType),       getNSString ("no-store") ,     getNSString ("*") };

  2122. -

  2123. -                id headerFields = call<id> (getClass ("NSDictionary"), "dictionaryWithObjects:forKeys:count:",

  2124. -                                            headerObjects, headerKeys, sizeof (headerObjects) / sizeof (id));

  2125. -

  2126. -                call<void> (task, "didReceiveResponse:", makeResponse (200, headerFields));

  2127. -

  2128. -                id data = call<id> (getClass ("NSData"), "dataWithBytes:length:", bytes.data(), bytes.size());

  2129. -                call<void> (task, "didReceiveData:", data);

  2130. -            }

  2131. -            else

  2132. -            {

  2133. -                call<void> (task, "didReceiveResponse:", makeResponse (404, nullptr));

  2134. -            }

  2135. -

  2136. -            call<void> (task, "didFinish");

  2137. -        }

  2138. -        catch (...)

  2139. -        {

  2140. -            id error = call<id> (getClass ("NSError"), "errorWithDomain:code:userInfo:",

  2141. -                                 getNSString ("NSURLErrorDomain"), -1, nullptr);

  2142. -

  2143. -            call<void> (task, "didFailWithError:", error);

  2144. -        }

  2145. -

  2146. -        CHOC_AUTORELEASE_END

  2147. -    }

  2148. -

  2149. -    BOOL sendAppAction (id self, const char* action)

  2150. -    {

  2151. -        objc::call<void> (objc::getSharedNSApplication(), "sendAction:to:from:",

  2152. -                          sel_registerName (action), (id) nullptr, self);

  2153. -        return true;

  2154. -    }

  2155. -

  2156. -    BOOL performKeyEquivalent (id self, id e)

  2157. -    {

  2158. -        enum

  2159. -        {

  2160. -            NSEventTypeKeyDown = 10,

  2161. -

  2162. -            NSEventModifierFlagShift    = 1 << 17,

  2163. -            NSEventModifierFlagControl  = 1 << 18,

  2164. -            NSEventModifierFlagOption   = 1 << 19,

  2165. -            NSEventModifierFlagCommand  = 1 << 20

  2166. -        };

  2167. -

  2168. -        if (objc::call<int> (e, "type") == NSEventTypeKeyDown)

  2169. -        {

  2170. -            auto flags = objc::call<int> (e, "modifierFlags") & (NSEventModifierFlagShift | NSEventModifierFlagCommand

  2171. -                                                                 | NSEventModifierFlagControl | NSEventModifierFlagOption);

  2172. -

  2173. -            auto path = objc::getString (objc::call<id> (e, "charactersIgnoringModifiers"));

  2174. -

  2175. -            if (flags == NSEventModifierFlagCommand)

  2176. -            {

  2177. -                if (path == "c") return sendAppAction (self, "copy:");

  2178. -                if (path == "x") return sendAppAction (self, "cut:");

  2179. -                if (path == "v") return sendAppAction (self, "paste:");

  2180. -                if (path == "z") return sendAppAction (self, "undo:");

  2181. -                if (path == "a") return sendAppAction (self, "selectAll:");

  2182. -            }

  2183. -            else if (flags == (NSEventModifierFlagShift | NSEventModifierFlagCommand))

  2184. -            {

  2185. -                if (path == "Z") return sendAppAction (self, "redo:");

  2186. -            }

  2187. -        }

  2188. -

  2189. -        return false;

  2190. -    }

  2191. -

  2192. -    void handleError (id error)

  2193. -    {

  2194. -        static constexpr int NSURLErrorCancelled = -999;

  2195. -

  2196. -        if (objc::call<int> (error, "code") == NSURLErrorCancelled)

  2197. -            return;

  2198. -

  2199. -        setHTML ("<!DOCTYPE html><html><head><title>Error</title></head>"

  2200. -                 "<body><h2>" + getMessageFromNSError (error) + "</h2></body></html>");

  2201. -    }

  2202. -

  2203. -    static Pimpl* getPimpl (id self)

  2204. -    {

  2205. -        return (CHOC_OBJC_CAST_BRIDGED Pimpl*) (objc_getAssociatedObject (self, "choc_webview"));

  2206. -    }

  2207. -

  2208. -    WebView& owner;

  2209. -    // NB: this is a pointer because making it a member forces the alignment of this Pimpl class

  2210. -    // to 16, which then conflicts with obj-C pointer alignment...

  2211. -    std::unique_ptr<Options> options;

  2212. -    id webview = {}, manager = {}, delegate = {};

  2213. -    std::string defaultURI;

  2214. -

  2215. -    struct WebviewClass

  2216. -    {

  2217. -        WebviewClass()

  2218. -        {

  2219. -            webviewClass = choc::objc::createDelegateClass ("WKWebView", "CHOCWebView_");

  2220. -

  2221. -            class_addMethod (webviewClass, sel_registerName ("acceptsFirstMouse:"),

  2222. -                            (IMP) (+[](id self, SEL, id) -> BOOL

  2223. -                            {

  2224. -                                if (auto p = getPimpl (self))

  2225. -                                    return p->options->acceptsFirstMouseClick;

  2226. -

  2227. -                                return false;

  2228. -                            }), "B@:@");

  2229. -

  2230. -            class_addMethod (webviewClass, sel_registerName ("performKeyEquivalent:"),

  2231. -                            (IMP) (+[](id self, SEL, id e) -> BOOL

  2232. -                            {

  2233. -                                if (auto p = getPimpl (self))

  2234. -                                    return p->performKeyEquivalent (self, e);

  2235. -

  2236. -                                return false;

  2237. -                            }), "B@:@");

  2238. -

  2239. -            objc_registerClassPair (webviewClass);

  2240. -        }

  2241. -

  2242. -        ~WebviewClass()

  2243. -        {

  2244. -            // NB: it doesn't seem possible to dispose of this class late enough to avoid a warning on shutdown

  2245. -            // about the KVO system still using it, so unfortunately the only option seems to be to let it leak..

  2246. -            // objc_disposeClassPair (webviewClass);

  2247. -        }

  2248. -

  2249. -        Class webviewClass = {};

  2250. -    };

  2251. -

  2252. -    struct DelegateClass

  2253. -    {

  2254. -        DelegateClass()

  2255. -        {

  2256. -            using namespace choc::objc;

  2257. -            delegateClass = createDelegateClass ("NSObject", "CHOCWebViewDelegate_");

  2258. -

  2259. -            class_addMethod (delegateClass, sel_registerName ("userContentController:didReceiveScriptMessage:"),

  2260. -                             (IMP) (+[](id self, SEL, id, id msg)

  2261. -                             {

  2262. -                                 if (auto p = getPimpl (self))

  2263. -                                     p->owner.invokeBinding (objc::getString (call<id> (msg, "body")));

  2264. -                             }),

  2265. -                             "v@:@@");

  2266. -

  2267. -            class_addMethod (delegateClass, sel_registerName ("webView:startURLSchemeTask:"),

  2268. -                             (IMP) (+[](id self, SEL, id, id task)

  2269. -                             {

  2270. -                                 if (auto p = getPimpl (self))

  2271. -                                     p->onResourceRequested (task);

  2272. -                             }),

  2273. -                             "v@:@@");

  2274. -

  2275. -            class_addMethod (delegateClass, sel_registerName ("webView:didFailProvisionalNavigation:withError:"),

  2276. -                             (IMP) (+[](id self, SEL, id, id, id error)

  2277. -                             {

  2278. -                                 if (auto p = getPimpl (self))

  2279. -                                     p->handleError (error);

  2280. -                             }),

  2281. -                             "v@:@@@");

  2282. -

  2283. -            class_addMethod (delegateClass, sel_registerName ("webView:didFailNavigation:withError:"),

  2284. -                             (IMP) (+[](id self, SEL, id, id, id error)

  2285. -                             {

  2286. -                                 if (auto p = getPimpl (self))

  2287. -                                     p->handleError (error);

  2288. -                             }),

  2289. -                             "v@:@@@");

  2290. -

  2291. -            class_addMethod (delegateClass, sel_registerName ("webView:stopURLSchemeTask:"), (IMP) (+[](id, SEL, id, id) {}), "v@:@@");

  2292. -

  2293. -            class_addMethod (delegateClass, sel_registerName ("webView:runOpenPanelWithParameters:initiatedByFrame:completionHandler:"),

  2294. -                             (IMP) (+[](id, SEL, id wkwebview, id params, id /*frame*/, void (^completionHandler)(id))

  2295. -                             {

  2296. -                                CHOC_AUTORELEASE_BEGIN

  2297. -                                id panel = call<id> (getClass ("NSOpenPanel"), "openPanel");

  2298. -

  2299. -                                auto allowsMultipleSelection = call<BOOL> (params, "allowsMultipleSelection");

  2300. -                                id allowedFileExtensions = call<id> (params, "_allowedFileExtensions");

  2301. -                                id window = call<id> (wkwebview, "window");

  2302. -

  2303. -                                call<void> (panel, "setAllowsMultipleSelection:", allowsMultipleSelection);

  2304. -                                call<void> (panel, "setAllowedFileTypes:", allowedFileExtensions);

  2305. -

  2306. -                                call<void> (panel, "beginSheetModalForWindow:completionHandler:", window,

  2307. -                                            ^(long result)

  2308. -                                            {

  2309. -                                                CHOC_AUTORELEASE_BEGIN

  2310. -                                                if (result == 1) // NSModalResponseOK

  2311. -                                                    completionHandler (call<id> (panel, "URLs"));

  2312. -                                                else

  2313. -                                                    completionHandler (nil);

  2314. -                                                CHOC_AUTORELEASE_END

  2315. -                                            });

  2316. -                                CHOC_AUTORELEASE_END

  2317. -                             }), "v@:@@@@");

  2318. -

  2319. -            objc_registerClassPair (delegateClass);

  2320. -        }

  2321. -

  2322. -        ~DelegateClass()

  2323. -        {

  2324. -            objc_disposeClassPair (delegateClass);

  2325. -        }

  2326. -

  2327. -        Class delegateClass = {};

  2328. -    };

  2329. -

  2330. -    static constexpr long WKUserScriptInjectionTimeAtDocumentStart = 0;

  2331. -

  2332. -    // Including CodeGraphics.h can create all kinds of messy C/C++ symbol clashes

  2333. -    // with other headers, but all we actually need are these coordinate structs:

  2334. -   #if defined (__LP64__) && __LP64__

  2335. -    using CGFloat = double;

  2336. -   #else

  2337. -    using CGFloat = float;

  2338. -   #endif

  2339. -

  2340. -    struct CGPoint { CGFloat x = 0, y = 0; };

  2341. -    struct CGSize  { CGFloat width = 0, height = 0; };

  2342. -    struct CGRect  { CGPoint origin; CGSize size; };

  2343. -};

  2344. -

  2345. -//==============================================================================

  2346. -#elif CHOC_WINDOWS

  2347. -

  2348. -#include "../platform/choc_DynamicLibrary.h"

  2349. -

  2350. -// If you want to supply your own mechanism for finding the Microsoft

  2351. -// Webview2Loader.dll file, then define the CHOC_FIND_WEBVIEW2LOADER_DLL

  2352. -// macro, which must evaluate to a choc::file::DynamicLibrary object

  2353. -// which points to the DLL.

  2354. -#ifndef CHOC_FIND_WEBVIEW2LOADER_DLL

  2355. - #define CHOC_USE_INTERNAL_WEBVIEW_DLL 1

  2356. - #define CHOC_FIND_WEBVIEW2LOADER_DLL choc::ui::getWebview2LoaderDLL()

  2357. - #include "../platform/choc_MemoryDLL.h"

  2358. - namespace choc::ui

  2359. - {

  2360. -    using WebViewDLL = choc::memory::MemoryDLL;

  2361. -    static WebViewDLL getWebview2LoaderDLL();

  2362. - }

  2363. -#else

  2364. - namespace choc::ui

  2365. - {

  2366. -    using WebViewDLL = choc::file::DynamicLibrary;

  2367. - }

  2368. -#endif

  2369. -

  2370. +#include "choc_DynamicLibrary.h"

  2371. +#include "choc_MemoryDLL.h"

  2372.  #include "choc_DesktopWindow.h"

  2373.  

  2374. +START_NAMESPACE_DISTRHO

  2375. +static MemoryDLL getWebview2LoaderDLL();

  2376. +END_NAMESPACE_DISTRHO

  2377. +

  2378.  #ifndef __webview2_h__

  2379.  #define __webview2_h__

  2380.  

  2381. @@ -1268,8 +473,7 @@ public:

  2382.  

  2383.  #endif // __webview2_h__

  2384.  

  2385. -namespace choc::ui

  2386. -{

  2387. +START_NAMESPACE_DISTRHO

  2388.  

  2389.  //==============================================================================

  2390.  struct WebView::Pimpl

  2391. @@ -1277,10 +481,7 @@ struct WebView::Pimpl

  2392.      Pimpl (WebView& v, const Options& opts)

  2393.          : owner (v), options (opts)

  2394.      {

  2395. -        // You cam define this macro to provide a custom way of getting a

  2396. -        // choc::file::DynamicLibrary that contains the redistributable

  2397. -        // Microsoft WebView2Loader.dll

  2398. -        webviewDLL = CHOC_FIND_WEBVIEW2LOADER_DLL;

  2399. +        webviewDLL = getWebview2LoaderDLL();

  2400.  

  2401.          if (! webviewDLL)

  2402.              return;

  2403. @@ -1290,9 +491,6 @@ struct WebView::Pimpl

  2404.          if (hwnd.hwnd == nullptr)

  2405.              return;

  2406.  

  2407. -        defaultURI = getURIHome (options);

  2408. -        setHTMLURI = defaultURI + "getHTMLInternal";

  2409. -

  2410.          SetWindowLongPtr (hwnd, GWLP_USERDATA, (LONG_PTR) this);

  2411.  

  2412.          if (createEmbeddedWebView())

  2413. @@ -1304,8 +502,6 @@ struct WebView::Pimpl

  2414.  

  2415.      ~Pimpl()

  2416.      {

  2417. -        deletionChecker->deleted = true;

  2418. -

  2419.          if (coreWebView != nullptr)

  2420.          {

  2421.              coreWebView->Release();

  2422. @@ -1327,52 +523,30 @@ struct WebView::Pimpl

  2423.          hwnd.reset();

  2424.      }

  2425.  

  2426. -    static constexpr const char* postMessageFn = "window.chrome.webview.postMessage";

  2427. -

  2428.      bool loadedOK() const           { return coreWebView != nullptr; }

  2429.      void* getViewHandle() const     { return (void*) hwnd.hwnd; }

  2430.  

  2431. -    std::shared_ptr<DeletionChecker> deletionChecker { std::make_shared<DeletionChecker>() };

  2432. -

  2433.      bool navigate (const std::string& url)

  2434.      {

  2435. -        if (url.empty())

  2436. -            return navigate (defaultURI);

  2437. -

  2438. -        CHOC_ASSERT (coreWebView != nullptr);

  2439. +        DISTRHO_SAFE_ASSERT_RETURN (coreWebView != nullptr, false);

  2440.          return coreWebView->Navigate (createUTF16StringFromUTF8 (url).c_str()) == S_OK;

  2441.      }

  2442.  

  2443.      bool addInitScript (const std::string& script)

  2444.      {

  2445. -        CHOC_ASSERT (coreWebView != nullptr);

  2446. +        DISTRHO_SAFE_ASSERT_RETURN (coreWebView != nullptr, false);

  2447.          return coreWebView->AddScriptToExecuteOnDocumentCreated (createUTF16StringFromUTF8 (script).c_str(), nullptr) == S_OK;

  2448.      }

  2449.  

  2450. -    bool evaluateJavascript (const std::string& script, CompletionHandler&& ch)

  2451. -    {

  2452. -        if (coreWebView == nullptr)

  2453. -            return false;

  2454. -

  2455. -        COMPtr<ExecuteScriptCompletedCallback> callback (ch ? new ExecuteScriptCompletedCallback (std::move (ch))

  2456. -                                                            : nullptr);

  2457. -

  2458. -        return coreWebView->ExecuteScript (createUTF16StringFromUTF8 (script).c_str(), callback) == S_OK;

  2459. -    }

  2460. -

  2461. -    bool setHTML (const std::string& html)

  2462. +    bool evaluateJavascript (const std::string& script)

  2463.      {

  2464. -        CHOC_ASSERT (coreWebView != nullptr);

  2465. -        pageHTML = { html, "text/html" };

  2466. -        navigate (setHTMLURI);

  2467. -        return true;

  2468. +        DISTRHO_SAFE_ASSERT_RETURN (coreWebView != nullptr, false);

  2469. +        return coreWebView->ExecuteScript (createUTF16StringFromUTF8 (script).c_str(), nullptr) == S_OK;

  2470.      }

  2471.  

  2472.  private:

  2473.      WindowClass windowClass { L"CHOCWebView", (WNDPROC) wndProc };

  2474.      HWNDHolder hwnd;

  2475. -    std::string defaultURI, setHTMLURI;

  2476. -    WebView::Options::Resource pageHTML;

  2477.  

  2478.      //==============================================================================

  2479.      template <typename Type>

  2480. @@ -1404,7 +578,7 @@ private:

  2481.              return message;

  2482.          }

  2483.  

  2484. -        return choc::text::createHexString (hr);

  2485. +        return createHexString (hr);

  2486.      }

  2487.  

  2488.      static Pimpl* getPimpl (HWND h)     { return (Pimpl*) GetWindowLongPtr (h, GWLP_USERDATA); }

  2489. @@ -1463,15 +637,9 @@ private:

  2490.                      if (coreWebView == nullptr)

  2491.                          return false;

  2492.  

  2493. -                    const auto wildcardFilter = createUTF16StringFromUTF8 (defaultURI + "*");

  2494. -                    coreWebView->AddWebResourceRequestedFilter (wildcardFilter.c_str(), COREWEBVIEW2_WEB_RESOURCE_CONTEXT_ALL);

  2495. -

  2496.                      EventRegistrationToken token;

  2497.                      coreWebView->add_WebResourceRequested (handler, std::addressof (token));

  2498.  

  2499. -                    if (options.fetchResource)

  2500. -                        navigate ({});

  2501. -

  2502.                      ICoreWebView2Settings* settings = nullptr;

  2503.  

  2504.                      if (coreWebView->get_Settings (std::addressof (settings)) == S_OK

  2505. @@ -1526,14 +694,6 @@ private:

  2506.          webviewInitialising.clear();

  2507.      }

  2508.  

  2509. -    std::optional<WebView::Options::Resource> fetchResourceOrPageHTML (const std::string& uri)

  2510. -    {

  2511. -        if (uri == setHTMLURI)

  2512. -            return pageHTML;

  2513. -

  2514. -        return options.fetchResource (uri.substr (defaultURI.size() - 1));

  2515. -    }

  2516. -

  2517.      HRESULT onResourceRequested (ICoreWebView2WebResourceRequestedEventArgs* args)

  2518.      {

  2519.          struct ScopedExit

  2520. @@ -1579,42 +739,8 @@ private:

  2521.              ICoreWebView2WebResourceResponse* response = {};

  2522.              ScopedExit cleanupResponse (makeCleanupIUnknown (response));

  2523.  

  2524. -            if (const auto resource = fetchResourceOrPageHTML (createUTF8FromUTF16 (uri)))

  2525. -            {

  2526. -                const auto makeMemoryStream = [](const auto* data, auto length) -> IStream*

  2527. -                {

  2528. -                    choc::file::DynamicLibrary lib ("shlwapi.dll");

  2529. -                    using SHCreateMemStreamFn = IStream*(__stdcall *)(const BYTE*, UINT);

  2530. -                    auto fn = reinterpret_cast<SHCreateMemStreamFn> (lib.findFunction ("SHCreateMemStream"));

  2531. -                    return fn ? fn (data, length) : nullptr;

  2532. -                };

  2533. -

  2534. -                auto* stream = makeMemoryStream (reinterpret_cast<const BYTE*> (resource->data.data()),

  2535. -                                                 static_cast<UINT> (resource->data.size()));

  2536. -

  2537. -                if (stream == nullptr)

  2538. -                    return E_FAIL;

  2539. -

  2540. -                ScopedExit cleanupStream (makeCleanupIUnknown (stream));

  2541. -

  2542. -                std::vector<std::string> headers;

  2543. -                headers.emplace_back ("Content-Type: " + resource->mimeType);

  2544. -                headers.emplace_back ("Cache-Control: no-store");

  2545. -                headers.emplace_back ("Access-Control-Allow-Origin: *");

  2546. -

  2547. -                if (! options.customUserAgent.empty())

  2548. -                    headers.emplace_back ("User-Agent: " + options.customUserAgent);

  2549. -

  2550. -                const auto headerString = createUTF16StringFromUTF8 (choc::text::joinStrings (headers, "\n"));

  2551. -

  2552. -                if (coreWebViewEnvironment->CreateWebResourceResponse (stream, 200, L"OK", headerString.c_str(), std::addressof (response)) != S_OK)

  2553. -                    return E_FAIL;

  2554. -            }

  2555. -            else

  2556. -            {

  2557. -                if (coreWebViewEnvironment->CreateWebResourceResponse (nullptr, 404, L"Not Found", nullptr, std::addressof (response)) != S_OK)

  2558. -                    return E_FAIL;

  2559. -            }

  2560. +            if (coreWebViewEnvironment->CreateWebResourceResponse (nullptr, 404, L"Not Found", nullptr, std::addressof (response)) != S_OK)

  2561. +                return E_FAIL;

  2562.  

  2563.              if (args->put_Response (response) != S_OK)

  2564.                  return E_FAIL;

  2565. @@ -1708,58 +834,9 @@ private:

  2566.          std::atomic<ULONG> refCount { 0 };

  2567.      };

  2568.  

  2569. -    //==============================================================================

  2570. -    struct ExecuteScriptCompletedCallback  : public ICoreWebView2ExecuteScriptCompletedHandler

  2571. -    {

  2572. -        ExecuteScriptCompletedCallback (CompletionHandler&& cb) : callback (std::move (cb)) {}

  2573. -        virtual ~ExecuteScriptCompletedCallback() {}

  2574. -

  2575. -        HRESULT STDMETHODCALLTYPE QueryInterface (REFIID refID, void** result) override

  2576. -        {

  2577. -            if (refID == IID { 0x49511172, 0xcc67, 0x4bca, { 0x99, 0x23, 0x13, 0x71, 0x12, 0xf4, 0xc4, 0xcc } }

  2578. -                || refID == IID_IUnknown)

  2579. -            {

  2580. -                *result = this;

  2581. -                AddRef();

  2582. -                return S_OK;

  2583. -            }

  2584. -

  2585. -            *result = nullptr;

  2586. -            return E_NOINTERFACE;

  2587. -        }

  2588. -

  2589. -        ULONG STDMETHODCALLTYPE AddRef() override     { return ++refCount; }

  2590. -        ULONG STDMETHODCALLTYPE Release() override    { auto newCount = --refCount; if (newCount == 0) delete this; return newCount; }

  2591. -

  2592. -        HRESULT STDMETHODCALLTYPE Invoke (HRESULT hr, LPCWSTR resultJSON) override

  2593. -        {

  2594. -            std::string errorMessage = getMessageFromHRESULT (hr);

  2595. -            choc::value::Value value;

  2596. -

  2597. -            if (resultJSON != nullptr)

  2598. -            {

  2599. -                try

  2600. -                {

  2601. -                    if (auto json = createUTF8FromUTF16 (std::wstring (resultJSON)); ! json.empty())

  2602. -                        value = choc::json::parseValue (json);

  2603. -                }

  2604. -                catch (const std::exception& e)

  2605. -                {

  2606. -                    errorMessage = e.what();

  2607. -                }

  2608. -            }

  2609. -

  2610. -            callback (errorMessage, value);

  2611. -            return S_OK;

  2612. -        }

  2613. -

  2614. -        CompletionHandler callback;

  2615. -        std::atomic<ULONG> refCount { 0 };

  2616. -    };

  2617. -

  2618.      //==============================================================================

  2619.      WebView& owner;

  2620. -    WebViewDLL webviewDLL;

  2621. +    MemoryDLL webviewDLL;

  2622.      Options options;

  2623.      ICoreWebView2Environment* coreWebViewEnvironment = nullptr;

  2624.      ICoreWebView2* coreWebView = nullptr;

  2625. @@ -1793,15 +870,6 @@ private:

  2626.      }

  2627.  };

  2628.  

  2629. -} // namespace choc::ui

  2630. -

  2631. -#else

  2632. - #error "choc WebView only supports OSX, Windows or Linux!"

  2633. -#endif

  2634. -

  2635. -namespace choc::ui

  2636. -{

  2637. -

  2638.  //==============================================================================

  2639.  inline WebView::WebView() : WebView (Options()) {}

  2640.  

  2641. @@ -1820,137 +888,30 @@ inline WebView::~WebView()

  2642.  

  2643.  inline bool WebView::loadedOK() const                                { return pimpl != nullptr; }

  2644.  inline bool WebView::navigate (const std::string& url)               { return pimpl != nullptr && pimpl->navigate (url); }

  2645. -inline bool WebView::setHTML (const std::string& html)               { return pimpl != nullptr && pimpl->setHTML (html); }

  2646.  inline bool WebView::addInitScript (const std::string& script)       { return pimpl != nullptr && pimpl->addInitScript (script); }

  2647.  

  2648. -inline bool WebView::evaluateJavascript (const std::string& script, CompletionHandler completionHandler)

  2649. +inline bool WebView::evaluateJavascript (const std::string& script)

  2650.  {

  2651. -    return pimpl != nullptr && pimpl->evaluateJavascript (script, std::move (completionHandler));

  2652. +    return pimpl != nullptr && pimpl->evaluateJavascript (script);

  2653.  }

  2654.  

  2655.  inline void* WebView::getViewHandle() const                          { return pimpl != nullptr ? pimpl->getViewHandle() : nullptr; }

  2656.  

  2657. -inline bool WebView::bind (const std::string& functionName, CallbackFn&& fn)

  2658. +inline bool WebView::bind (CallbackFn&& fn)

  2659.  {

  2660.      if (pimpl == nullptr)

  2661.          return false;

  2662.  

  2663. -    static constexpr std::string_view scriptTemplate = R"((function() {

  2664. -const fnBinding = window._fnBindings = (window._fnBindings || { messageID: 1 });

  2665. -

  2666. -window["FUNCTION_NAME"] = function()

  2667. -{

  2668. -  const messageID = ++fnBinding.messageID;

  2669. -  const promise = new Promise((resolve, reject) => { fnBinding[messageID] = { resolve, reject }; });

  2670. -

  2671. -  const args = JSON.stringify ({ id: messageID,

  2672. -                                 fn: "FUNCTION_NAME",

  2673. -                                 params: Array.prototype.slice.call (arguments)

  2674. -                               },

  2675. -                               (key, value) => typeof value === 'bigint' ? value.toString() : value);

  2676. -  INVOKE_BINDING (args);

  2677. -  return promise;

  2678. -}

  2679. -})())";

  2680. -

  2681. -    auto script = choc::text::replace (scriptTemplate, "FUNCTION_NAME", functionName,

  2682. -                                                       "INVOKE_BINDING", Pimpl::postMessageFn);

  2683. -

  2684. -    if (addInitScript (script)

  2685. -         && evaluateJavascript (script))

  2686. -    {

  2687. -        bindings[functionName] = std::move (fn);

  2688. -        return true;

  2689. -    }

  2690. -

  2691. -    return false;

  2692. -}

  2693. -

  2694. -inline bool WebView::unbind (const std::string& functionName)

  2695. -{

  2696. -    if (auto found = bindings.find (functionName); found != bindings.end())

  2697. -    {

  2698. -        evaluateJavascript ("delete window[\"" + functionName + "\"];");

  2699. -        bindings.erase (found);

  2700. -        return true;

  2701. -    }

  2702. -

  2703. -    return false;

  2704. +    binding = std::move (fn);

  2705. +    return true;

  2706.  }

  2707.  

  2708.  inline void WebView::invokeBinding (const std::string& msg)

  2709.  {

  2710. -    try

  2711. -    {

  2712. -        auto json = choc::json::parse (msg);

  2713. -        auto b = bindings.find (std::string (json["fn"].getString()));

  2714. -        auto callbackID = json["id"].getWithDefault<int64_t>(0);

  2715. -

  2716. -        if (callbackID == 0 || b == bindings.end())

  2717. -            return;

  2718. -

  2719. -        auto callbackItem = "window._fnBindings[" + std::to_string (callbackID) + "]";

  2720. -

  2721. -        try

  2722. -        {

  2723. -            auto deletionChecker = pimpl->deletionChecker;

  2724. -            auto result = b->second (json["params"]);

  2725. -

  2726. -            if (deletionChecker->deleted) // in case the WebView was deleted during the callback

  2727. -                return;

  2728. -

  2729. -            auto call = callbackItem + ".resolve(" + choc::json::toString (result) + "); delete " + callbackItem + ";";

  2730. -            evaluateJavascript (call);

  2731. -            return;

  2732. -        }

  2733. -        catch (const std::exception&)

  2734. -        {}

  2735. -

  2736. -        auto call = callbackItem + ".reject(); delete " + callbackItem + ";";

  2737. -        evaluateJavascript (call);

  2738. -    }

  2739. -    catch (const std::exception&)

  2740. -    {}

  2741. -}

  2742. -

  2743. -inline std::string WebView::getURIHome (const Options& options)

  2744. -{

  2745. -    if (! options.customSchemeURI.empty())

  2746. -    {

  2747. -        if (choc::text::endsWith (options.customSchemeURI, "/"))

  2748. -            return options.customSchemeURI;

  2749. -

  2750. -        return options.customSchemeURI + "/";

  2751. -    }

  2752. -

  2753. -   #if CHOC_WINDOWS

  2754. -    return "https://choc.localhost/";

  2755. -   #else

  2756. -    return "choc://choc.choc/";

  2757. -   #endif

  2758. -}

  2759. -

  2760. -inline std::string WebView::getURIScheme (const Options& options)

  2761. -{

  2762. -    auto uri = getURIHome (options);

  2763. -    auto colon = uri.find (":");

  2764. -    CHOC_ASSERT (colon != std::string::npos && colon != 0); // need to provide a valid URI with a scheme at the start.

  2765. -    return uri.substr (0, colon);

  2766. -}

  2767. -

  2768. -inline WebView::Options::Resource::Resource (std::string_view content, std::string mime)

  2769. -{

  2770. -    if (! content.empty())

  2771. -    {

  2772. -        auto src = content.data();

  2773. -        data.insert (data.end(), src, src + content.length());

  2774. -    }

  2775. -

  2776. -    mimeType = std::move (mime);

  2777. +    binding(msg);

  2778.  }

  2779.  

  2780. -} // namespace choc::ui

  2781. -

  2782. +END_NAMESPACE_DISTRHO

  2783.  

  2784.  //==============================================================================

  2785.  //==============================================================================

  2786. @@ -2035,7 +996,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  2787.  )")

  2788.  #endif

  2789.  

  2790. -inline choc::ui::WebViewDLL choc::ui::getWebview2LoaderDLL()

  2791. +inline DISTRHO_NAMESPACE::MemoryDLL DISTRHO_NAMESPACE::getWebview2LoaderDLL()

  2792.  {

  2793.      // This is version 1.0.2365.46

  2794.  

  2795. @@ -5798,7 +4759,7 @@ inline choc::ui::WebViewDLL choc::ui::getWebview2LoaderDLL()

  2796.      };

  2797.     #endif

  2798.  

  2799. -    return choc::memory::MemoryDLL (dllData, sizeof (dllData));

  2800. +    return DISTRHO_NAMESPACE::MemoryDLL (dllData, sizeof (dllData));

  2801.  }

  2802.  

  2803.  #endif