xbintsc 0.5.36 → 0.5.38

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (124) hide show
  1. package/dist/src/cli/help.d.ts +1 -1
  2. package/dist/src/codegen/generator/state.js +1 -0
  3. package/dist/src/codegen/generator/state.js.map +1 -1
  4. package/dist/src/codegen/generator/tables.js +1 -0
  5. package/dist/src/codegen/generator/tables.js.map +1 -1
  6. package/dist/src/driver/bundler/deferred.d.ts +63 -0
  7. package/dist/src/driver/bundler/deferred.js +279 -0
  8. package/dist/src/driver/bundler/deferred.js.map +1 -0
  9. package/dist/src/driver/bundler/merge.js +214 -2
  10. package/dist/src/driver/bundler/merge.js.map +1 -1
  11. package/dist/src/driver/runtime-objects.d.ts +1 -1
  12. package/dist/src/driver/runtime-objects.js +1 -0
  13. package/dist/src/driver/runtime-objects.js.map +1 -1
  14. package/dist/src/driver/version.d.ts +1 -1
  15. package/dist/src/driver/version.js +1 -1
  16. package/dist/src/extensions/gui/html.js +89 -13
  17. package/dist/src/extensions/gui/html.js.map +1 -1
  18. package/dist/src/extensions/gui/index.js +13 -0
  19. package/dist/src/extensions/gui/index.js.map +1 -1
  20. package/dist/src/extensions/gui/three.d.ts +4 -3
  21. package/dist/src/extensions/gui/three.js +4 -3
  22. package/dist/src/extensions/gui/three.js.map +1 -1
  23. package/dist/tests/e2e/gui-browser.test.js +65 -0
  24. package/dist/tests/e2e/gui-browser.test.js.map +1 -1
  25. package/dist/tests/e2e/gui-canvas-args.test.d.ts +6 -0
  26. package/dist/tests/e2e/gui-canvas-args.test.js +217 -0
  27. package/dist/tests/e2e/gui-canvas-args.test.js.map +1 -0
  28. package/dist/tests/e2e/gui-canvas.test.js.map +1 -1
  29. package/dist/tests/e2e/gui-dom.test.js +215 -0
  30. package/dist/tests/e2e/gui-dom.test.js.map +1 -1
  31. package/dist/tests/e2e/gui-events.test.js +112 -0
  32. package/dist/tests/e2e/gui-events.test.js.map +1 -1
  33. package/dist/tests/e2e/gui-script-import-order.test.d.ts +10 -0
  34. package/dist/tests/e2e/gui-script-import-order.test.js +161 -0
  35. package/dist/tests/e2e/gui-script-import-order.test.js.map +1 -0
  36. package/dist/tests/e2e/gui-webgl2-shadow.test.d.ts +10 -0
  37. package/dist/tests/e2e/gui-webgl2-shadow.test.js +108 -0
  38. package/dist/tests/e2e/gui-webgl2-shadow.test.js.map +1 -0
  39. package/dist/tests/e2e/url.test.d.ts +6 -0
  40. package/dist/tests/e2e/url.test.js +114 -0
  41. package/dist/tests/e2e/url.test.js.map +1 -0
  42. package/dist/tests/extensions/gui.test.js +22 -10
  43. package/dist/tests/extensions/gui.test.js.map +1 -1
  44. package/doc/gui/api.md +38 -9
  45. package/doc/gui/canvas.md +49 -18
  46. package/doc/gui/dom.md +51 -4
  47. package/doc/gui/webgl.md +20 -10
  48. package/doc/gui-scripts.md +19 -19
  49. package/doc/gui.md +10 -8
  50. package/doc/implemented/fetch.md +5 -0
  51. package/doc/implemented/modules.md +13 -0
  52. package/doc/implemented/stdlib.md +17 -0
  53. package/doc/unimplemented/deviations.md +1 -0
  54. package/doc/zh-CN/gui/api.md +33 -4
  55. package/doc/zh-CN/gui/canvas.md +44 -19
  56. package/doc/zh-CN/gui/dom.md +45 -3
  57. package/doc/zh-CN/gui/webgl.md +3 -3
  58. package/doc/zh-CN/gui-scripts.md +14 -13
  59. package/doc/zh-CN/gui.md +7 -6
  60. package/doc/zh-CN/implemented/fetch.md +4 -0
  61. package/doc/zh-CN/implemented/modules.md +10 -0
  62. package/doc/zh-CN/implemented/stdlib.md +15 -0
  63. package/doc/zh-CN/unimplemented/deviations.md +1 -0
  64. package/package.json +7 -7
  65. package/runtime/ext_gui/browser.cpp +34 -49
  66. package/runtime/ext_gui/browser_abort.cpp +249 -0
  67. package/runtime/ext_gui/browser_dialogs.cpp +76 -0
  68. package/runtime/ext_gui/browser_media.cpp +176 -0
  69. package/runtime/ext_gui/browser_navigation.cpp +130 -0
  70. package/runtime/ext_gui/canvas.cpp +88 -30
  71. package/runtime/ext_gui/canvas.h +74 -9
  72. package/runtime/ext_gui/canvas_image_data.cpp +143 -0
  73. package/runtime/ext_gui/canvas_internal.h +8 -5
  74. package/runtime/ext_gui/canvas_pattern.cpp +90 -0
  75. package/runtime/ext_gui/canvas_raster.cpp +31 -9
  76. package/runtime/ext_gui/canvas_style.cpp +4 -2
  77. package/runtime/ext_gui/dom.h +4 -0
  78. package/runtime/ext_gui/dom_api.cpp +1 -0
  79. package/runtime/ext_gui/dom_api_canvas.cpp +120 -114
  80. package/runtime/ext_gui/dom_api_canvas_extra.cpp +57 -2
  81. package/runtime/ext_gui/dom_api_canvas_image.cpp +239 -0
  82. package/runtime/ext_gui/dom_api_canvas_paths.cpp +179 -0
  83. package/runtime/ext_gui/dom_api_computed_style.cpp +124 -0
  84. package/runtime/ext_gui/dom_api_dataset.cpp +154 -0
  85. package/runtime/ext_gui/dom_api_document.cpp +58 -5
  86. package/runtime/ext_gui/dom_api_events.cpp +93 -17
  87. package/runtime/ext_gui/dom_api_internal.h +55 -2
  88. package/runtime/ext_gui/dom_api_mutation.cpp +159 -0
  89. package/runtime/ext_gui/dom_api_node.cpp +40 -19
  90. package/runtime/ext_gui/dom_api_node_read.cpp +37 -1
  91. package/runtime/ext_gui/dom_api_path2d.cpp +358 -0
  92. package/runtime/ext_gui/dom_api_proto.cpp +35 -0
  93. package/runtime/ext_gui/dom_api_style.cpp +223 -13
  94. package/runtime/ext_gui/dom_api_webgl.cpp +10 -0
  95. package/runtime/ext_gui/dom_api_webgl2.cpp +33 -1
  96. package/runtime/ext_gui/gui.cpp +59 -5
  97. package/runtime/ext_gui/gui_engine.h +49 -0
  98. package/runtime/ext_gui/gui_events.cpp +80 -9
  99. package/runtime/ext_gui/listener_options.h +43 -0
  100. package/runtime/ext_gui/paint.cpp +28 -0
  101. package/runtime/ext_gui/paint.h +4 -0
  102. package/runtime/ext_gui/script.cpp +31 -0
  103. package/runtime/ext_gui/webgl_glsl.h +3 -0
  104. package/runtime/ext_gui/webgl_glsl_unroll.cpp +283 -0
  105. package/runtime/ext_gui/webgl_msl.cpp +4 -0
  106. package/runtime/ext_gui/webgl_shader.cpp +12 -6
  107. package/runtime/ext_gui/window.cpp +14 -65
  108. package/runtime/ext_gui/window_events.cpp +125 -0
  109. package/runtime/rt.h +29 -0
  110. package/runtime/rt_internal.h +4 -0
  111. package/runtime/xt_builtins.c +0 -21
  112. package/runtime/xt_containers/access.inc +94 -2
  113. package/runtime/xt_containers/objects.inc +29 -31
  114. package/runtime/xt_fetch/async.inc +60 -0
  115. package/runtime/xt_url_object.c +463 -0
  116. package/src/codegen/generator/state.ts +1 -0
  117. package/src/codegen/generator/tables.ts +1 -0
  118. package/src/driver/bundler/deferred.ts +351 -0
  119. package/src/driver/bundler/merge.ts +219 -2
  120. package/src/driver/runtime-objects.ts +1 -0
  121. package/src/driver/version.ts +1 -1
  122. package/src/extensions/gui/html.ts +91 -15
  123. package/src/extensions/gui/index.ts +13 -0
  124. package/src/extensions/gui/three.ts +4 -3
@@ -41,10 +41,34 @@ std::string string_arg(int32_t argc, xt_value *argv, int32_t index) {
41
41
  return to_string_value(xt_arg(argc, argv, index));
42
42
  }
43
43
 
44
+ /* Defined with the path bindings below; the transform methods accept a matrix
45
+ * argument too. */
46
+ /** `transform(a, b, c, d, e, f)` or `transform(matrix)` where `matrix` is a
47
+ * `DOMMatrix`, `{ a, b, c, d, e, f }` or a six-element array. */
48
+ bool canvas_matrix_arg(int32_t argc, xt_value *argv, int32_t index, float values[6]) {
49
+ if (index >= argc) return false;
50
+ xt_value value = xt_arg(argc, argv, index);
51
+ if (XT_IS_ARRAY(value)) {
52
+ if (xt_to_number(xt_array_length(value)) < 6) return false;
53
+ for (int i = 0; i < 6; i++) values[i] = (float)xt_to_number(xt_array_get(value, xt_number(i)));
54
+ return true;
55
+ }
56
+ if (!XT_IS_OBJECT(value)) return false;
57
+ static const char *const names[6] = {"a", "b", "c", "d", "e", "f"};
58
+ for (int i = 0; i < 6; i++) {
59
+ xt_value member = xt_object_get_cstr(value, names[i]);
60
+ if (!XT_IS_NUMBER(member)) return false;
61
+ values[i] = (float)xt_to_number(member);
62
+ }
63
+ return true;
64
+ }
65
+
44
66
  } // namespace
45
67
 
46
68
  xtgui::Canvas2D *canvas_from_context(xt_value self) { return context_canvas(self); }
47
69
 
70
+ xt_value canvas_context_attributes(xt_value requested, bool alpha);
71
+
48
72
  double canvas_number_arg(int32_t argc, xt_value *argv, int32_t index, double fallback) {
49
73
  return number_arg(argc, argv, index, fallback);
50
74
  }
@@ -75,18 +99,70 @@ METHOD(node_get_context) {
75
99
  if (node == nullptr) return xt_canvas_pending_context(self, win);
76
100
  if (!node->isElement() || !node->isTag("canvas")) return XT_NULL;
77
101
  if (xt_gui_webgl_find(win, node) != nullptr) return XT_NULL; // already a WebGL canvas
78
- xtgui::Canvas2D *canvas = xt_gui_canvas_get(win, node);
79
- if (canvas == nullptr) return XT_NULL;
80
102
  xt_value cached = xt_object_get_cstr(self, "__xt_gui_ctx");
81
103
  if (XT_IS_OBJECT(cached)) return cached;
104
+ xtgui::Canvas2D *canvas = xt_gui_canvas_get(win, node);
105
+ if (canvas == nullptr) return XT_NULL;
106
+ /* The second argument only takes effect when the context is created; a later
107
+ * `getContext("2d", ...)` returns the existing context unchanged. `alpha` is
108
+ * the one attribute with an observable effect on the bitmap. */
109
+ xt_value attributes = xt_arg(argc, argv, 1);
110
+ bool alpha = true;
111
+ if (XT_IS_OBJECT(attributes)) {
112
+ xt_value value = xt_object_get_cstr(attributes, "alpha");
113
+ if (XT_IS_BOOL(value)) alpha = value_truthy(value);
114
+ }
115
+ canvas->set_alpha(alpha);
82
116
  xt_value ctx = xt_object_new_with_proto(canvas_proto());
83
117
  xt_object_set(ctx, xt_string_from_cstr("__xt_gui_canvas"), xt_number((double)canvas->id()));
84
118
  /* Keep the element handle alive (and reachable) from the context. */
85
119
  xt_object_set(ctx, xt_string_from_cstr("__xt_gui_node"), self);
120
+ xt_object_set(ctx, xt_string_from_cstr("__xt_gui_ctx_attributes"),
121
+ canvas_context_attributes(attributes, alpha));
86
122
  xt_object_set(self, xt_string_from_cstr("__xt_gui_ctx"), ctx);
87
123
  return ctx;
88
124
  }
89
125
 
126
+ /** The attributes object `getContextAttributes()` reports. Options the engine
127
+ * does not implement keep their specification default, so a feature test sees
128
+ * an honest answer instead of `undefined`. */
129
+ xt_value canvas_context_attributes(xt_value requested, bool alpha) {
130
+ xt_value result = xt_object_new();
131
+ struct Attribute {
132
+ const char *name;
133
+ bool fallback;
134
+ };
135
+ const Attribute defaults[] = {
136
+ {"alpha", alpha}, {"antialias", true},
137
+ {"depth", true}, {"stencil", false},
138
+ {"premultipliedAlpha", true}, {"preserveDrawingBuffer", false},
139
+ {"desynchronized", false}, {"willReadFrequently", false},
140
+ {"failIfMajorPerformanceCaveat", false},
141
+ };
142
+ for (const Attribute &attribute : defaults) {
143
+ xt_value value = XT_UNDEFINED;
144
+ if (XT_IS_OBJECT(requested)) value = xt_object_get_cstr(requested, attribute.name);
145
+ if (XT_IS_BOOL(value)) {
146
+ xt_object_set(result, xt_string_from_cstr(attribute.name), value);
147
+ } else {
148
+ xt_object_set(result, xt_string_from_cstr(attribute.name),
149
+ attribute.fallback ? XT_TRUE : XT_FALSE);
150
+ }
151
+ }
152
+ xt_object_set(result, xt_string_from_cstr("powerPreference"),
153
+ xt_string_from_cstr("default"));
154
+ xt_object_set(result, xt_string_from_cstr("colorSpace"), xt_string_from_cstr("srgb"));
155
+ return result;
156
+ }
157
+
158
+ METHOD(canvas_get_context_attributes) {
159
+ (void)env;
160
+ (void)argc;
161
+ (void)argv;
162
+ xt_value stored = xt_object_get_cstr(self, "__xt_gui_ctx_attributes");
163
+ return XT_IS_OBJECT(stored) ? stored : canvas_context_attributes(XT_UNDEFINED, true);
164
+ }
165
+
90
166
  METHOD(canvas_get_canvas) {
91
167
  (void)env;
92
168
  (void)argc;
@@ -103,6 +179,9 @@ METHOD(canvas_fill_style_get) {
103
179
  if (canvas->fill_gradient_id() != 0) {
104
180
  return canvas_gradient_handle(self, canvas, canvas->fill_gradient_id());
105
181
  }
182
+ if (canvas->fill_pattern_id() != 0) {
183
+ return canvas_pattern_handle(self, canvas, canvas->fill_pattern_id());
184
+ }
106
185
  return xt_string_from_cstr(canvas->fill_style().c_str());
107
186
  }
108
187
 
@@ -116,6 +195,11 @@ METHOD(canvas_fill_style_set) {
116
195
  canvas->set_fill_gradient(gradient);
117
196
  return XT_UNDEFINED;
118
197
  }
198
+ uint64_t pattern = canvas_pattern_id(xt_arg(argc, argv, 0), canvas);
199
+ if (pattern != 0) {
200
+ canvas->set_fill_pattern(pattern);
201
+ return XT_UNDEFINED;
202
+ }
119
203
  }
120
204
  canvas->set_fill_style(string_arg(argc, argv, 0));
121
205
  return XT_UNDEFINED;
@@ -130,6 +214,9 @@ METHOD(canvas_stroke_style_get) {
130
214
  if (canvas->stroke_gradient_id() != 0) {
131
215
  return canvas_gradient_handle(self, canvas, canvas->stroke_gradient_id());
132
216
  }
217
+ if (canvas->stroke_pattern_id() != 0) {
218
+ return canvas_pattern_handle(self, canvas, canvas->stroke_pattern_id());
219
+ }
133
220
  return xt_string_from_cstr(canvas->stroke_style().c_str());
134
221
  }
135
222
 
@@ -143,6 +230,11 @@ METHOD(canvas_stroke_style_set) {
143
230
  canvas->set_stroke_gradient(gradient);
144
231
  return XT_UNDEFINED;
145
232
  }
233
+ uint64_t pattern = canvas_pattern_id(xt_arg(argc, argv, 0), canvas);
234
+ if (pattern != 0) {
235
+ canvas->set_stroke_pattern(pattern);
236
+ return XT_UNDEFINED;
237
+ }
146
238
  }
147
239
  canvas->set_stroke_style(string_arg(argc, argv, 0));
148
240
  return XT_UNDEFINED;
@@ -269,23 +361,33 @@ METHOD(canvas_scale) {
269
361
  METHOD(canvas_transform) {
270
362
  (void)env;
271
363
  xtgui::Canvas2D *canvas = context_canvas(self);
272
- if (canvas != nullptr)
273
- canvas->transform((float)number_arg(argc, argv, 0, 1.0), (float)number_arg(argc, argv, 1, 0.0),
274
- (float)number_arg(argc, argv, 2, 0.0), (float)number_arg(argc, argv, 3, 1.0),
275
- (float)number_arg(argc, argv, 4, 0.0), (float)number_arg(argc, argv, 5, 0.0));
364
+ if (canvas == nullptr) return XT_UNDEFINED;
365
+ float values[6];
366
+ if (canvas_matrix_arg(argc, argv, 0, values)) {
367
+ canvas->transform(values[0], values[1], values[2], values[3], values[4], values[5]);
368
+ return XT_UNDEFINED;
369
+ }
370
+ canvas->transform((float)number_arg(argc, argv, 0, 1.0), (float)number_arg(argc, argv, 1, 0.0),
371
+ (float)number_arg(argc, argv, 2, 0.0), (float)number_arg(argc, argv, 3, 1.0),
372
+ (float)number_arg(argc, argv, 4, 0.0), (float)number_arg(argc, argv, 5, 0.0));
276
373
  return XT_UNDEFINED;
277
374
  }
278
375
 
279
376
  METHOD(canvas_set_transform) {
280
377
  (void)env;
281
378
  xtgui::Canvas2D *canvas = context_canvas(self);
282
- if (canvas != nullptr)
283
- canvas->set_transform((float)number_arg(argc, argv, 0, 1.0),
284
- (float)number_arg(argc, argv, 1, 0.0),
285
- (float)number_arg(argc, argv, 2, 0.0),
286
- (float)number_arg(argc, argv, 3, 1.0),
287
- (float)number_arg(argc, argv, 4, 0.0),
288
- (float)number_arg(argc, argv, 5, 0.0));
379
+ if (canvas == nullptr) return XT_UNDEFINED;
380
+ float values[6];
381
+ if (canvas_matrix_arg(argc, argv, 0, values)) {
382
+ canvas->set_transform(values[0], values[1], values[2], values[3], values[4], values[5]);
383
+ return XT_UNDEFINED;
384
+ }
385
+ canvas->set_transform((float)number_arg(argc, argv, 0, 1.0),
386
+ (float)number_arg(argc, argv, 1, 0.0),
387
+ (float)number_arg(argc, argv, 2, 0.0),
388
+ (float)number_arg(argc, argv, 3, 1.0),
389
+ (float)number_arg(argc, argv, 4, 0.0),
390
+ (float)number_arg(argc, argv, 5, 0.0));
289
391
  return XT_UNDEFINED;
290
392
  }
291
393
 
@@ -298,104 +400,6 @@ METHOD(canvas_reset_transform) {
298
400
  return XT_UNDEFINED;
299
401
  }
300
402
 
301
- /* -- paths ---------------------------------------------------------------- */
302
-
303
- METHOD(canvas_begin_path) {
304
- (void)env;
305
- (void)argc;
306
- (void)argv;
307
- xtgui::Canvas2D *canvas = context_canvas(self);
308
- if (canvas != nullptr) canvas->begin_path();
309
- return XT_UNDEFINED;
310
- }
311
-
312
- METHOD(canvas_close_path) {
313
- (void)env;
314
- (void)argc;
315
- (void)argv;
316
- xtgui::Canvas2D *canvas = context_canvas(self);
317
- if (canvas != nullptr) canvas->close_path();
318
- return XT_UNDEFINED;
319
- }
320
-
321
- METHOD(canvas_move_to) {
322
- (void)env;
323
- xtgui::Canvas2D *canvas = context_canvas(self);
324
- if (canvas != nullptr)
325
- canvas->move_to((float)number_arg(argc, argv, 0, 0.0), (float)number_arg(argc, argv, 1, 0.0));
326
- return XT_UNDEFINED;
327
- }
328
-
329
- METHOD(canvas_line_to) {
330
- (void)env;
331
- xtgui::Canvas2D *canvas = context_canvas(self);
332
- if (canvas != nullptr)
333
- canvas->line_to((float)number_arg(argc, argv, 0, 0.0), (float)number_arg(argc, argv, 1, 0.0));
334
- return XT_UNDEFINED;
335
- }
336
-
337
- METHOD(canvas_rect) {
338
- (void)env;
339
- xtgui::Canvas2D *canvas = context_canvas(self);
340
- if (canvas != nullptr)
341
- canvas->rect((float)number_arg(argc, argv, 0, 0.0), (float)number_arg(argc, argv, 1, 0.0),
342
- (float)number_arg(argc, argv, 2, 0.0), (float)number_arg(argc, argv, 3, 0.0));
343
- return XT_UNDEFINED;
344
- }
345
-
346
- METHOD(canvas_arc) {
347
- (void)env;
348
- xtgui::Canvas2D *canvas = context_canvas(self);
349
- if (canvas != nullptr) {
350
- canvas->arc((float)number_arg(argc, argv, 0, 0.0), (float)number_arg(argc, argv, 1, 0.0),
351
- (float)number_arg(argc, argv, 2, 0.0), (float)number_arg(argc, argv, 3, 0.0),
352
- (float)number_arg(argc, argv, 4, 0.0), value_truthy(xt_arg(argc, argv, 5)));
353
- }
354
- return XT_UNDEFINED;
355
- }
356
-
357
- METHOD(canvas_quadratic_curve_to) {
358
- (void)env;
359
- xtgui::Canvas2D *canvas = context_canvas(self);
360
- if (canvas != nullptr)
361
- canvas->quadratic_curve_to((float)number_arg(argc, argv, 0, 0.0),
362
- (float)number_arg(argc, argv, 1, 0.0),
363
- (float)number_arg(argc, argv, 2, 0.0),
364
- (float)number_arg(argc, argv, 3, 0.0));
365
- return XT_UNDEFINED;
366
- }
367
-
368
- METHOD(canvas_bezier_curve_to) {
369
- (void)env;
370
- xtgui::Canvas2D *canvas = context_canvas(self);
371
- if (canvas != nullptr)
372
- canvas->bezier_curve_to((float)number_arg(argc, argv, 0, 0.0),
373
- (float)number_arg(argc, argv, 1, 0.0),
374
- (float)number_arg(argc, argv, 2, 0.0),
375
- (float)number_arg(argc, argv, 3, 0.0),
376
- (float)number_arg(argc, argv, 4, 0.0),
377
- (float)number_arg(argc, argv, 5, 0.0));
378
- return XT_UNDEFINED;
379
- }
380
-
381
- METHOD(canvas_fill) {
382
- (void)env;
383
- (void)argc;
384
- (void)argv;
385
- xtgui::Canvas2D *canvas = context_canvas(self);
386
- if (canvas != nullptr) canvas->fill();
387
- return XT_UNDEFINED;
388
- }
389
-
390
- METHOD(canvas_stroke) {
391
- (void)env;
392
- (void)argc;
393
- (void)argv;
394
- xtgui::Canvas2D *canvas = context_canvas(self);
395
- if (canvas != nullptr) canvas->stroke();
396
- return XT_UNDEFINED;
397
- }
398
-
399
403
  METHOD(canvas_clear_rect) {
400
404
  (void)env;
401
405
  xtgui::Canvas2D *canvas = context_canvas(self);
@@ -440,7 +444,8 @@ METHOD(canvas_fill_text) {
440
444
  xtgui::Canvas2D *canvas = context_canvas(self);
441
445
  if (canvas != nullptr)
442
446
  canvas->fill_text(string_arg(argc, argv, 0), (float)number_arg(argc, argv, 1, 0.0),
443
- (float)number_arg(argc, argv, 2, 0.0));
447
+ (float)number_arg(argc, argv, 2, 0.0),
448
+ (float)number_arg(argc, argv, 3, 0.0));
444
449
  return XT_UNDEFINED;
445
450
  }
446
451
 
@@ -449,7 +454,8 @@ METHOD(canvas_stroke_text) {
449
454
  xtgui::Canvas2D *canvas = context_canvas(self);
450
455
  if (canvas != nullptr)
451
456
  canvas->stroke_text(string_arg(argc, argv, 0), (float)number_arg(argc, argv, 1, 0.0),
452
- (float)number_arg(argc, argv, 2, 0.0));
457
+ (float)number_arg(argc, argv, 2, 0.0),
458
+ (float)number_arg(argc, argv, 3, 0.0));
453
459
  return XT_UNDEFINED;
454
460
  }
455
461
 
@@ -516,4 +522,4 @@ METHOD(canvas_get_image_data) {
516
522
 
517
523
  } // namespace domapi
518
524
 
519
- #undef METHOD
525
+ #undef METHOD
@@ -100,15 +100,70 @@ METHOD(canvas_ellipse) {
100
100
  return XT_UNDEFINED;
101
101
  }
102
102
 
103
+ namespace {
104
+
105
+ /** One corner radius: a number, or a `{ x, y }` pair (the engine draws circular
106
+ * corners, so such a pair contributes its `x` radius). */
107
+ bool canvas_radius_value(xt_value value, float *out) {
108
+ if (XT_IS_NUMBER(value)) {
109
+ *out = (float)xt_to_number(value);
110
+ return true;
111
+ }
112
+ if (XT_IS_OBJECT(value)) {
113
+ xt_value x = xt_object_get_cstr(value, "x");
114
+ xt_value y = xt_object_get_cstr(value, "y");
115
+ if (XT_IS_NUMBER(x)) {
116
+ *out = (float)xt_to_number(x);
117
+ return true;
118
+ }
119
+ if (XT_IS_NUMBER(y)) {
120
+ *out = (float)xt_to_number(y);
121
+ return true;
122
+ }
123
+ }
124
+ return false;
125
+ }
126
+
127
+ /** `roundRect`'s fifth argument: one radius or a list of 1–4 radii in CSS order
128
+ * (top-left, top-right, bottom-right, bottom-left). */
129
+ bool canvas_radii_arg(xt_value value, float radii[4]) {
130
+ radii[0] = radii[1] = radii[2] = radii[3] = 0.0f;
131
+ if (canvas_radius_value(value, &radii[0])) {
132
+ radii[1] = radii[2] = radii[3] = radii[0];
133
+ return true;
134
+ }
135
+ if (!XT_IS_ARRAY(value)) return false;
136
+ int32_t count = (int32_t)xt_to_number(xt_array_length(value));
137
+ if (count <= 0) return false;
138
+ if (count > 4) count = 4;
139
+ for (int32_t i = 0; i < count; i++) {
140
+ if (!canvas_radius_value(xt_array_get(value, xt_number((double)i)), &radii[i])) return false;
141
+ }
142
+ /* CSS expansion: [a] [a,b] [a,b,c] to four corners. */
143
+ if (count == 1) {
144
+ radii[1] = radii[2] = radii[3] = radii[0];
145
+ } else if (count == 2) {
146
+ radii[2] = radii[0];
147
+ radii[3] = radii[1];
148
+ } else if (count == 3) {
149
+ radii[3] = radii[1];
150
+ }
151
+ return true;
152
+ }
153
+
154
+ } // namespace
155
+
103
156
  METHOD(canvas_round_rect) {
104
157
  (void)env;
105
158
  xtgui::Canvas2D *canvas = canvas_from_context(self);
106
159
  if (canvas != nullptr) {
160
+ float radii[4];
161
+ canvas_radii_arg(xt_arg(argc, argv, 4), radii);
107
162
  canvas->round_rect((float)canvas_number_arg(argc, argv, 0, 0.0),
108
163
  (float)canvas_number_arg(argc, argv, 1, 0.0),
109
164
  (float)canvas_number_arg(argc, argv, 2, 0.0),
110
- (float)canvas_number_arg(argc, argv, 3, 0.0),
111
- (float)canvas_number_arg(argc, argv, 4, 0.0));
165
+ (float)canvas_number_arg(argc, argv, 3, 0.0), radii[0], radii[1],
166
+ radii[2], radii[3]);
112
167
  }
113
168
  return XT_UNDEFINED;
114
169
  }
@@ -0,0 +1,239 @@
1
+ /*
2
+ * xbintsc GUI engine — the Canvas2D image APIs (`putImageData`,
3
+ * `createImageData`, `createPattern`, `toDataURL`, `toBlob`).
4
+ *
5
+ * `ImageData` is the same `{ width, height, data }` shape `getImageData` already
6
+ * returns (a byte array), patterns are canvas-owned handles like gradients, and
7
+ * `toDataURL`/`toBlob` export the bitmap as a PNG data URL / callback result.
8
+ */
9
+
10
+ #include "dom_api_internal.h"
11
+
12
+ #include <cmath>
13
+ #include <string>
14
+ #include <vector>
15
+
16
+ #include "canvas.h"
17
+ #include "image.h"
18
+
19
+ namespace domapi {
20
+
21
+ namespace {
22
+
23
+ #define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
24
+
25
+ /** Read an `ImageData`-shaped value into width/height/RGBA bytes. */
26
+ bool image_data_arg(xt_value value, int *width, int *height, std::vector<unsigned char> *bytes) {
27
+ if (!XT_IS_OBJECT(value)) return false;
28
+ xt_value w = xt_object_get_cstr(value, "width");
29
+ xt_value h = xt_object_get_cstr(value, "height");
30
+ if (!XT_IS_NUMBER(w) || !XT_IS_NUMBER(h)) return false;
31
+ *width = (int)xt_to_number(w);
32
+ *height = (int)xt_to_number(h);
33
+ if (*width <= 0 || *height <= 0) return false;
34
+ xt_value data = xt_object_get_cstr(value, "data");
35
+ if (!XT_IS_ARRAY(data)) return false;
36
+ int32_t count = (int32_t)xt_to_number(xt_array_length(data));
37
+ if (count < *width * *height * 4) return false;
38
+ bytes->resize((size_t)count);
39
+ for (int32_t i = 0; i < count; i++) {
40
+ (*bytes)[(size_t)i] = (unsigned char)xt_to_number(xt_array_get(data, xt_number((double)i)));
41
+ }
42
+ return true;
43
+ }
44
+
45
+ xt_value make_image_data(int width, int height, const std::vector<unsigned char> &bytes) {
46
+ xt_value result = xt_object_new();
47
+ xt_value data = xt_array_new(0, nullptr);
48
+ for (unsigned char byte : bytes) xt_array_push(data, xt_number((double)byte));
49
+ xt_object_set(result, xt_string_from_cstr("width"), xt_number((double)width));
50
+ xt_object_set(result, xt_string_from_cstr("height"), xt_number((double)height));
51
+ xt_object_set(result, xt_string_from_cstr("data"), data);
52
+ return result;
53
+ }
54
+
55
+ /** Decode a `createPattern` source: an `<img>` or another `<canvas>`. */
56
+ bool source_image(XtGuiWindow *win, xt_value value, xtgui::Image *out) {
57
+ xtgui::Node *node = resolve_node(value, &win);
58
+ if (node == nullptr || !node->isElement()) return false;
59
+ if (node->isTag("img")) {
60
+ const std::string *src = node->attr("src");
61
+ if (src == nullptr) return false;
62
+ const xtgui::Image *image = xtgui::xt_image_load(*src);
63
+ if (image == nullptr || image->width <= 0 || image->height <= 0) return false;
64
+ *out = *image;
65
+ return true;
66
+ }
67
+ xtgui::Canvas2D *canvas = xt_gui_canvas_find(win, node);
68
+ if (canvas == nullptr) return false;
69
+ *out = canvas->image();
70
+ return out->width > 0 && out->height > 0;
71
+ }
72
+
73
+ const char kBase64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
74
+
75
+ std::string base64_encode(const std::vector<unsigned char> &bytes) {
76
+ std::string out;
77
+ out.reserve((bytes.size() + 2) / 3 * 4);
78
+ size_t i = 0;
79
+ while (i + 2 < bytes.size()) {
80
+ uint32_t triple = ((uint32_t)bytes[i] << 16) | ((uint32_t)bytes[i + 1] << 8) | bytes[i + 2];
81
+ out.push_back(kBase64[(triple >> 18) & 0x3F]);
82
+ out.push_back(kBase64[(triple >> 12) & 0x3F]);
83
+ out.push_back(kBase64[(triple >> 6) & 0x3F]);
84
+ out.push_back(kBase64[triple & 0x3F]);
85
+ i += 3;
86
+ }
87
+ if (i < bytes.size()) {
88
+ uint32_t triple = (uint32_t)bytes[i] << 16;
89
+ bool two = i + 1 < bytes.size();
90
+ if (two) triple |= (uint32_t)bytes[i + 1] << 8;
91
+ out.push_back(kBase64[(triple >> 18) & 0x3F]);
92
+ out.push_back(kBase64[(triple >> 12) & 0x3F]);
93
+ out.push_back(two ? kBase64[(triple >> 6) & 0x3F] : '=');
94
+ out.push_back('=');
95
+ }
96
+ return out;
97
+ }
98
+
99
+ xt_value blob_callback(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
100
+ (void)self;
101
+ (void)argc;
102
+ (void)argv;
103
+ xt_value fn = xt_closure_env(env, 0);
104
+ xt_value blob = xt_closure_env(env, 1);
105
+ xt_value args[1] = {blob};
106
+ return xt_call_with_this(fn, XT_UNDEFINED, 1, args);
107
+ }
108
+
109
+ } // namespace
110
+
111
+ /** The canvas behind a context handle or a `<canvas>` element handle. */
112
+ xtgui::Canvas2D *canvas_or_element(xt_value self) {
113
+ xtgui::Canvas2D *canvas = canvas_from_context(self);
114
+ if (canvas != nullptr) return canvas;
115
+ XtGuiWindow *win = nullptr;
116
+ xtgui::Node *node = resolve_node(self, &win);
117
+ if (node == nullptr || win == nullptr) return nullptr;
118
+ return xt_gui_canvas_find(win, node);
119
+ }
120
+
121
+ xt_value canvas_pattern_handle(xt_value context, const xtgui::Canvas2D *canvas, uint64_t id) {
122
+ const std::string key = "__xt_gui_pattern_" + std::to_string(id);
123
+ xt_value cached = xt_object_get_cstr(context, key.c_str());
124
+ if (XT_IS_OBJECT(cached)) return cached;
125
+ xt_value handle = xt_object_new_with_proto(xt_object_prototype());
126
+ if (canvas != nullptr) {
127
+ xt_object_set(handle, xt_string_from_cstr("__xt_gui_canvas"), xt_number((double)canvas->id()));
128
+ }
129
+ xt_object_set(handle, xt_string_from_cstr("__xt_gui_pattern"), xt_number((double)id));
130
+ xt_object_set(context, xt_string_from_cstr(key.c_str()), handle);
131
+ return handle;
132
+ }
133
+
134
+ uint64_t canvas_pattern_id(xt_value handle, const xtgui::Canvas2D *canvas) {
135
+ if (canvas == nullptr || !XT_IS_OBJECT(handle)) return 0;
136
+ xt_value canvasId = xt_object_get_cstr(handle, "__xt_gui_canvas");
137
+ xt_value patternId = xt_object_get_cstr(handle, "__xt_gui_pattern");
138
+ if (!XT_IS_NUMBER(canvasId) || !XT_IS_NUMBER(patternId)) return 0;
139
+ if ((uint64_t)xt_to_number(canvasId) != canvas->id()) return 0;
140
+ uint64_t id = (uint64_t)xt_to_number(patternId);
141
+ return canvas->find_pattern(id) == nullptr ? 0 : id;
142
+ }
143
+
144
+ METHOD(canvas_put_image_data) {
145
+ (void)env;
146
+ xtgui::Canvas2D *canvas = canvas_from_context(self);
147
+ if (canvas == nullptr || argc < 3) return XT_UNDEFINED;
148
+ int width = 0;
149
+ int height = 0;
150
+ std::vector<unsigned char> bytes;
151
+ if (!image_data_arg(xt_arg(argc, argv, 0), &width, &height, &bytes)) return XT_UNDEFINED;
152
+ int dx = (int)canvas_number_arg(argc, argv, 1, 0.0);
153
+ int dy = (int)canvas_number_arg(argc, argv, 2, 0.0);
154
+ int dirty_x = (int)canvas_number_arg(argc, argv, 3, 0.0);
155
+ int dirty_y = (int)canvas_number_arg(argc, argv, 4, 0.0);
156
+ int dirty_width = (int)canvas_number_arg(argc, argv, 5, 0.0);
157
+ int dirty_height = (int)canvas_number_arg(argc, argv, 6, 0.0);
158
+ canvas->set_image_data(bytes, width, height, dx, dy, dirty_x, dirty_y, dirty_width,
159
+ dirty_height);
160
+ return XT_UNDEFINED;
161
+ }
162
+
163
+ METHOD(canvas_create_image_data) {
164
+ (void)env;
165
+ int width = 0;
166
+ int height = 0;
167
+ if (argc >= 2) {
168
+ width = (int)canvas_number_arg(argc, argv, 0, 0.0);
169
+ height = (int)canvas_number_arg(argc, argv, 1, 0.0);
170
+ } else if (argc >= 1) {
171
+ int source_width = 0;
172
+ int source_height = 0;
173
+ std::vector<unsigned char> bytes;
174
+ if (image_data_arg(xt_arg(argc, argv, 0), &source_width, &source_height, &bytes)) {
175
+ width = source_width;
176
+ height = source_height;
177
+ }
178
+ }
179
+ if (width <= 0 || height <= 0) return XT_UNDEFINED;
180
+ return make_image_data(width, height, std::vector<unsigned char>((size_t)width * height * 4, 0));
181
+ }
182
+
183
+ METHOD(canvas_create_pattern) {
184
+ (void)env;
185
+ xtgui::Canvas2D *canvas = canvas_from_context(self);
186
+ if (canvas == nullptr || argc < 1) return XT_NULL;
187
+ XtGuiWindow *win = nullptr;
188
+ resolve_node(xt_object_get_cstr(self, "__xt_gui_node"), &win);
189
+ xtgui::Image source;
190
+ if (win == nullptr || !source_image(win, xt_arg(argc, argv, 0), &source)) return XT_NULL;
191
+ std::string repetition = argc >= 2 ? canvas_string_arg(argc, argv, 1) : "repeat";
192
+ xtgui::CanvasPattern::Repeat repeat = xtgui::CanvasPattern::Repeat::Both;
193
+ if (repetition == "repeat-x") repeat = xtgui::CanvasPattern::Repeat::X;
194
+ else if (repetition == "repeat-y") repeat = xtgui::CanvasPattern::Repeat::Y;
195
+ else if (repetition == "no-repeat") repeat = xtgui::CanvasPattern::Repeat::None;
196
+ xtgui::CanvasPattern *pattern = canvas->create_pattern(source, repeat);
197
+ return canvas_pattern_handle(self, canvas, pattern->id());
198
+ }
199
+
200
+ /** `toDataURL(type?)`: a PNG data URL (the engine has one encoder; a browser
201
+ * also falls back to PNG for an unsupported type). */
202
+ METHOD(canvas_to_data_url) {
203
+ (void)env;
204
+ (void)argc;
205
+ (void)argv;
206
+ xtgui::Canvas2D *canvas = canvas_or_element(self);
207
+ if (canvas == nullptr) return xt_string_from_cstr("data:,");
208
+ std::vector<unsigned char> png;
209
+ if (!canvas->encode_png(&png)) return xt_string_from_cstr("data:,");
210
+ std::string url = "data:image/png;base64," + base64_encode(png);
211
+ return xt_string_from_cstr(url.c_str());
212
+ }
213
+
214
+ /** `toBlob(callback, type?)`: build a Blob-shaped result and deliver it from a
215
+ * microtask, as the browser does. The bytes are on `__xt_gui_blob_data`; there
216
+ * is no `URL.createObjectURL` in this runtime. */
217
+ METHOD(canvas_to_blob) {
218
+ (void)env;
219
+ xtgui::Canvas2D *canvas = canvas_or_element(self);
220
+ xt_value callback = argc >= 1 ? xt_arg(argc, argv, 0) : XT_UNDEFINED;
221
+ if (canvas == nullptr || !XT_IS_FUNCTION(callback)) return XT_UNDEFINED;
222
+ std::vector<unsigned char> png;
223
+ if (!canvas->encode_png(&png)) return XT_UNDEFINED;
224
+ xt_value data = xt_array_new(0, nullptr);
225
+ for (unsigned char byte : png) xt_array_push(data, xt_number((double)byte));
226
+ xt_value blob = xt_object_new();
227
+ xt_object_set(blob, xt_string_from_cstr("type"), xt_string_from_cstr("image/png"));
228
+ xt_object_set(blob, xt_string_from_cstr("size"), xt_number((double)png.size()));
229
+ xt_object_set(blob, xt_string_from_cstr("__xt_gui_blob_data"), data);
230
+ xt_value captured[2] = {callback, blob};
231
+ xt_value task = xt_closure_new((void *)blob_callback, 2, captured);
232
+ xt_value args[1] = {task};
233
+ xt_queue_microtask(1, args);
234
+ return XT_UNDEFINED;
235
+ }
236
+
237
+ #undef METHOD
238
+
239
+ } // namespace domapi