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.
- package/dist/src/cli/help.d.ts +1 -1
- package/dist/src/codegen/generator/state.js +1 -0
- package/dist/src/codegen/generator/state.js.map +1 -1
- package/dist/src/codegen/generator/tables.js +1 -0
- package/dist/src/codegen/generator/tables.js.map +1 -1
- package/dist/src/driver/bundler/deferred.d.ts +63 -0
- package/dist/src/driver/bundler/deferred.js +279 -0
- package/dist/src/driver/bundler/deferred.js.map +1 -0
- package/dist/src/driver/bundler/merge.js +214 -2
- package/dist/src/driver/bundler/merge.js.map +1 -1
- package/dist/src/driver/runtime-objects.d.ts +1 -1
- package/dist/src/driver/runtime-objects.js +1 -0
- package/dist/src/driver/runtime-objects.js.map +1 -1
- package/dist/src/driver/version.d.ts +1 -1
- package/dist/src/driver/version.js +1 -1
- package/dist/src/extensions/gui/html.js +89 -13
- package/dist/src/extensions/gui/html.js.map +1 -1
- package/dist/src/extensions/gui/index.js +13 -0
- package/dist/src/extensions/gui/index.js.map +1 -1
- package/dist/src/extensions/gui/three.d.ts +4 -3
- package/dist/src/extensions/gui/three.js +4 -3
- package/dist/src/extensions/gui/three.js.map +1 -1
- package/dist/tests/e2e/gui-browser.test.js +65 -0
- package/dist/tests/e2e/gui-browser.test.js.map +1 -1
- package/dist/tests/e2e/gui-canvas-args.test.d.ts +6 -0
- package/dist/tests/e2e/gui-canvas-args.test.js +217 -0
- package/dist/tests/e2e/gui-canvas-args.test.js.map +1 -0
- package/dist/tests/e2e/gui-canvas.test.js.map +1 -1
- package/dist/tests/e2e/gui-dom.test.js +215 -0
- package/dist/tests/e2e/gui-dom.test.js.map +1 -1
- package/dist/tests/e2e/gui-events.test.js +112 -0
- package/dist/tests/e2e/gui-events.test.js.map +1 -1
- package/dist/tests/e2e/gui-script-import-order.test.d.ts +10 -0
- package/dist/tests/e2e/gui-script-import-order.test.js +161 -0
- package/dist/tests/e2e/gui-script-import-order.test.js.map +1 -0
- package/dist/tests/e2e/gui-webgl2-shadow.test.d.ts +10 -0
- package/dist/tests/e2e/gui-webgl2-shadow.test.js +108 -0
- package/dist/tests/e2e/gui-webgl2-shadow.test.js.map +1 -0
- package/dist/tests/e2e/url.test.d.ts +6 -0
- package/dist/tests/e2e/url.test.js +114 -0
- package/dist/tests/e2e/url.test.js.map +1 -0
- package/dist/tests/extensions/gui.test.js +22 -10
- package/dist/tests/extensions/gui.test.js.map +1 -1
- package/doc/gui/api.md +38 -9
- package/doc/gui/canvas.md +49 -18
- package/doc/gui/dom.md +51 -4
- package/doc/gui/webgl.md +20 -10
- package/doc/gui-scripts.md +19 -19
- package/doc/gui.md +10 -8
- package/doc/implemented/fetch.md +5 -0
- package/doc/implemented/modules.md +13 -0
- package/doc/implemented/stdlib.md +17 -0
- package/doc/unimplemented/deviations.md +1 -0
- package/doc/zh-CN/gui/api.md +33 -4
- package/doc/zh-CN/gui/canvas.md +44 -19
- package/doc/zh-CN/gui/dom.md +45 -3
- package/doc/zh-CN/gui/webgl.md +3 -3
- package/doc/zh-CN/gui-scripts.md +14 -13
- package/doc/zh-CN/gui.md +7 -6
- package/doc/zh-CN/implemented/fetch.md +4 -0
- package/doc/zh-CN/implemented/modules.md +10 -0
- package/doc/zh-CN/implemented/stdlib.md +15 -0
- package/doc/zh-CN/unimplemented/deviations.md +1 -0
- package/package.json +7 -7
- package/runtime/ext_gui/browser.cpp +34 -49
- package/runtime/ext_gui/browser_abort.cpp +249 -0
- package/runtime/ext_gui/browser_dialogs.cpp +76 -0
- package/runtime/ext_gui/browser_media.cpp +176 -0
- package/runtime/ext_gui/browser_navigation.cpp +130 -0
- package/runtime/ext_gui/canvas.cpp +88 -30
- package/runtime/ext_gui/canvas.h +74 -9
- package/runtime/ext_gui/canvas_image_data.cpp +143 -0
- package/runtime/ext_gui/canvas_internal.h +8 -5
- package/runtime/ext_gui/canvas_pattern.cpp +90 -0
- package/runtime/ext_gui/canvas_raster.cpp +31 -9
- package/runtime/ext_gui/canvas_style.cpp +4 -2
- package/runtime/ext_gui/dom.h +4 -0
- package/runtime/ext_gui/dom_api.cpp +1 -0
- package/runtime/ext_gui/dom_api_canvas.cpp +120 -114
- package/runtime/ext_gui/dom_api_canvas_extra.cpp +57 -2
- package/runtime/ext_gui/dom_api_canvas_image.cpp +239 -0
- package/runtime/ext_gui/dom_api_canvas_paths.cpp +179 -0
- package/runtime/ext_gui/dom_api_computed_style.cpp +124 -0
- package/runtime/ext_gui/dom_api_dataset.cpp +154 -0
- package/runtime/ext_gui/dom_api_document.cpp +58 -5
- package/runtime/ext_gui/dom_api_events.cpp +93 -17
- package/runtime/ext_gui/dom_api_internal.h +55 -2
- package/runtime/ext_gui/dom_api_mutation.cpp +159 -0
- package/runtime/ext_gui/dom_api_node.cpp +40 -19
- package/runtime/ext_gui/dom_api_node_read.cpp +37 -1
- package/runtime/ext_gui/dom_api_path2d.cpp +358 -0
- package/runtime/ext_gui/dom_api_proto.cpp +35 -0
- package/runtime/ext_gui/dom_api_style.cpp +223 -13
- package/runtime/ext_gui/dom_api_webgl.cpp +10 -0
- package/runtime/ext_gui/dom_api_webgl2.cpp +33 -1
- package/runtime/ext_gui/gui.cpp +59 -5
- package/runtime/ext_gui/gui_engine.h +49 -0
- package/runtime/ext_gui/gui_events.cpp +80 -9
- package/runtime/ext_gui/listener_options.h +43 -0
- package/runtime/ext_gui/paint.cpp +28 -0
- package/runtime/ext_gui/paint.h +4 -0
- package/runtime/ext_gui/script.cpp +31 -0
- package/runtime/ext_gui/webgl_glsl.h +3 -0
- package/runtime/ext_gui/webgl_glsl_unroll.cpp +283 -0
- package/runtime/ext_gui/webgl_msl.cpp +4 -0
- package/runtime/ext_gui/webgl_shader.cpp +12 -6
- package/runtime/ext_gui/window.cpp +14 -65
- package/runtime/ext_gui/window_events.cpp +125 -0
- package/runtime/rt.h +29 -0
- package/runtime/rt_internal.h +4 -0
- package/runtime/xt_builtins.c +0 -21
- package/runtime/xt_containers/access.inc +94 -2
- package/runtime/xt_containers/objects.inc +29 -31
- package/runtime/xt_fetch/async.inc +60 -0
- package/runtime/xt_url_object.c +463 -0
- package/src/codegen/generator/state.ts +1 -0
- package/src/codegen/generator/tables.ts +1 -0
- package/src/driver/bundler/deferred.ts +351 -0
- package/src/driver/bundler/merge.ts +219 -2
- package/src/driver/runtime-objects.ts +1 -0
- package/src/driver/version.ts +1 -1
- package/src/extensions/gui/html.ts +91 -15
- package/src/extensions/gui/index.ts +13 -0
- 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
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
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
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
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
|
-
|
|
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
|