DISTRHO
/
DPF
mirror of https://github.com/DISTRHO/DPF
1
0
Fork 0
Code Releases 0 Activity
DISTRHO Plugin Framework
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.
2523 Commits
6 Branches
50MB
Tree: 04eb91490c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '04eb91490c'
${ noResults }
DPF/dgl/src/pugl-extra/wasm.c

1234 lines
38KB
Raw Blame History 

  1. // Copyright 2012-2022 David Robillard <d@drobilla.net>

  2. // Copyright 2021-2025 Filipe Coelho <falktx@falktx.com>

  3. // SPDX-License-Identifier: ISC

  4. 

  5. #include "wasm.h"

  6. 

  7. #include "../pugl-upstream/src/internal.h"

  8. #include "../pugl-upstream/src/platform.h"

  9. 

  10. #include <stdio.h>

  11. 

  12. #include <emscripten/html5.h>

  13. 

  14. #ifdef __cplusplus

  15. #  define PUGL_INIT_STRUCT \

  16.     {}

  17. #else

  18. #  define PUGL_INIT_STRUCT \

  19.     {                      \

  20.       0                    \

  21.     }

  22. #endif

  23. 

  24. #ifdef __MOD_DEVICES__

  25. #  define MOD_SCALE_FACTOR_MULT 1

  26. #endif

  27. 

  28. // #define PUGL_WASM_AUTO_POINTER_LOCK

  29. // #define PUGL_WASM_NO_KEYBOARD_INPUT

  30. // #define PUGL_WASM_NO_MOUSEWHEEL_INPUT

  31. 

  32. PuglWorldInternals*

  33. puglInitWorldInternals(const PuglWorldType type, const PuglWorldFlags flags)

  34. {

  35.   PuglWorldInternals* impl =

  36.     (PuglWorldInternals*)calloc(1, sizeof(PuglWorldInternals));

  37. 

  38.   impl->scaleFactor = emscripten_get_device_pixel_ratio();

  39. #ifdef __MOD_DEVICES__

  40.   impl->scaleFactor *= MOD_SCALE_FACTOR_MULT;

  41. #endif

  42. 

  43.   printf("DONE: %s %d | -> %f\n", __func__, __LINE__, impl->scaleFactor);

  44. 

  45.   return impl;

  46. }

  47. 

  48. void*

  49. puglGetNativeWorld(PuglWorld*)

  50. {

  51.   printf("DONE: %s %d\n", __func__, __LINE__);

  52.   return NULL;

  53. }

  54. 

  55. PuglInternals*

  56. puglInitViewInternals(PuglWorld* const world)

  57. {

  58.   printf("DONE: %s %d\n", __func__, __LINE__);

  59.   PuglInternals* impl = (PuglInternals*)calloc(1, sizeof(PuglInternals));

  60. 

  61.   impl->buttonPressTimeout = -1;

  62.   impl->supportsTouch = PUGL_DONT_CARE; // not yet known

  63. 

  64. #ifdef PUGL_WASM_ASYNC_CLIPBOARD

  65.   impl->supportsClipboardRead = (PuglViewHintValue)EM_ASM_INT({

  66.     if (typeof(navigator.clipboard) !== 'undefined' && typeof(navigator.clipboard.readText) === 'function' && window.isSecureContext) {

  67.       return 1; // PUGL_TRUE

  68.     }

  69.     return 0; // PUGL_FALSE

  70.   });

  71. 

  72.   impl->supportsClipboardWrite = (PuglViewHintValue)EM_ASM_INT({

  73.     if (typeof(navigator.clipboard) !== 'undefined' && typeof(navigator.clipboard.writeText) === 'function' && window.isSecureContext) {

  74.       return 1; // PUGL_TRUE

  75.     }

  76.     if (typeof(document.queryCommandSupported) !== 'undefined' && document.queryCommandSupported("copy")) {

  77.       return 1; // PUGL_TRUE

  78.     }

  79.     return 0; // PUGL_FALSE

  80.   });

  81. #endif

  82. 

  83.   return impl;

  84. }

  85. 

  86. PuglStatus

  87. puglApplySizeHint(PuglView* const view, const PuglSizeHint PUGL_UNUSED(hint))

  88. {

  89.   // No fine-grained updates, hints are always recalculated together

  90.   return puglUpdateSizeHints(view);

  91. }

  92. 

  93. PuglStatus

  94. puglUpdateSizeHints(PuglView* const view)

  95. {

  96.   const char* const className = view->world->strings[PUGL_CLASS_NAME];

  97. 

  98.   if (!view->hints[PUGL_RESIZABLE]) {

  99.     PuglArea size = puglGetSizeHint(view, PUGL_CURRENT_SIZE);

  100.     if (!puglIsValidSize(size.width, size.height)) {

  101.       size = puglGetSizeHint(view, PUGL_DEFAULT_SIZE);

  102.     }

  103.     EM_ASM({

  104.       var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  105.       var width = parseInt($1 / window.devicePixelRatio);

  106.       var height = parseInt($2 / window.devicePixelRatio);

  107.       canvasWrapper.style.setProperty("min-width", width + 'px');

  108.       canvasWrapper.style.setProperty("max-width", width + 'px');

  109.       canvasWrapper.style.setProperty("min-height", height + 'px');

  110.       canvasWrapper.style.setProperty("max-height", height + 'px');

  111.     }, className, size.width, size.height);

  112.   } else {

  113.     const PuglArea minSize = view->sizeHints[PUGL_MIN_SIZE];

  114.     if (puglIsValidArea(minSize)) {

  115.       EM_ASM({

  116.         var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  117.         canvasWrapper.style.setProperty("min-width", parseInt($1 / window.devicePixelRatio) + 'px');

  118.         canvasWrapper.style.setProperty("min-height", parseInt($2 / window.devicePixelRatio) + 'px');

  119.       }, className, minSize.width, minSize.height);

  120.     } else {

  121.       EM_ASM({

  122.         var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  123.         canvasWrapper.style.removeProperty("min-width");

  124.         canvasWrapper.style.removeProperty("min-height");

  125.       }, className);

  126.     }

  127. 

  128.     const PuglArea maxSize = view->sizeHints[PUGL_MAX_SIZE];

  129.     if (puglIsValidArea(maxSize)) {

  130.       EM_ASM({

  131.         var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  132.         canvasWrapper.style.setProperty("max-width", parseInt($1 / window.devicePixelRatio) + 'px');

  133.         canvasWrapper.style.setProperty("max-height", parseInt($2 / window.devicePixelRatio) + 'px');

  134.       }, className, maxSize.width, maxSize.height);

  135.     } else {

  136.       EM_ASM({

  137.         var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  138.         canvasWrapper.style.removeProperty("max-width");

  139.         canvasWrapper.style.removeProperty("max-height");

  140.       }, className);

  141.     }

  142. 

  143.     /* TODO

  144.      const PuglArea minAspect = view->sizeHints[PUGL_MIN_ASPECT];

  145.      const PuglArea maxAspect = view->sizeHints[PUGL_MAX_ASPECT];

  146.      const PuglArea fixedAspect = view->sizeHints[PUGL_FIXED_ASPECT];

  147.      */

  148.   }

  149. 

  150.   return PUGL_SUCCESS;

  151. }

  152. 

  153. static PuglStatus

  154. puglDispatchEventWithContext(PuglView* const view, const PuglEvent* event)

  155. {

  156.   PuglStatus st0 = PUGL_SUCCESS;

  157.   PuglStatus st1 = PUGL_SUCCESS;

  158. 

  159.   if (!(st0 = view->backend->enter(view, NULL))) {

  160.     st0 = view->eventFunc(view, event);

  161.     st1 = view->backend->leave(view, NULL);

  162.   }

  163. 

  164.   return st0 ? st0 : st1;

  165. }

  166. 

  167. static PuglMods

  168. translateModifiers(const EM_BOOL ctrlKey,

  169.                    const EM_BOOL shiftKey,

  170.                    const EM_BOOL altKey,

  171.                    const EM_BOOL metaKey)

  172. {

  173.   return (ctrlKey  ? PUGL_MOD_CTRL  : 0u) |

  174.          (shiftKey ? PUGL_MOD_SHIFT : 0u) |

  175.          (altKey   ? PUGL_MOD_ALT   : 0u) |

  176.          (metaKey  ? PUGL_MOD_SUPER : 0u);

  177. }

  178. 

  179. #ifndef PUGL_WASM_NO_KEYBOARD_INPUT

  180. static PuglKey

  181. keyCodeToSpecial(const unsigned long code, const unsigned long location)

  182. {

  183.   switch (code) {

  184.   case 0x08: return PUGL_KEY_BACKSPACE;

  185.   case 0x1B: return PUGL_KEY_ESCAPE;

  186.   case 0x2E: return PUGL_KEY_DELETE;

  187.   case 0x70: return PUGL_KEY_F1;

  188.   case 0x71: return PUGL_KEY_F2;

  189.   case 0x72: return PUGL_KEY_F3;

  190.   case 0x73: return PUGL_KEY_F4;

  191.   case 0x74: return PUGL_KEY_F5;

  192.   case 0x75: return PUGL_KEY_F6;

  193.   case 0x76: return PUGL_KEY_F7;

  194.   case 0x77: return PUGL_KEY_F8;

  195.   case 0x78: return PUGL_KEY_F9;

  196.   case 0x79: return PUGL_KEY_F10;

  197.   case 0x7A: return PUGL_KEY_F11;

  198.   case 0x7B: return PUGL_KEY_F12;

  199.   case 0x25: return PUGL_KEY_LEFT;

  200.   case 0x26: return PUGL_KEY_UP;

  201.   case 0x27: return PUGL_KEY_RIGHT;

  202.   case 0x28: return PUGL_KEY_DOWN;

  203.   case 0x21: return PUGL_KEY_PAGE_UP;

  204.   case 0x22: return PUGL_KEY_PAGE_DOWN;

  205.   case 0x24: return PUGL_KEY_HOME;

  206.   case 0x23: return PUGL_KEY_END;

  207.   case 0x2D: return PUGL_KEY_INSERT;

  208.   case 0x10: return location == DOM_KEY_LOCATION_RIGHT ? PUGL_KEY_SHIFT_R : PUGL_KEY_SHIFT_L;

  209.   case 0x11: return location == DOM_KEY_LOCATION_RIGHT ? PUGL_KEY_CTRL_R : PUGL_KEY_CTRL_L;

  210.   case 0x12: return location == DOM_KEY_LOCATION_RIGHT ? PUGL_KEY_ALT_R : PUGL_KEY_ALT_L;

  211.   case 0xE0: return location == DOM_KEY_LOCATION_RIGHT ? PUGL_KEY_SUPER_R : PUGL_KEY_SUPER_L;

  212.   case 0x5D: return PUGL_KEY_MENU;

  213.   case 0x14: return PUGL_KEY_CAPS_LOCK;

  214.   case 0x91: return PUGL_KEY_SCROLL_LOCK;

  215.   case 0x90: return PUGL_KEY_NUM_LOCK;

  216.   case 0x2C: return PUGL_KEY_PRINT_SCREEN;

  217.   case 0x13: return PUGL_KEY_PAUSE;

  218.   case '\r': return (PuglKey)'\r';

  219.   default: break;

  220.   }

  221. 

  222.   return (PuglKey)0;

  223. }

  224. 

  225. static bool

  226. decodeCharacterString(const unsigned long keyCode,

  227.                       const EM_UTF8 key[EM_HTML5_SHORT_STRING_LEN_BYTES],

  228.                       char str[8])

  229. {

  230.   if (key[1] == 0)

  231.   {

  232.     str[0] = key[0];

  233.     return true;

  234.   }

  235. 

  236.   return false;

  237. }

  238. 

  239. static EM_BOOL

  240. puglKeyCallback(const int eventType, const EmscriptenKeyboardEvent* const keyEvent, void* const userData)

  241. {

  242.   PuglView* const view = (PuglView*)userData;

  243. 

  244.   if (!view->impl->visible) {

  245.     return EM_FALSE;

  246.   }

  247. 

  248.   if (keyEvent->repeat && view->hints[PUGL_IGNORE_KEY_REPEAT])

  249.     return EM_TRUE;

  250. 

  251.   PuglStatus st0 = PUGL_SUCCESS;

  252.   PuglStatus st1 = PUGL_SUCCESS;

  253. 

  254.   const uint state = translateModifiers(keyEvent->ctrlKey,

  255.                                         keyEvent->shiftKey,

  256.                                         keyEvent->altKey,

  257.                                         keyEvent->metaKey);

  258. 

  259.   const PuglKey special = keyCodeToSpecial(keyEvent->keyCode, keyEvent->location);

  260. 

  261.   uint key = keyEvent->key[0] >= ' ' && keyEvent->key[0] <= '~' && keyEvent->key[1] == '\0'

  262.            ? keyEvent->key[0]

  263.            : keyEvent->keyCode;

  264. 

  265.   if (key >= 'A' && key <= 'Z' && !keyEvent->shiftKey)

  266.       key += 'a' - 'A';

  267. 

  268.   PuglEvent event = {{PUGL_NOTHING, 0}};

  269.   event.key.type = eventType == EMSCRIPTEN_EVENT_KEYDOWN ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;

  270.   event.key.time = keyEvent->timestamp / 1e3;

  271.   // event.key.x     = xevent.xkey.x;

  272.   // event.key.y     = xevent.xkey.y;

  273.   // event.key.xRoot = xevent.xkey.x_root;

  274.   // event.key.yRoot = xevent.xkey.y_root;

  275.   event.key.key     = special ? special : key;

  276.   event.key.keycode = keyEvent->keyCode;

  277.   event.key.state   = state;

  278.   st0 = puglDispatchEventWithContext(view, &event);

  279. 

  280.   d_debug("key event \n"

  281.            "\tdown:     %d\n"

  282.            "\trepeat:   %d\n"

  283.            "\tlocation: %d\n"

  284.            "\tstate:    0x%x\n"

  285.            "\tkey[]:    '%s'\n"

  286.            "\tcode[]:   '%s'\n"

  287.            "\tlocale[]: '%s'\n"

  288.            "\tkeyCode:  0x%lx:'%c' [deprecated, use key]\n"

  289.            "\twhich:    0x%lx:'%c' [deprecated, use key, same as keycode?]\n"

  290.            "\tspecial:  0x%x",

  291.            eventType == EMSCRIPTEN_EVENT_KEYDOWN,

  292.            keyEvent->repeat,

  293.            keyEvent->location,

  294.            state,

  295.            keyEvent->key,

  296.            keyEvent->code,

  297.            keyEvent->locale,

  298.            keyEvent->keyCode, keyEvent->keyCode >= ' ' && keyEvent->keyCode <= '~' ? keyEvent->keyCode : 0,

  299.            keyEvent->which, keyEvent->which >= ' ' && keyEvent->which <= '~' ? keyEvent->which : 0,

  300.            special);

  301. 

  302.   if (event.type == PUGL_KEY_PRESS && !special && !(keyEvent->ctrlKey|keyEvent->altKey|keyEvent->metaKey)) {

  303.     char str[8] = PUGL_INIT_STRUCT;

  304. 

  305.     if (decodeCharacterString(keyEvent->keyCode, keyEvent->key, str)) {

  306.       d_debug("resulting string is '%s'", str);

  307. 

  308.       event.text.type      = PUGL_TEXT;

  309.       event.text.character = event.key.key;

  310.       memcpy(event.text.string, str, sizeof(event.text.string));

  311.       st1 = puglDispatchEventWithContext(view, &event);

  312.     }

  313.   }

  314. 

  315.   return (st0 ? st0 : st1) == PUGL_SUCCESS ? EM_TRUE : EM_FALSE;

  316. }

  317. #endif

  318. 

  319. static EM_BOOL

  320. puglMouseCallback(const int eventType, const EmscriptenMouseEvent* const mouseEvent, void* const userData)

  321. {

  322.   PuglView* const view = (PuglView*)userData;

  323. 

  324.   if (!view->impl->visible) {

  325.     return EM_FALSE;

  326.   }

  327. 

  328.   PuglEvent event = {{PUGL_NOTHING, 0}};

  329. 

  330.   const double   time  = mouseEvent->timestamp / 1e3;

  331.   const PuglMods state = translateModifiers(mouseEvent->ctrlKey,

  332.                                             mouseEvent->shiftKey,

  333.                                             mouseEvent->altKey,

  334.                                             mouseEvent->metaKey);

  335. 

  336.   double scaleFactor = view->world->impl->scaleFactor;

  337. #ifdef __MOD_DEVICES__

  338.   if (!view->impl->isFullscreen) {

  339.     scaleFactor /= EM_ASM_DOUBLE({

  340.       return parseFloat(

  341.         RegExp('^scale\\\((.*)\\\)$')

  342.         .exec(document.getElementById("pedalboard-dashboard").style.transform)[1]

  343.       );

  344.     }) * MOD_SCALE_FACTOR_MULT;

  345.   }

  346. #endif

  347. 

  348.   // workaround missing pointer lock callback, see https://github.com/emscripten-core/emscripten/issues/9681

  349.   EmscriptenPointerlockChangeEvent e;

  350.   if (emscripten_get_pointerlock_status(&e) == EMSCRIPTEN_RESULT_SUCCESS)

  351.       view->impl->pointerLocked = e.isActive;

  352. 

  353. #ifdef __MOD_DEVICES__

  354.   const long canvasX = mouseEvent->canvasX;

  355.   const long canvasY = mouseEvent->canvasY;

  356. #else

  357.   const char* const className = view->world->strings[PUGL_CLASS_NAME];

  358.   const double canvasX = mouseEvent->clientX - EM_ASM_DOUBLE({

  359.     var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  360.     return canvasWrapper.getBoundingClientRect().x;

  361.   }, className);

  362.   const double canvasY = mouseEvent->clientY - EM_ASM_DOUBLE({

  363.     var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  364.     return canvasWrapper.getBoundingClientRect().y;

  365.   }, className);

  366. #endif

  367. 

  368.   switch (eventType) {

  369.   case EMSCRIPTEN_EVENT_MOUSEDOWN:

  370.   case EMSCRIPTEN_EVENT_MOUSEUP:

  371.     event.button.type  = eventType == EMSCRIPTEN_EVENT_MOUSEDOWN ? PUGL_BUTTON_PRESS : PUGL_BUTTON_RELEASE;

  372.     event.button.time  = time;

  373.     event.button.x     = canvasX * scaleFactor;

  374.     event.button.y     = canvasY * scaleFactor;

  375.     event.button.xRoot = mouseEvent->screenX * scaleFactor;

  376.     event.button.yRoot = mouseEvent->screenY * scaleFactor;

  377.     event.button.state = state;

  378.     switch (mouseEvent->button) {

  379.     case 1:

  380.       event.button.button = 2;

  381.       break;

  382.     case 2:

  383.       event.button.button = 1;

  384.       break;

  385.     default:

  386.       event.button.button = mouseEvent->button;

  387.       break;

  388.     }

  389.     break;

  390.   case EMSCRIPTEN_EVENT_MOUSEMOVE:

  391.     event.motion.type = PUGL_MOTION;

  392.     event.motion.time = time;

  393.     if (view->impl->pointerLocked) {

  394.       // adjust local values for delta

  395.       const double movementX = mouseEvent->movementX * scaleFactor;

  396.       const double movementY = mouseEvent->movementY * scaleFactor;

  397.       view->impl->lastMotion.x += movementX;

  398.       view->impl->lastMotion.y += movementY;

  399.       view->impl->lastMotion.xRoot += movementX;

  400.       view->impl->lastMotion.yRoot += movementY;

  401.       // now set x, y, xRoot and yRoot

  402.       event.motion.x = view->impl->lastMotion.x;

  403.       event.motion.y = view->impl->lastMotion.y;

  404.       event.motion.xRoot = view->impl->lastMotion.xRoot;

  405.       event.motion.yRoot = view->impl->lastMotion.yRoot;

  406.     } else {

  407.       // cache values for possible pointer lock movement later

  408.       view->impl->lastMotion.x = event.motion.x = canvasX * scaleFactor;

  409.       view->impl->lastMotion.y = event.motion.y = canvasY * scaleFactor;

  410.       view->impl->lastMotion.xRoot = event.motion.xRoot = mouseEvent->screenX * scaleFactor;

  411.       view->impl->lastMotion.yRoot = event.motion.yRoot = mouseEvent->screenY * scaleFactor;

  412.     }

  413.     event.motion.state = state;

  414.     break;

  415.   case EMSCRIPTEN_EVENT_MOUSEENTER:

  416.   case EMSCRIPTEN_EVENT_MOUSELEAVE:

  417.     event.crossing.type  = eventType == EMSCRIPTEN_EVENT_MOUSEENTER ? PUGL_POINTER_IN : PUGL_POINTER_OUT;

  418.     event.crossing.time  = time;

  419.     event.crossing.x     = canvasX * scaleFactor;

  420.     event.crossing.y     = canvasY * scaleFactor;

  421.     event.crossing.xRoot = mouseEvent->screenX * scaleFactor;

  422.     event.crossing.yRoot = mouseEvent->screenY * scaleFactor;

  423.     event.crossing.state = state;

  424.     event.crossing.mode  = PUGL_CROSSING_NORMAL;

  425.     break;

  426.   }

  427. 

  428.   if (event.type == PUGL_NOTHING)

  429.     return EM_FALSE;

  430. 

  431.   puglDispatchEventWithContext(view, &event);

  432. 

  433. #ifdef PUGL_WASM_AUTO_POINTER_LOCK

  434.   switch (eventType) {

  435.   case EMSCRIPTEN_EVENT_MOUSEDOWN:

  436.     emscripten_request_pointerlock(view->world->strings[PUGL_CLASS_NAME], false);

  437.     break;

  438.   case EMSCRIPTEN_EVENT_MOUSEUP:

  439.     emscripten_exit_pointerlock();

  440.     break;

  441.   }

  442. #endif

  443. 

  444.   // note: we must always return false, otherwise canvas never gets keyboard input

  445.   return EM_FALSE;

  446. }

  447. 

  448. static void

  449. puglTouchStartDelay(void* const userData)

  450. {

  451.   PuglView*      const view = (PuglView*)userData;

  452.   PuglInternals* const impl  = view->impl;

  453. 

  454.   impl->buttonPressTimeout = -1;

  455.   impl->nextButtonEvent.button.time += 2000;

  456.   puglDispatchEventWithContext(view, &impl->nextButtonEvent);

  457. }

  458. 

  459. static EM_BOOL

  460. puglTouchCallback(const int eventType, const EmscriptenTouchEvent* const touchEvent, void* const userData)

  461. {

  462.   if (touchEvent->numTouches <= 0) {

  463.     return EM_FALSE;

  464.   }

  465. 

  466.   PuglView*      const view   = (PuglView*)userData;

  467.   PuglInternals* const impl   = view->impl;

  468.   const char* const className = view->world->strings[PUGL_CLASS_NAME];

  469. 

  470.   if (impl->supportsTouch == PUGL_DONT_CARE) {

  471.     impl->supportsTouch = PUGL_TRUE;

  472. 

  473.     // stop using mouse press events which conflict with touch

  474.     emscripten_set_mousedown_callback(className, view, false, NULL);

  475.     emscripten_set_mouseup_callback(className, view, false, NULL);

  476.   }

  477. 

  478.   if (!view->impl->visible) {

  479.     return EM_FALSE;

  480.   }

  481. 

  482.   PuglEvent event = {{PUGL_NOTHING, 0}};

  483. 

  484.   const double   time  = touchEvent->timestamp / 1e3;

  485.   const PuglMods state = translateModifiers(touchEvent->ctrlKey,

  486.                                             touchEvent->shiftKey,

  487.                                             touchEvent->altKey,

  488.                                             touchEvent->metaKey);

  489. 

  490.   double scaleFactor = view->world->impl->scaleFactor;

  491. #ifdef __MOD_DEVICES__

  492.   if (!view->impl->isFullscreen) {

  493.     scaleFactor /= EM_ASM_DOUBLE({

  494.       return parseFloat(

  495.         RegExp('^scale\\\((.*)\\\)$')

  496.         .exec(document.getElementById("pedalboard-dashboard").style.transform)[1]

  497.       );

  498.     }) * MOD_SCALE_FACTOR_MULT;

  499.   }

  500. #endif

  501. 

  502.   d_debug("touch %d|%s %d || %ld",

  503.           eventType,

  504.           eventType == EMSCRIPTEN_EVENT_TOUCHSTART ? "start" :

  505.           eventType == EMSCRIPTEN_EVENT_TOUCHEND ? "end" : "cancel",

  506.           touchEvent->numTouches,

  507.           impl->buttonPressTimeout);

  508. 

  509.   const EmscriptenTouchPoint* point = &touchEvent->touches[0];

  510. 

  511.   if (impl->buttonPressTimeout != -1 || eventType == EMSCRIPTEN_EVENT_TOUCHCANCEL) {

  512.     // if we received an event while touch is active, trigger initial click now

  513.     if (impl->buttonPressTimeout != -1) {

  514.       emscripten_clear_timeout(impl->buttonPressTimeout);

  515.       impl->buttonPressTimeout = -1;

  516.       if (eventType != EMSCRIPTEN_EVENT_TOUCHCANCEL) {

  517.         impl->nextButtonEvent.button.button = 0;

  518.       }

  519.     }

  520.     impl->nextButtonEvent.button.time = time;

  521.     puglDispatchEventWithContext(view, &impl->nextButtonEvent);

  522.   }

  523. 

  524. #ifdef __MOD_DEVICES__

  525.   const long canvasX = point->canvasX;

  526.   const long canvasY = point->canvasY;

  527. #else

  528.   const double canvasX = point->clientX - EM_ASM_DOUBLE({

  529.     var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  530.     return canvasWrapper.getBoundingClientRect().x;

  531.   }, className);

  532.   const double canvasY = point->clientY - EM_ASM_DOUBLE({

  533.     var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  534.     return canvasWrapper.getBoundingClientRect().y;

  535.   }, className);

  536. #endif

  537. 

  538.   switch (eventType) {

  539.   case EMSCRIPTEN_EVENT_TOUCHEND:

  540.   case EMSCRIPTEN_EVENT_TOUCHCANCEL:

  541.     event.button.type   = PUGL_BUTTON_RELEASE;

  542.     event.button.time   = time;

  543.     event.button.button = eventType == EMSCRIPTEN_EVENT_TOUCHCANCEL ? 1 : 0;

  544.     event.button.x      = canvasX * scaleFactor;

  545.     event.button.y      = canvasY * scaleFactor;

  546.     event.button.xRoot  = point->screenX * scaleFactor;

  547.     event.button.yRoot  = point->screenY * scaleFactor;

  548.     event.button.state  = state;

  549.     break;

  550. 

  551.   case EMSCRIPTEN_EVENT_TOUCHSTART:

  552.     // this event can be used for a couple of things, store it until we know more

  553.     event.button.type   = PUGL_BUTTON_PRESS;

  554.     event.button.time   = time;

  555.     event.button.button = 1; // if no other event occurs soon, treat it as right-click

  556.     event.button.x      = canvasX * scaleFactor;

  557.     event.button.y      = canvasY * scaleFactor;

  558.     event.button.xRoot  = point->screenX * scaleFactor;

  559.     event.button.yRoot  = point->screenY * scaleFactor;

  560.     event.button.state  = state;

  561.     memcpy(&impl->nextButtonEvent, &event, sizeof(PuglEvent));

  562.     impl->buttonPressTimeout = emscripten_set_timeout(puglTouchStartDelay, 2000, view);

  563.     // fall through, moving "mouse" to touch position

  564. 

  565.   case EMSCRIPTEN_EVENT_TOUCHMOVE:

  566.     event.motion.type  = PUGL_MOTION;

  567.     event.motion.time  = time;

  568.     event.motion.x     = canvasX * scaleFactor;

  569.     event.motion.y     = canvasY * scaleFactor;

  570.     event.motion.xRoot = point->screenX * scaleFactor;

  571.     event.motion.yRoot = point->screenY * scaleFactor;

  572.     event.motion.state = state;

  573.     break;

  574.   }

  575. 

  576.   if (event.type == PUGL_NOTHING)

  577.     return EM_FALSE;

  578. 

  579.   puglDispatchEventWithContext(view, &event);

  580. 

  581.   // FIXME we must always return false??

  582.   return EM_FALSE;

  583. }

  584. 

  585. static EM_BOOL

  586. puglFocusCallback(const int eventType, const EmscriptenFocusEvent* /*const focusEvent*/, void* const userData)

  587. {

  588.   PuglView* const view = (PuglView*)userData;

  589. 

  590.   if (!view->impl->visible) {

  591.     return EM_FALSE;

  592.   }

  593. 

  594.   d_debug("focus %d|%s", eventType, eventType == EMSCRIPTEN_EVENT_FOCUSIN ? "focus-in" : "focus-out");

  595. 

  596.   PuglEvent event = {{eventType == EMSCRIPTEN_EVENT_FOCUSIN ? PUGL_FOCUS_IN : PUGL_FOCUS_OUT, 0}};

  597.   event.focus.mode = PUGL_CROSSING_NORMAL;

  598. 

  599.   puglDispatchEventWithContext(view, &event);

  600. 

  601.   // note: we must always return false, otherwise canvas never gets proper focus

  602.   return EM_FALSE;

  603. }

  604. 

  605. static EM_BOOL

  606. puglPointerLockChangeCallback(const int eventType, const EmscriptenPointerlockChangeEvent* event, void* const userData)

  607. {

  608.   PuglView* const view = (PuglView*)userData;

  609. 

  610.   view->impl->pointerLocked = event->isActive;

  611.   return EM_TRUE;

  612. }

  613. 

  614. #ifndef PUGL_WASM_NO_MOUSEWHEEL_INPUT

  615. static EM_BOOL

  616. puglWheelCallback(const int eventType, const EmscriptenWheelEvent* const wheelEvent, void* const userData)

  617. {

  618.   PuglView* const view = (PuglView*)userData;

  619. 

  620.   if (!view->impl->visible) {

  621.     return EM_FALSE;

  622.   }

  623. 

  624.   double scaleFactor = view->world->impl->scaleFactor;

  625. #ifdef __MOD_DEVICES__

  626.   if (!view->impl->isFullscreen) {

  627.     scaleFactor /= EM_ASM_DOUBLE({

  628.       return parseFloat(

  629.         RegExp('^scale\\\((.*)\\\)$')

  630.         .exec(document.getElementById("pedalboard-dashboard").style.transform)[1]

  631.       );

  632.     }) * MOD_SCALE_FACTOR_MULT;

  633.   }

  634. #endif

  635. 

  636. #ifdef __MOD_DEVICES__

  637.   const long canvasX = wheelEvent->mouse.canvasX;

  638.   const long canvasY = wheelEvent->mouse.canvasY;

  639. #else

  640.   const char* const className = view->world->strings[PUGL_CLASS_NAME];

  641.   const double canvasX = wheelEvent->mouse.canvasX - EM_ASM_INT({

  642.     var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  643.     return canvasWrapper.getBoundingClientRect().x;

  644.   }, className);

  645.   const double canvasY = wheelEvent->mouse.canvasY - EM_ASM_INT({

  646.     var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  647.     return canvasWrapper.getBoundingClientRect().y;

  648.   }, className);

  649. #endif

  650. 

  651.   PuglEvent event = {{PUGL_SCROLL, 0}};

  652.   event.scroll.time  = wheelEvent->mouse.timestamp / 1e3;

  653.   event.scroll.x     = canvasX;

  654.   event.scroll.y     = canvasY;

  655.   event.scroll.xRoot = wheelEvent->mouse.screenX;

  656.   event.scroll.yRoot = wheelEvent->mouse.screenY;

  657.   event.scroll.state = translateModifiers(wheelEvent->mouse.ctrlKey,

  658.                                           wheelEvent->mouse.shiftKey,

  659.                                           wheelEvent->mouse.altKey,

  660.                                           wheelEvent->mouse.metaKey);

  661.   event.scroll.direction = PUGL_SCROLL_SMOOTH;

  662.   // FIXME handle wheelEvent->deltaMode

  663.   event.scroll.dx = wheelEvent->deltaX * 0.01 * scaleFactor;

  664.   event.scroll.dy = -wheelEvent->deltaY * 0.01 * scaleFactor;

  665. 

  666.   return puglDispatchEventWithContext(view, &event) == PUGL_SUCCESS ? EM_TRUE : EM_FALSE;

  667. }

  668. #endif

  669. 

  670. static EM_BOOL

  671. puglUiCallback(const int eventType, const EmscriptenUiEvent* const uiEvent, void* const userData)

  672. {

  673.   PuglView* const view = (PuglView*)userData;

  674.   const char* const className = view->world->strings[PUGL_CLASS_NAME];

  675.   const bool isFullscreen = view->impl->isFullscreen;

  676. 

  677.   // FIXME

  678.   const int width = EM_ASM_INT({

  679.     var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  680.     canvasWrapper.style.setProperty("--device-pixel-ratio", window.devicePixelRatio);

  681.     if ($1) {

  682.       return window.innerWidth;

  683.     } else {

  684.       return canvasWrapper.clientWidth;

  685.     }

  686.   }, className, isFullscreen);

  687. 

  688.   const int height = EM_ASM_INT({

  689.     if ($1) {

  690.       return window.innerHeight;

  691.     } else {

  692.       var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  693.       return canvasWrapper.clientHeight;

  694.     }

  695.   }, className, isFullscreen);

  696. 

  697.   if (!width || !height)

  698.     return EM_FALSE;

  699. 

  700.   double scaleFactor = emscripten_get_device_pixel_ratio();

  701. #ifdef __MOD_DEVICES__

  702.   scaleFactor *= MOD_SCALE_FACTOR_MULT;

  703. #endif

  704.   view->world->impl->scaleFactor = scaleFactor;

  705. 

  706.   PuglEvent event        = {{PUGL_CONFIGURE, 0}};

  707.   event.configure.x      = view->lastConfigure.x;

  708.   event.configure.y      = view->lastConfigure.y;

  709.   event.configure.width  = width * scaleFactor;

  710.   event.configure.height = height * scaleFactor;

  711.   puglDispatchEvent(view, &event);

  712. 

  713.   emscripten_set_canvas_element_size(view->world->strings[PUGL_CLASS_NAME],

  714.                                      width * scaleFactor,

  715.                                      height * scaleFactor);

  716. 

  717. #ifdef __MOD_DEVICES__

  718.   if (isFullscreen) {

  719.     EM_ASM({

  720.       document.getElementById("pedalboard-dashboard").style.transform = "scale(1.0)";

  721.     });

  722.   }

  723. #endif

  724. 

  725.   return EM_TRUE;

  726. }

  727. 

  728. static EM_BOOL

  729. puglFullscreenChangeCallback(const int eventType, const EmscriptenFullscreenChangeEvent* const fscEvent, void* const userData)

  730. {

  731.   PuglView* const view = (PuglView*)userData;

  732. 

  733.   view->impl->isFullscreen = fscEvent->isFullscreen;

  734. 

  735.   double scaleFactor = emscripten_get_device_pixel_ratio();

  736. #ifdef __MOD_DEVICES__

  737.   scaleFactor *= MOD_SCALE_FACTOR_MULT;

  738. #endif

  739. 

  740.   view->world->impl->scaleFactor = scaleFactor;

  741. 

  742.   if (!fscEvent->isFullscreen)

  743.     return puglUiCallback(0, NULL, userData);

  744. 

  745.   const int width = EM_ASM_INT({

  746.     return window.innerWidth;

  747.   });

  748. 

  749.   const int height = EM_ASM_INT({

  750.     return window.innerHeight;

  751.   });

  752. 

  753.   PuglEvent event        = {{PUGL_CONFIGURE, 0}};

  754.   event.configure.x      = 0;

  755.   event.configure.y      = 0;

  756.   event.configure.width  = width;

  757.   event.configure.height = height;

  758.   puglDispatchEvent(view, &event);

  759. 

  760.   emscripten_set_canvas_element_size(view->world->strings[PUGL_CLASS_NAME], width, height);

  761. 

  762. #ifdef __MOD_DEVICES__

  763.   EM_ASM({

  764.     document.getElementById("pedalboard-dashboard").style.transform = "scale(1.0)";

  765.   });

  766. #endif

  767. 

  768.   return EM_TRUE;

  769. }

  770. 

  771. static EM_BOOL

  772. puglVisibilityChangeCallback(const int eventType, const EmscriptenVisibilityChangeEvent* const visibilityChangeEvent, void* const userData)

  773. {

  774.   PuglView* const view = (PuglView*)userData;

  775. 

  776.   view->impl->visible = visibilityChangeEvent->hidden == EM_FALSE;

  777.   return EM_FALSE;

  778. }

  779. 

  780. PuglStatus

  781. puglRealize(PuglView* const view)

  782. {

  783.   printf("TODO: %s %d\n", __func__, __LINE__);

  784.   PuglStatus st = PUGL_SUCCESS;

  785. 

  786.   // Ensure that we do not have a parent

  787.   if (view->parent) {

  788.   printf("TODO: %s %d\n", __func__, __LINE__);

  789.     return PUGL_FAILURE;

  790.   }

  791. 

  792.   if (!view->backend || !view->backend->configure) {

  793.   printf("TODO: %s %d\n", __func__, __LINE__);

  794.     return PUGL_BAD_BACKEND;

  795.   }

  796. 

  797.   const char* const className = view->world->strings[PUGL_CLASS_NAME];

  798.   d_stdout("className is %s", className);

  799. 

  800.   const PuglPoint defaultPos = view->positionHints[PUGL_DEFAULT_POSITION];

  801.   const PuglArea defaultSize = view->sizeHints[PUGL_DEFAULT_SIZE];

  802.   if (!defaultSize.width || !defaultSize.height) {

  803.     return PUGL_BAD_CONFIGURATION;

  804.   }

  805. 

  806.   // Configure and create the backend

  807.   if ((st = view->backend->configure(view)) || (st = view->backend->create(view))) {

  808.     view->backend->destroy(view);

  809.     return st;

  810.   }

  811. 

  812.   if (view->strings[PUGL_WINDOW_TITLE]) {

  813.     emscripten_set_window_title(view->strings[PUGL_WINDOW_TITLE]);

  814.   }

  815. 

  816.   puglDispatchSimpleEvent(view, PUGL_REALIZE);

  817. 

  818.   PuglEvent event        = {{PUGL_CONFIGURE, 0}};

  819.   event.configure.x      = defaultPos.x;

  820.   event.configure.y      = defaultPos.y;

  821.   event.configure.width  = defaultSize.width;

  822.   event.configure.height = defaultSize.height;

  823.   puglDispatchEvent(view, &event);

  824. 

  825.   view->impl->created = true;

  826. 

  827.   EM_ASM({

  828.    var canvasWrapper = document.getElementById(UTF8ToString($0)).parentElement;

  829.    canvasWrapper.style.setProperty("--device-pixel-ratio", window.devicePixelRatio);

  830.   }, className);

  831. 

  832.   puglUpdateSizeHints(view);

  833. 

  834.   emscripten_set_canvas_element_size(className, defaultSize.width, defaultSize.height);

  835. #ifndef PUGL_WASM_NO_KEYBOARD_INPUT

  836. //   emscripten_set_keypress_callback(className, view, false, puglKeyCallback);

  837.   emscripten_set_keydown_callback(className, view, false, puglKeyCallback);

  838.   emscripten_set_keyup_callback(className, view, false, puglKeyCallback);

  839. #endif

  840.   emscripten_set_touchstart_callback(className, view, false, puglTouchCallback);

  841.   emscripten_set_touchend_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, view, false, puglTouchCallback);

  842.   emscripten_set_touchmove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, view, false, puglTouchCallback);

  843.   emscripten_set_touchcancel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, view, false, puglTouchCallback);

  844.   emscripten_set_mousedown_callback(className, view, false, puglMouseCallback);

  845.   emscripten_set_mouseup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, view, false, puglMouseCallback);

  846.   emscripten_set_mousemove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, view, false, puglMouseCallback);

  847.   emscripten_set_mouseenter_callback(className, view, false, puglMouseCallback);

  848.   emscripten_set_mouseleave_callback(className, view, false, puglMouseCallback);

  849.   emscripten_set_focusin_callback(className, view, false, puglFocusCallback);

  850.   emscripten_set_focusout_callback(className, view, false, puglFocusCallback);

  851. #ifndef PUGL_WASM_NO_MOUSEWHEEL_INPUT

  852.   emscripten_set_wheel_callback(className, view, false, puglWheelCallback);

  853. #endif

  854.   emscripten_set_pointerlockchange_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, view, false, puglPointerLockChangeCallback);

  855.   emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, view, false, puglUiCallback);

  856.   emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, view, false, puglFullscreenChangeCallback);

  857.   emscripten_set_visibilitychange_callback(view, false, puglVisibilityChangeCallback);

  858. 

  859.   printf("TODO: %s %d\n", __func__, __LINE__);

  860.   return PUGL_SUCCESS;

  861. }

  862. 

  863. PuglStatus

  864. puglShow(PuglView* const view, PuglShowCommand)

  865. {

  866.   view->impl->visible = true;

  867.   view->impl->needsRepaint = true;

  868.   return puglObscureView(view);

  869. }

  870. 

  871. PuglStatus

  872. puglHide(PuglView* const view)

  873. {

  874.   view->impl->visible = false;

  875.   return PUGL_FAILURE;

  876. }

  877. 

  878. void

  879. puglFreeViewInternals(PuglView* const view)

  880. {

  881.   printf("DONE: %s %d\n", __func__, __LINE__);

  882.   if (view && view->impl) {

  883.     if (view->backend) {

  884.       // unregister the window events, to make sure no callbacks to old views are triggered

  885.       emscripten_set_touchend_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, NULL);

  886.       emscripten_set_touchmove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, NULL);

  887.       emscripten_set_touchcancel_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, NULL);

  888.       emscripten_set_mouseup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, NULL);

  889.       emscripten_set_mousemove_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, NULL);

  890.       emscripten_set_pointerlockchange_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, NULL);

  891.       emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, NULL);

  892.       emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, false, NULL);

  893.       emscripten_set_visibilitychange_callback(NULL, false, NULL);

  894.       view->backend->destroy(view);

  895.     }

  896.     free(view->impl->clipboardData);

  897.     free(view->impl->timers);

  898.     free(view->impl);

  899.   }

  900. }

  901. 

  902. void

  903. puglFreeWorldInternals(PuglWorld* const world)

  904. {

  905.   printf("DONE: %s %d\n", __func__, __LINE__);

  906.   free(world->impl);

  907. }

  908. 

  909. PuglStatus

  910. puglGrabFocus(PuglView*)

  911. {

  912.   return PUGL_FAILURE;

  913. }

  914. 

  915. double

  916. puglGetScaleFactor(const PuglView* const view)

  917. {

  918.   printf("DONE: %s %d\n", __func__, __LINE__);

  919.   return view->world->impl->scaleFactor;

  920. }

  921. 

  922. double

  923. puglGetTime(const PuglWorld*)

  924. {

  925.   return emscripten_get_now() / 1e3;

  926. }

  927. 

  928. PuglStatus

  929. puglUpdate(PuglWorld* const world, const double timeout)

  930. {

  931.   for (size_t i = 0; i < world->numViews; ++i) {

  932.     PuglView* const view = world->views[i];

  933. 

  934.     if (!view->impl->visible) {

  935.       continue;

  936.     }

  937. 

  938.     puglDispatchSimpleEvent(view, PUGL_UPDATE);

  939. 

  940.     if (!view->impl->needsRepaint) {

  941.       continue;

  942.     }

  943. 

  944.     view->impl->needsRepaint = false;

  945. 

  946.     PuglEvent event     = {{PUGL_EXPOSE, 0}};

  947.     event.expose.x      = view->lastConfigure.x;

  948.     event.expose.y      = view->lastConfigure.y;

  949.     event.expose.width  = view->lastConfigure.width;

  950.     event.expose.height = view->lastConfigure.height;

  951.     puglDispatchEvent(view, &event);

  952.   }

  953. 

  954.   return PUGL_SUCCESS;

  955. }

  956. 

  957. PuglStatus

  958. puglObscureView(PuglView* const view)

  959. {

  960.   view->impl->needsRepaint = true;

  961.   return PUGL_SUCCESS;

  962. }

  963. 

  964. PuglStatus

  965. puglObscureRegion(PuglView*      view,

  966.                   const int      x,

  967.                   const int      y,

  968.                   const unsigned width,

  969.                   const unsigned height)

  970. {

  971.   if (!puglIsValidPosition(x, y) || !puglIsValidSize(width, height)) {

  972.     return PUGL_BAD_PARAMETER;

  973.   }

  974. 

  975.   view->impl->needsRepaint = true;

  976.   return PUGL_FAILURE;

  977. }

  978. 

  979. PuglNativeView

  980. puglGetNativeView(const PuglView* const view)

  981. {

  982.   return 0;

  983. }

  984. 

  985. PuglStatus

  986. puglViewStringChanged(PuglView*, const PuglStringHint key, const char* const value)

  987. {

  988.   switch (key) {

  989.   case PUGL_CLASS_NAME:

  990.     break;

  991.   case PUGL_WINDOW_TITLE:

  992.     emscripten_set_window_title(value);

  993.     break;

  994.   }

  995. 

  996.   return PUGL_SUCCESS;

  997. }

  998. 

  999. PuglStatus

  1000. puglSetWindowSize(PuglView* const view, const unsigned width, const unsigned height)

  1001. {

  1002.   if (view->impl->created) {

  1003.     const char* const className = view->world->strings[PUGL_CLASS_NAME];

  1004.     emscripten_set_canvas_element_size(className, width, height);

  1005.   }

  1006. 

  1007.   return PUGL_SUCCESS;

  1008. }

  1009. 

  1010. static EM_BOOL

  1011. puglTimerLoopCallback(double timeout, void* const arg)

  1012. {

  1013.   PuglTimer*     const timer = (PuglTimer*)arg;

  1014.   PuglInternals* const impl  = timer->view->impl;

  1015. 

  1016.   // only handle active timers

  1017.   for (uint32_t i=0; i<impl->numTimers; ++i)

  1018.   {

  1019.     if (impl->timers[i].id == timer->id)

  1020.     {

  1021.       PuglEvent event = {{PUGL_TIMER, 0}};

  1022.       event.timer.id  = timer->id;

  1023.       puglDispatchEventWithContext(timer->view, &event);

  1024.       return EM_TRUE;

  1025.     }

  1026.   }

  1027. 

  1028.   return EM_FALSE;

  1029. 

  1030.   // unused

  1031.   (void)timeout;

  1032. }

  1033. 

  1034. PuglStatus

  1035. puglStartTimer(PuglView* const view, const uintptr_t id, const double timeout)

  1036. {

  1037.   printf("DONE: %s %d\n", __func__, __LINE__);

  1038.   PuglInternals* const impl = view->impl;

  1039.   const uint32_t timerIndex = impl->numTimers++;

  1040. 

  1041.   if (impl->timers == NULL)

  1042.     impl->timers = (PuglTimer*)malloc(sizeof(PuglTimer));

  1043.   else

  1044.     impl->timers = (PuglTimer*)realloc(impl->timers, sizeof(PuglTimer) * timerIndex);

  1045. 

  1046.   PuglTimer* const timer = &impl->timers[timerIndex];

  1047.   timer->view = view;

  1048.   timer->id = id;

  1049. 

  1050.   emscripten_set_timeout_loop(puglTimerLoopCallback, timeout * 1e3, timer);

  1051.   return PUGL_SUCCESS;

  1052. }

  1053. 

  1054. PuglStatus

  1055. puglStopTimer(PuglView* const view, const uintptr_t id)

  1056. {

  1057.   printf("DONE: %s %d\n", __func__, __LINE__);

  1058.   PuglInternals* const impl = view->impl;

  1059. 

  1060.   if (impl->timers == NULL || impl->numTimers == 0)

  1061.     return PUGL_FAILURE;

  1062. 

  1063.   for (uint32_t i=0; i<impl->numTimers; ++i)

  1064.   {

  1065.     if (impl->timers[i].id == id)

  1066.     {

  1067.       memmove(impl->timers + i, impl->timers + (i + 1), sizeof(PuglTimer) * (impl->numTimers - 1));

  1068.       --impl->numTimers;

  1069.       return PUGL_SUCCESS;

  1070.     }

  1071.   }

  1072. 

  1073.   return PUGL_FAILURE;

  1074. }

  1075. 

  1076. #ifdef PUGL_WASM_ASYNC_CLIPBOARD

  1077. EM_JS(char*, puglGetAsyncClipboardData, (), {

  1078.   var text = Asyncify.handleSleep(function(wakeUp) {

  1079.     navigator.clipboard.readText()

  1080.       .then(function(text) {

  1081.         wakeUp(text);

  1082.       })

  1083.       .catch(function() {

  1084.         wakeUp("");

  1085.       });

  1086.   });

  1087.   if (!text.length) {

  1088.     return null;

  1089.   }

  1090.   var length = lengthBytesUTF8(text) + 1;

  1091.   var str = _malloc(length);

  1092.   stringToUTF8(text, str, length);

  1093.   return str;

  1094. });

  1095. #endif

  1096. 

  1097. PuglStatus

  1098. puglPaste(PuglView* const view)

  1099. {

  1100. #ifdef PUGL_WASM_ASYNC_CLIPBOARD

  1101.   // abort early if we already know it is not supported

  1102.   if (view->impl->supportsClipboardRead == PUGL_FALSE) {

  1103.     return PUGL_UNSUPPORTED;

  1104.   }

  1105. 

  1106.   free(view->impl->clipboardData);

  1107.   view->impl->clipboardData = puglGetAsyncClipboardData();

  1108. #endif

  1109. 

  1110.   if (view->impl->clipboardData == NULL) {

  1111.     return PUGL_FAILURE;

  1112.   }

  1113. 

  1114.   const PuglDataOfferEvent offer = {

  1115.     PUGL_DATA_OFFER,

  1116.     0,

  1117.     emscripten_get_now() / 1e3,

  1118.   };

  1119. 

  1120.   PuglEvent offerEvent;

  1121.   offerEvent.offer = offer;

  1122.   puglDispatchEvent(view, &offerEvent);

  1123.   return PUGL_SUCCESS;

  1124. }

  1125. 

  1126. PuglStatus

  1127. puglAcceptOffer(PuglView* const                 view,

  1128.                 const PuglDataOfferEvent* const offer,

  1129.                 const uint32_t                  typeIndex)

  1130. {

  1131.   if (typeIndex != 0) {

  1132.     return PUGL_UNSUPPORTED;

  1133.   }

  1134. 

  1135.   const PuglDataEvent data = {

  1136.     PUGL_DATA,

  1137.     0,

  1138.     emscripten_get_now() / 1e3,

  1139.     0,

  1140.   };

  1141. 

  1142.   PuglEvent dataEvent;

  1143.   dataEvent.data = data;

  1144.   puglDispatchEvent(view, &dataEvent);

  1145.   return PUGL_SUCCESS;

  1146. }

  1147. 

  1148. uint32_t

  1149. puglGetNumClipboardTypes(const PuglView* const view)

  1150. {

  1151.   return view->impl->clipboardData != NULL ? 1u : 0u;

  1152. }

  1153. 

  1154. const char*

  1155. puglGetClipboardType(const PuglView* const view, const uint32_t typeIndex)

  1156. {

  1157.   return (typeIndex == 0 && view->impl->clipboardData != NULL)

  1158.            ? "text/plain"

  1159.            : NULL;

  1160. }

  1161. 

  1162. const void*

  1163. puglGetClipboard(PuglView* const view,

  1164.                  const uint32_t  typeIndex,

  1165.                  size_t* const   len)

  1166. {

  1167.   return view->impl->clipboardData;

  1168. }

  1169. 

  1170. PuglStatus

  1171. puglSetClipboard(PuglView* const   view,

  1172.                  const char* const type,

  1173.                  const void* const data,

  1174.                  const size_t      len)

  1175. {

  1176.   // only utf8 text supported for now

  1177.   if (type != NULL && strcmp(type, "text/plain") != 0) {

  1178.     return PUGL_UNSUPPORTED;

  1179.   }

  1180. 

  1181.   const char* const className = view->world->strings[PUGL_CLASS_NAME];

  1182.   const char* const text      = (const char*)data;

  1183. 

  1184. #ifdef PUGL_WASM_ASYNC_CLIPBOARD

  1185.   // abort early if we already know it is not supported

  1186.   if (view->impl->supportsClipboardWrite == PUGL_FALSE) {

  1187.     return PUGL_UNSUPPORTED;

  1188.   }

  1189. #else

  1190.   puglSetString(&view->impl->clipboardData, text);

  1191. #endif

  1192. 

  1193.   EM_ASM({

  1194.     if (typeof(navigator.clipboard) !== 'undefined' && typeof(navigator.clipboard.writeText) === 'function' && window.isSecureContext) {

  1195.       navigator.clipboard.writeText(UTF8ToString($1));

  1196.     } else {

  1197.       var canvasClipboardObjName = UTF8ToString($0) + "_clipboard";

  1198.       var canvasClipboardElem = document.getElementById(canvasClipboardObjName);

  1199. 

  1200.       if (!canvasClipboardElem) {

  1201.         canvasClipboardElem = document.createElement('textarea');

  1202.         canvasClipboardElem.id = canvasClipboardObjName;

  1203.         canvasClipboardElem.style.position = 'fixed';

  1204.         canvasClipboardElem.style.whiteSpace = 'pre';

  1205.         canvasClipboardElem.style.zIndex = '-1';

  1206.         canvasClipboardElem.setAttribute('readonly', true);

  1207.         document.body.appendChild(canvasClipboardElem);

  1208.       }

  1209. 

  1210.       canvasClipboardElem.textContent = UTF8ToString($1);

  1211.       canvasClipboardElem.select();

  1212.       document.execCommand("copy");

  1213.     }

  1214.   }, className, text);

  1215. 

  1216.   // FIXME proper return status

  1217.   return PUGL_SUCCESS;

  1218. }

  1219. 

  1220. PuglStatus

  1221. puglSetCursor(PuglView* const view, const PuglCursor cursor)

  1222. {

  1223.   printf("TODO: %s %d\n", __func__, __LINE__);

  1224.   return PUGL_FAILURE;

  1225. }

  1226. 

  1227. PuglStatus

  1228. puglSetTransientParent(PuglView* const view, const PuglNativeView parent)

  1229. {

  1230.   printf("TODO: %s %d\n", __func__, __LINE__);

  1231.   view->transientParent = parent;

  1232.   return PUGL_FAILURE;

  1233. }