1#[cfg(not(all(feature = "lottie", feature = "video")))]
10mod absent;
11mod aria;
12mod bgimage;
13mod cache;
14mod clipboard;
15mod color;
16mod containers;
17mod css_namespace;
18mod cull;
19mod dom;
20mod effect_texture;
21mod filter;
22mod font_api;
23mod fonts;
24mod fullscreen;
25mod geometry_js;
26mod idmap;
27pub mod iframe;
28mod img;
29mod inherit;
30mod inline_style;
31mod live;
32mod live_state;
33pub mod log;
34#[cfg(feature = "lottie")]
35mod lottie;
36#[cfg(not(feature = "lottie"))]
37#[path = "absent/lottie.rs"]
38mod lottie;
39mod mask;
40mod native_dom;
41mod observe;
42pub mod perf;
43mod pointer;
44mod pointer_lock;
45mod range;
46mod render;
47mod resample;
48mod scheme;
49mod scroll;
50mod select;
51mod selection;
52mod snap;
53mod sticky;
54mod style_decl;
55pub mod surface;
56mod svg;
57mod toggle;
58mod tree;
59#[cfg(feature = "video")]
60mod video;
61#[cfg(not(feature = "video"))]
62#[path = "absent/video.rs"]
63mod video;
64#[cfg(windows)]
65mod video_device;
66mod view_transition;
67mod view_transition_js;
68mod waapi;
69pub mod windows;
70
71pub mod devtools;
72
73pub use containers::settle_frame as settle_container_queries;
74pub use img::{
75 asset_base, asset_store, content_key, dev_asset_file, read_app_asset, set_asset_base,
76 set_asset_store, set_dev_asset_files, AssetLookup,
77};
78pub use inherit::dynamic_range_limit;
79pub use observe::update_layout_observers;
80pub use pointer_lock::{
81 intercept_escape as pointer_lock_intercept_escape, navigated as pointer_lock_navigated,
82};
83pub use render::{
84 bounds_in, build_root, build_subtree, control_hitboxes, control_hitboxes_in,
85 enable_pick_hitboxes, flush_pending_mouse_move, painted_bounds_in, painted_drag_region,
86 painted_drag_region_in, popped_out, root_bounds, root_bounds_in, set_os_chrome,
87 set_os_chrome_in, set_popped_out, set_repaint_all, window_control_at,
88};
89pub use tree::{
90 effects_changed, with_tree, EVENT_NAMES, EV_AUXCLICK, EV_BEFOREINPUT, EV_BLUR, EV_CANPLAY,
91 EV_CANPLAYTHROUGH, EV_CLICK, EV_COMPLETE, EV_COMPOSITIONEND, EV_COMPOSITIONSTART,
92 EV_COMPOSITIONUPDATE, EV_CONTEXTMENU, EV_COPY, EV_CUT, EV_DURATIONCHANGE, EV_EMPTIED, EV_ENDED,
93 EV_ENTERFRAME, EV_ERROR, EV_FOCUS, EV_INPUT, EV_KEYDOWN, EV_KEYUP, EV_LOAD, EV_LOADEDDATA,
94 EV_LOADEDMETADATA, EV_LOADSTART, EV_LOOPCOMPLETE, EV_MESSAGE, EV_MOUSEDOWN, EV_MOUSEENTER,
95 EV_MOUSELEAVE, EV_MOUSEMOVE, EV_MOUSEUP, EV_PASTE, EV_PAUSE, EV_PLAY, EV_PLAYING,
96 EV_POINTERCANCEL, EV_POINTERLOCKCHANGE, EV_POINTERLOCKERROR, EV_RATECHANGE, EV_SCROLL,
97 EV_SEEKED, EV_SEEKING, EV_TIMEUPDATE, EV_VOLUMECHANGE, EV_WAITING, EV_WHEEL,
98};
99pub use view_transition::build_overlay as build_view_transition;
100pub use windows::WinKey;
101
102#[derive(Default)]
106pub struct EventPayload<'a> {
107 pub a: f64,
108 pub b: f64,
109 pub c: f64,
110 pub d: f64,
111 pub key: Option<&'a str>,
112}
113
114use std::ffi::c_void;
115
116use sk_runtime::redjs::api::Value;
117use sk_runtime::redjs::webapi::util::read_string;
118use sk_runtime::{host_fn, JsRuntime};
119
120const UNDEF: u64 = 0xa;
121
122fn ret_id(id: u32) -> u64 {
123 Value::int32(id as i32).0
124}
125
126fn arg_id(v: Value) -> u32 {
127 v.as_number().unwrap_or(0.0) as u32
128}
129
130host_fn!(fn sk_intern(g, args) {
131 let name = unsafe { read_string(g, args.arg(0).0) }.unwrap_or_default();
132 ret_id(tree::with_tree(|t| t.intern(&name)))
133});
134
135host_fn!(fn sk_create_element(g, args) {
136 let tag = arg_id(args.arg(0));
137 perf::note_dom(perf::DomOp::Create);
138 #[cfg(not(all(feature = "lottie", feature = "video")))]
139 absent::advise(g, tag);
140 if let Some(reason) = iframe::unavailable() {
141 if tree::with_tree(|t| t.name(tag) == "iframe") {
142 let msg = format!("<iframe> shows nothing: {reason}");
143 unsafe { sk_runtime::host::warn_compat(g, "absent:iframe", &msg) };
145 }
146 }
147 ret_id(tree::with_tree(|t| t.create_element(tag)))
148});
149
150host_fn!(fn sk_create_text(_g, _args) {
151 perf::note_dom(perf::DomOp::Create);
152 ret_id(tree::with_tree(|t| t.create_text()))
153});
154
155host_fn!(fn sk_create_anchor(_g, _args) {
156 perf::note_dom(perf::DomOp::Create);
157 ret_id(tree::with_tree(|t| t.create_anchor()))
158});
159
160host_fn!(fn sk_set_text(g, args) {
161 let id = arg_id(args.arg(0));
162 let text = unsafe { read_string(g, args.arg(1).0) }.unwrap_or_default();
163 perf::note_dom(perf::DomOp::Text);
164 tree::with_tree(|t| t.set_text(id, text));
165 UNDEF
166});
167
168host_fn!(fn sk_set_element_text(g, args) {
169 let id = arg_id(args.arg(0));
170 let text = unsafe { read_string(g, args.arg(1).0) }.unwrap_or_default();
171 perf::note_dom(perf::DomOp::Text);
172 tree::with_tree(|t| t.set_element_text(id, text));
173 UNDEF
174});
175
176host_fn!(fn sk_insert(_g, args) {
177 let (child, parent, anchor) = (arg_id(args.arg(0)), arg_id(args.arg(1)), arg_id(args.arg(2)));
178 perf::note_dom(perf::DomOp::Insert);
179 tree::with_tree(|t| t.insert(child, parent, anchor));
180 iframe::note_structure();
181 UNDEF
182});
183
184host_fn!(fn sk_remove(_g, args) {
185 let id = arg_id(args.arg(0));
186 perf::note_dom(perf::DomOp::Remove);
187 tree::with_tree(|t| t.remove(id));
188 iframe::note_structure();
189 UNDEF
190});
191
192host_fn!(fn sk_set_style(g, args) {
193 let id = arg_id(args.arg(0));
194 let key = arg_id(args.arg(1));
195 let value = unsafe { read_string(g, args.arg(2).0) }.unwrap_or_default();
196 perf::note_dom(perf::DomOp::Style);
197 tree::with_tree(|t| t.set_style(id, key, value));
198 UNDEF
199});
200
201host_fn!(fn sk_style_accepts(g, args) {
204 let key = arg_id(args.arg(0));
205 let value = unsafe { read_string(g, args.arg(1).0) }.unwrap_or_default();
206 let name = tree::with_tree(|t| t.name(key).to_string());
207 Value::boolean(sk_css::accepts_declaration(&name, &value)).0
208});
209
210host_fn!(fn sk_set_class(g, args) {
211 let id = arg_id(args.arg(0));
212 let classes = unsafe { read_string(g, args.arg(1).0) }.unwrap_or_default();
213 perf::note_dom(perf::DomOp::Class);
214 tree::with_tree(|t| t.set_class(id, &classes));
215 UNDEF
216});
217
218host_fn!(fn sk_set_prop(g, args) {
219 let id = arg_id(args.arg(0));
220 let key = arg_id(args.arg(1));
221 let value = if args.arg(2).is_undefined() || args.arg(2).is_null() {
222 None
223 } else {
224 unsafe { read_string(g, args.arg(2).0) }
225 };
226 perf::note_dom(perf::DomOp::Prop);
227 let (img_src, frame_attr) = tree::with_tree(|t| {
228 t.set_prop(id, key, value);
229 if t.name(key) == "checked" {
230 toggle::attribute_changed(t, id);
231 }
232 let tag = t.node(id).map(|n| t.name(n.tag));
233 let name = t.name(key);
234 (name == "src" && tag == Some("img"), tag == Some("iframe") && iframe::is_frame_attr(name))
235 });
236 if frame_attr {
237 iframe::note(id);
238 }
239 if img_src {
240 perf::note_img_src();
241 img::note_src(id);
242 }
243 UNDEF
244});
245
246host_fn!(fn sk_add_scope(g, args) {
247 let id = arg_id(args.arg(0));
248 let scope = unsafe { read_string(g, args.arg(1).0) }.unwrap_or_default();
249 perf::note_dom(perf::DomOp::Other);
250 tree::with_tree(|t| t.add_scope(id, scope));
251 UNDEF
252});
253
254host_fn!(fn sk_copy_scopes(_g, args) {
255 let (from, to) = (arg_id(args.arg(0)), arg_id(args.arg(1)));
256 tree::with_tree(|t| t.copy_scopes(from, to));
257 UNDEF
258});
259
260host_fn!(fn sk_set_stylesheet(g, args) {
261 let css = unsafe { read_string(g, args.arg(0).0) }.unwrap_or_default();
262 let extra = args.arg(1).0;
263 let head: Vec<String> = if sk_runtime::redjs::webapi::util::is_cell(extra) {
264 unsafe {
265 use sk_runtime::redjs::webapi::util::{array_len, get_i};
266 (0..array_len(g, extra)).filter_map(|i| read_string(g, get_i(g, extra, i))).collect()
267 }
268 } else {
269 Vec::new()
270 };
271 if tree::set_stylesheet_with_head(css, head) {
272 perf::note_full(perf::FullReason::Stylesheet);
273 tree::with_tree(|t| t.mark_dirty());
274 }
275 UNDEF
276});
277
278host_fn!(fn sk_set_listener(g, args) {
279 let id = arg_id(args.arg(0));
280 let event = arg_id(args.arg(1));
281 let on = args.arg(2).as_bool().unwrap_or(false);
282 let _ = g;
283 perf::note_dom(perf::DomOp::Other);
284 tree::with_tree(|t| t.set_listener(id, event, on));
285 UNDEF
286});
287
288host_fn!(fn sk_create_root(_g, _args) {
289 ret_id(tree::with_tree(|t| t.create_root()))
290});
291
292host_fn!(fn sk_set_dispatcher(g, args) {
293 let f = args.arg(0);
294 unsafe { sk_runtime::redjs::ffi::redjs_protect(g, f.0) };
295 tree::set_dispatcher(f.0);
296 UNDEF
297});
298
299fn ret_string(s: &str) -> u64 {
300 JsRuntime::with(|rt| rt.ctx().string(s).0)
301}
302
303host_fn!(fn sk_query(g, args) {
305 let selector = unsafe { read_string(g, args.arg(0).0) }.unwrap_or_default();
306 let root = arg_id(args.arg(1));
307 perf::note_read(perf::Read::Query);
308 let mode = match arg_id(args.arg(2)) {
309 1 => dom::QueryMode::SelfOnly,
310 2 => dom::QueryMode::Closest,
311 3 => dom::QueryMode::Document,
312 _ => dom::QueryMode::Descendants,
313 };
314 let out = match dom::query(&selector, root, mode) {
315 Ok(ids) => ids.iter().map(u32::to_string).collect::<Vec<_>>().join(","),
316 Err(e) => format!("!{e}"),
317 };
318 ret_string(&out)
319});
320
321sk_runtime::raw_host_fn! { fn sk_perf_frame(_g, _cf) {
324 Value::number(render::build_count() as f64).0
325} }
326
327host_fn!(fn sk_perf_visible(_g, args) {
328 let out = dom::visible_share(arg_id(args.arg(0)))
329 .map_or_else(String::new, |(total, seen)| format!("{total},{seen}"));
330 ret_string(&out)
331});
332
333host_fn!(fn sk_bounds(_g, args) {
334 let id = arg_id(args.arg(0));
335 perf::note_read(perf::Read::Layout);
336 let out = match dom::bounds(id) {
337 (Some((x, y, w, h)), _) => match dom::transformed(id) {
338 Some((tx, ty, tw, th)) => format!("{x},{y},{w},{h},{tx},{ty},{tw},{th}"),
339 None => format!("{x},{y},{w},{h}"),
340 },
341 (None, true) => "stale".to_string(),
342 (None, false) => String::new(),
343 };
344 ret_string(&out)
345});
346
347host_fn!(fn sk_focus(_g, args) {
352 let id = arg_id(args.arg(0));
353 let op = arg_id(args.arg(1));
354 if op == 0 && render::style_refuses_focus(id) {
355 return ret_string("refused");
356 }
357 if op == 0 && layout_owed() && render::focus_wants_build(id) {
358 sync_layout_by(perf::SyncCaller::Focus);
359 }
360 let out = sk_runtime::with_commit(|window, cx| {
361 if op == 1 {
362 return if render::js_blur(id, window, cx) { "blurred".to_string() } else { String::new() };
363 }
364 match render::js_focus(id, window, cx) {
365 render::FocusAnswer::Moved { old } => format!("moved:{old}"),
366 render::FocusAnswer::Already => "already".to_string(),
367 render::FocusAnswer::Pending => "pending".to_string(),
368 render::FocusAnswer::Refused => "refused".to_string(),
369 }
370 })
371 .unwrap_or_else(|| {
372 if op == 1 {
373 return String::new();
374 }
375 render::queue_focus(id);
376 "pending".to_string()
377 });
378 ret_string(&out)
379});
380
381host_fn!(fn sk_input_select(_g, args) {
382 Value::boolean(render::select_input_text(arg_id(args.arg(0)))).0
383});
384
385host_fn!(fn sk_media_state(_g, args) {
387 let id = arg_id(args.arg(0));
388 ret_string(&video::media_state(id).unwrap_or_default())
389});
390
391host_fn!(fn sk_media_prop(_g, args) {
394 let id = arg_id(args.arg(0));
395 let code = arg_id(args.arg(1));
396 video::media_prop(id, code).map_or(UNDEF, |v| Value::number(v).0)
397});
398
399host_fn!(fn sk_media_call(_g, args) {
400 let id = arg_id(args.arg(0));
401 let verb = arg_id(args.arg(1));
402 let arg = args.arg(2).as_number().unwrap_or(0.0);
403 Value::boolean(video::media_call(id, verb, arg)).0
404});
405
406host_fn!(fn sk_media_can_play(g, args) {
409 let id = arg_id(args.arg(0));
410 let mime = unsafe { read_string(g, args.arg(1).0) }.unwrap_or_default();
411 ret_string(&video::can_play_type(id, &mime))
412});
413
414host_fn!(fn sk_media_events(_g, args) {
415 let id = arg_id(args.arg(0));
416 ret_string(&video::drain_recent(id))
417});
418
419host_fn!(fn sk_iframe_post(g, args) {
420 let id = arg_id(args.arg(0));
421 let wire = unsafe { read_string(g, args.arg(1).0) }.unwrap_or_default();
422 let target = unsafe { read_string(g, args.arg(2).0) }.unwrap_or_default();
423 iframe::post(id, &wire, &target);
424 UNDEF
425});
426
427host_fn!(fn sk_iframe_supported(_g, _args) {
428 Value::boolean(iframe::supported()).0
429});
430
431host_fn!(fn sk_img_bitmap(g, args) {
432 let id = arg_id(args.arg(0));
433 let clean = args.arg(1).as_bool().unwrap_or(true);
434 let found = sk_runtime::with_app(|cx| img::pixels(id, Some(cx))).unwrap_or_else(|| img::pixels(id, None));
435 match found {
436 img::Pixels::Ready { width, height, rgba } => {
437 let mut data = sk_runtime::redjs::webapi::image::BitmapData::new(width, height, rgba);
438 data.origin_clean = clean;
439 unsafe { sk_runtime::redjs::webapi::image::create_bitmap(g, data) }
440 }
441 img::Pixels::NotYet => Value::null().0,
442 img::Pixels::Broken(why) => ret_string(&why),
443 }
444});
445
446host_fn!(fn sk_fullscreen_element(_g, args) {
447 Value::boolean(fullscreen::set(arg_id(args.arg(0)))).0
448});
449
450pub fn install(rt: &JsRuntime) {
451 let fns: &[(&str, u32, *const c_void)] = &[
452 ("__sk_intern", 1, sk_intern as *const _),
453 ("__sk_create_element", 1, sk_create_element as *const _),
454 ("__sk_create_text", 0, sk_create_text as *const _),
455 ("__sk_create_anchor", 0, sk_create_anchor as *const _),
456 ("__sk_set_text", 2, sk_set_text as *const _),
457 ("__sk_set_element_text", 2, sk_set_element_text as *const _),
458 ("__sk_insert", 3, sk_insert as *const _),
459 ("__sk_remove", 1, sk_remove as *const _),
460 ("__sk_set_style", 3, sk_set_style as *const _),
461 ("__sk_style_accepts", 2, sk_style_accepts as *const _),
462 ("__sk_set_class", 2, sk_set_class as *const _),
463 ("__sk_set_prop", 3, sk_set_prop as *const _),
464 ("__sk_add_scope", 2, sk_add_scope as *const _),
465 ("__sk_copy_scopes", 2, sk_copy_scopes as *const _),
466 ("__sk_set_stylesheet", 1, sk_set_stylesheet as *const _),
467 ("__sk_set_listener", 3, sk_set_listener as *const _),
468 ("__sk_create_root", 0, sk_create_root as *const _),
469 (
470 "__sk_fullscreen_element",
471 1,
472 sk_fullscreen_element as *const _,
473 ),
474 ("__sk_set_dispatcher", 1, sk_set_dispatcher as *const _),
475 ("__sk_query", 3, sk_query as *const _),
476 ("__sk_bounds", 1, sk_bounds as *const _),
477 ("__sk_perf_frame", 0, sk_perf_frame as *const _),
478 ("__sk_perf_visible", 1, sk_perf_visible as *const _),
479 ("__sk_focus", 2, sk_focus as *const _),
480 ("__sk_input_select", 1, sk_input_select as *const _),
481 ("__sk_media_state", 1, sk_media_state as *const _),
482 ("__sk_media_prop", 2, sk_media_prop as *const _),
483 ("__sk_media_call", 3, sk_media_call as *const _),
484 ("__sk_media_can_play", 2, sk_media_can_play as *const _),
485 ("__sk_media_events", 1, sk_media_events as *const _),
486 ("__sk_img_bitmap", 2, sk_img_bitmap as *const _),
487 ("__sk_iframe_post", 3, sk_iframe_post as *const _),
488 ("__sk_iframe_supported", 0, sk_iframe_supported as *const _),
489 ];
490 for (name, arity, f) in fns {
491 rt.register(name, *arity, *f);
492 }
493 waapi::install(rt);
494 style_decl::install(rt);
495 css_namespace::install(rt);
496 selection::install(rt);
497 pointer::install(rt);
498 native_dom::install(rt);
499 geometry_js::install(rt);
500 toggle::install(rt);
501 pointer_lock::install(rt);
502 observe::install(rt);
503 font_api::install(rt);
504 effect_texture::install();
505 view_transition_js::install(rt);
506}
507
508thread_local! {
512 static SYNC_LAYOUT: std::cell::Cell<Option<fn()>> = const { std::cell::Cell::new(None) };
513 static IN_SYNC_LAYOUT: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
514 static INPUT_DISPATCH: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };
515 static OFF_INPUT: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
517 static FLUSHED_AT_BUILD: std::cell::Cell<Option<u64>> = const { std::cell::Cell::new(None) };
519 static FLUSHED_BY_SYNC: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
520}
521
522pub fn in_input_dispatch() -> bool {
525 INPUT_DISPATCH.with(|c| c.get()) > 0
526}
527
528pub(crate) struct InputDispatch(bool);
529
530impl InputDispatch {
531 pub(crate) fn enter() -> Self {
532 if OFF_INPUT.with(|c| c.get()) {
533 return Self(false);
534 }
535 Self::inside_gpui()
536 }
537
538 pub(crate) fn inside_gpui() -> Self {
540 INPUT_DISPATCH.with(|c| c.set(c.get() + 1));
541 Self(true)
542 }
543}
544
545impl Drop for InputDispatch {
546 fn drop(&mut self) {
547 if self.0 {
548 INPUT_DISPATCH.with(|c| c.set(c.get().saturating_sub(1)));
549 }
550 }
551}
552
553pub(crate) fn off_input<R>(f: impl FnOnce() -> R) -> R {
556 struct Restore(bool);
557 impl Drop for Restore {
558 fn drop(&mut self) {
559 OFF_INPUT.with(|c| c.set(self.0));
560 }
561 }
562 let _r = Restore(OFF_INPUT.with(|c| c.replace(true)));
563 f()
564}
565
566pub(crate) fn layout_owed() -> bool {
567 tree::read_tree(|t| t.is_dirty())
568 || FLUSHED_AT_BUILD.with(|c| c.get()) == Some(render::build_count())
569}
570
571pub fn set_sync_layout(f: fn()) {
573 SYNC_LAYOUT.with(|c| c.set(Some(f)));
574}
575
576pub fn sync_layout() {
579 if IN_SYNC_LAYOUT.with(|c| c.get()) {
580 return;
581 }
582 sync_layout_inner();
583}
584
585pub(crate) fn sync_layout_by(caller: perf::SyncCaller) {
587 if IN_SYNC_LAYOUT.with(|c| c.get()) {
588 return;
589 }
590 let _profile = sk_runtime::redjs::profiling::span(
591 "layout",
592 match caller {
593 perf::SyncCaller::Bounds => "Forced layout: bounds read",
594 perf::SyncCaller::Scroll => "Forced layout: scroll read",
595 perf::SyncCaller::Focus => "Forced layout: focus",
596 },
597 );
598 if !perf::enabled() {
599 sync_layout_inner();
600 return;
601 }
602 let before = render::build_count();
603 let span = perf::Span::start();
604 sync_layout_inner();
605 perf::note_sync_layout(caller, render::build_count() != before, span.ms());
606}
607
608fn sync_layout_inner() {
609 let Some(f) = SYNC_LAYOUT.with(|c| c.get()) else {
610 return;
611 };
612 IN_SYNC_LAYOUT.with(|c| c.set(true));
613 if flush_changes() {
614 FLUSHED_BY_SYNC.with(|c| c.set(true));
615 }
616 let laid_out = render::layout_count();
617 f();
618 if render::layout_count() != laid_out {
619 containers::settle(f);
620 }
621 IN_SYNC_LAYOUT.with(|c| c.set(false));
622}
623
624#[derive(Clone, Copy, Debug, PartialEq, Eq)]
625pub enum Flush {
626 Unchanged,
627 Changed,
628 DrawnBySync,
630}
631
632pub fn flush_changes() -> bool {
633 flush_changes_kind() != Flush::Unchanged
634}
635
636static TREE_REVISION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
638
639pub fn tree_revision() -> u64 {
642 TREE_REVISION.load(std::sync::atomic::Ordering::Relaxed)
643}
644
645pub fn flush_changes_kind() -> Flush {
646 let dirty = tree::with_tree(|t| t.take_dirty());
647 if dirty {
648 TREE_REVISION.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
649 tree::restyle_all();
650 render::gc_node_state();
651 containers::gc(&|id| tree::read_tree(|t| t.node(id).is_some()));
652 render::canvas::gc(|id| tree::read_tree(|t| t.node(id).is_some()));
653 tree::animator_gc();
654 tree::with_tree(|t| t.release_freed());
655 FLUSHED_AT_BUILD.with(|c| c.set(Some(render::build_count())));
656 }
657 let forced = !IN_SYNC_LAYOUT.with(|c| c.get()) && FLUSHED_BY_SYNC.with(|c| c.replace(false));
658 if dirty {
659 Flush::Changed
660 } else if !forced {
661 Flush::Unchanged
662 } else if layout_owed() {
663 Flush::Changed
664 } else {
665 Flush::DrawnBySync
666 }
667}
668
669pub fn animating() -> bool {
670 tree::animating()
671}
672
673pub fn lotties_animating() -> bool {
674 lottie::any_playing()
675}
676
677pub fn videos_playing() -> bool {
678 video::any_playing()
679}
680
681pub fn media_polls() -> bool {
684 video::any_playing()
685 || lottie::any_playing()
686 || img::loads_pending()
687 || render::sticker::polls()
688}
689
690#[cfg(windows)]
695pub unsafe fn set_video_device(ptr: *mut c_void, generation: u64) {
696 unsafe { video_device::set_device(ptr, generation) }
697}
698
699#[cfg(windows)]
701pub use video_device::{SharedDeviceProvider, SharedVideoDevice};
702
703#[cfg(windows)]
706pub unsafe fn install_video_device_provider(
707 provider: SharedDeviceProvider,
708) -> Result<(), &'static str> {
709 unsafe { video_device::install_provider(provider) }
710}
711
712pub fn surface_device_changed() {
715 surface::device_changed();
716}
717
718pub fn video_device_changed() -> usize {
721 video::device_changed()
722}
723
724pub fn frame_tick(window: &mut gpui::Window, cx: &mut gpui::App) -> bool {
727 off_input(|| frame_tick_inner(window, cx))
729}
730
731fn frame_tick_inner(window: &mut gpui::Window, cx: &mut gpui::App) -> bool {
732 img::evict_pending(window, cx);
733 render::apply_pending_blur(window, cx);
734 render::apply_pending_focus(window, cx);
735 render::ensure_root_focus(window, cx);
736 let settled = tree::advance_animations();
737 let anim = render::dispatch_anim_events(window, cx) | settled;
739 let scripted = tree::take_script_dirty();
740 img::tick(window, cx);
741 iframe::tick(window, cx);
742 let lottie_moved = lottie::tick(window, cx);
743 let video_moved = video::tick(window, cx);
744 let stickers_moved = render::sticker::tick(window, cx);
745 let canvas_moved = render::canvas::tick(window);
746 surface::node::sample_display(window);
747 let surfaces_moved = surface::node::tick(window, cx);
748 let snapped = snap::tick();
749 let gliding = scroll::tick() | snapped;
750 let scrolled = scroll::dispatch_pending(window, cx) | gliding;
751 let fonts_moved = fonts::tick(window, cx);
752 let resampled = resample::tick(window, cx);
753 let restored = img::residency_tick(window, cx);
754 let selecting = selection::tick(window, cx);
755 let transition = view_transition::tick(window) | view_transition_js::deliver(window, cx);
756 let draw = anim
757 | transition
758 | scripted
759 | lottie_moved
760 | video_moved
761 | stickers_moved
762 | canvas_moved
763 | surfaces_moved
764 | scrolled
765 | fonts_moved
766 | resampled
767 | restored
768 | selecting;
769 match live::take() {
770 live::Shown::Draw => true,
771 live::Shown::Present if !draw => {
772 live::present(window);
773 false
774 }
775 _ => draw,
776 }
777}
778
779pub fn window_frame_tick(window: &mut gpui::Window, cx: &mut gpui::App) {
782 pointer::arm_hover_tick(window);
783 img::evict_pending(window, cx);
784 lottie::window_tick(window, cx);
785 video::drain_pending_drops_for(window, cx);
786 video::drain_pending_uploads(window);
787 render::sticker::window_tick(window);
788 surface::node::sample_display(window);
789 surface::node::window_tick(window);
790 render::apply_pending_blur(window, cx);
791 render::apply_pending_focus(window, cx);
792 render::ensure_root_focus(window, cx);
793}
794
795pub fn forget_window(key: windows::WinKey) {
798 windows::forget(key);
799 render::sticker::forget_window(key);
800 lottie::forget_window(key);
801 surface::node::forget_window(key);
802 iframe::forget_window(key);
803 pointer_lock::window_closed(key);
804}
805
806pub fn set_page_hidden(hidden: bool) {
809 live::set_hidden(hidden);
810 surface::feedback::set_page_hidden(hidden);
811}
812
813pub fn surface_app_closed() {
815 surface::feedback::app_closed();
816}
817
818pub fn set_reduce_motion(on: bool) {
819 tree::set_reduce_motion(on);
820}
821
822pub fn set_env(env: sk_css::Env) -> bool {
825 let changed = tree::set_env(env);
826 if changed {
827 perf::note_full(perf::FullReason::Env);
828 tree::with_tree(|t| t.mark_dirty());
829 }
830 changed
831}
832
833pub fn set_env_for(key: windows::WinKey, env: sk_css::Env) -> bool {
834 tree::set_window_env(key, env)
835}
836
837pub fn env() -> sk_css::Env {
839 tree::env()
840}
841
842pub fn match_media(query: &str) -> Result<bool, String> {
844 sk_css::match_media(query, &tree::env())
845}
846
847#[cfg(test)]
848mod tests {
849 use super::*;
850
851 fn env(w: f32, h: f32, dark: bool, reduce_motion: bool) -> sk_css::Env {
852 sk_css::Env {
853 viewport_width: w,
854 viewport_height: h,
855 dark,
856 reduce_motion,
857 ..sk_css::Env::default()
858 }
859 }
860
861 fn opacity_of(id: u32) -> Option<f32> {
862 tree::read_tree(|t| {
863 t.node(id)
864 .and_then(|n| n.computed.as_ref())
865 .and_then(|c| c.base.opacity)
866 })
867 }
868
869 #[test]
870 fn env_changes_mark_the_whole_tree_dirty_exactly_once() {
871 tree::with_tree(|t| t.take_dirty());
872 assert!(set_env(env(800.0, 600.0, false, false)));
873 assert!(tree::with_tree(|t| t.take_dirty()));
874 assert!(!set_env(env(800.0, 600.0, false, false)));
875 assert!(!tree::with_tree(|t| t.take_dirty()));
876 assert!(set_env(env(800.0, 600.0, true, false)));
877 assert!(tree::with_tree(|t| t.take_dirty()));
878 assert!(set_env(env(801.0, 600.0, true, false)));
879 assert!(tree::with_tree(|t| t.take_dirty()));
880 }
881
882 #[test]
883 fn a_text_change_flushed_outside_the_frame_advances_the_tree_revision() {
884 let text = tree::with_tree(|t| {
885 let root = t.create_root();
886 let text = t.create_text();
887 t.set_text(text, "0".into());
888 t.insert(text, root, 0);
889 text
890 });
891 flush_changes();
892 let before = tree_revision();
893 tree::with_tree(|t| t.set_text(text, "1".into()));
894 assert!(flush_changes());
895 assert!(tree_revision() > before);
896 }
897
898 #[test]
899 fn element_properties_drive_the_cascade() {
900 let child = tree::with_tree(|t| {
901 let root = t.create_root();
902 let tag = t.intern("input");
903 let child = t.create_element(tag);
904 t.insert(child, root, 0);
905 t.set_class(child, "field");
906 child
907 });
908 tree::set_engine(sk_css::Engine::compile(
909 ".field { opacity: 1 } .field:disabled { opacity: 0.4 }",
910 ));
911 tree::restyle_all();
912 assert_eq!(opacity_of(child), Some(1.0));
913
914 tree::with_tree(|t| {
915 let key = t.intern("disabled");
916 t.set_prop(child, key, Some("true".into()));
917 });
918 assert!(flush_changes(), "a prop write must dirty the tree");
919 assert_eq!(opacity_of(child), Some(0.4));
920
921 tree::with_tree(|t| {
922 let key = t.intern("disabled");
923 t.set_prop(child, key, Some("false".into()));
924 });
925 flush_changes();
926 assert_eq!(opacity_of(child), Some(1.0));
927 }
928
929 #[test]
931 fn attribute_selectors_see_the_class_attribute() {
932 let (root, child) = tree::with_tree(|t| {
933 let root = t.create_root();
934 let div = t.intern("div");
935 let child = t.create_element(div);
936 t.insert(child, root, 0);
937 t.set_class(child, "row group/msg hover:x");
938 (root, child)
939 });
940 let q = |sel: &str| dom::query(sel, root, dom::QueryMode::Descendants).unwrap();
941 assert_eq!(q(r#"[class*="group/msg"]"#), vec![child]);
942 assert_eq!(q(r#"[class~="row"]"#), vec![child]);
943 assert_eq!(q(r#"[class^="row "]"#), vec![child]);
944 assert_eq!(q("[class]"), vec![child]);
945 assert_eq!(q(".row"), vec![child], "the token list is unchanged");
946 tree::with_tree(|t| t.set_class(child, ""));
947 assert!(q("[class]").is_empty());
948 }
949
950 fn mounted_child() -> u32 {
951 tree::with_tree(|t| {
952 let root = t.create_root();
953 let div = t.intern("div");
954 let child = t.create_element(div);
955 t.insert(child, root, 0);
956 child
957 })
958 }
959
960 #[test]
961 fn an_owed_layout_that_cannot_be_forced_reads_stale() {
962 let child = mounted_child();
963 assert_eq!(dom::bounds(child), (None, true));
964 assert!(flush_changes());
965 assert_eq!(dom::bounds(child), (None, true), "flushed is not laid out");
966 render::note_build();
967 assert_eq!(
968 dom::bounds(child),
969 (None, false),
970 "built and still unpainted: not painted"
971 );
972 }
973
974 #[test]
975 fn a_refused_forced_layout_keeps_the_waves_repaint() {
976 fn refuse() {}
977 set_sync_layout(refuse);
978 let child = mounted_child();
979 assert_eq!(dom::bounds(child), (None, true));
980 assert!(
981 !tree::read_tree(|t| t.is_dirty()),
982 "the forced layout flushed"
983 );
984 assert_eq!(
985 flush_changes_kind(),
986 Flush::Changed,
987 "…and the wave still draws, as nothing did"
988 );
989 assert!(!flush_changes(), "once");
990
991 fn draw() {
992 render::note_build();
993 }
994 set_sync_layout(draw);
995 let other = mounted_child();
996 assert_eq!(dom::bounds(other), (None, false));
997 assert_eq!(
998 flush_changes_kind(),
999 Flush::DrawnBySync,
1000 "a forced layout that drew still reports the change (pop-outs repaint), as already drawn",
1001 );
1002 assert_eq!(flush_changes_kind(), Flush::Unchanged, "once");
1003
1004 let third = mounted_child();
1005 assert_eq!(dom::bounds(third), (None, false));
1006 tree::with_tree(|t| t.set_class(third, "moved"));
1007 assert_eq!(flush_changes_kind(), Flush::Changed);
1008 }
1009
1010 #[test]
1012 fn off_input_never_masks_an_enclosing_input_dispatch() {
1013 assert!(!in_input_dispatch());
1014 off_input(|| {
1015 let _d = InputDispatch::enter();
1016 assert!(!in_input_dispatch());
1017 });
1018 {
1019 let _d = InputDispatch::enter();
1020 assert!(in_input_dispatch());
1021 off_input(|| {
1022 let _n = InputDispatch::enter();
1023 assert!(in_input_dispatch());
1024 });
1025 assert!(in_input_dispatch());
1026 }
1027 assert!(!in_input_dispatch());
1028 off_input(|| {
1029 let _f = InputDispatch::inside_gpui();
1030 assert!(in_input_dispatch());
1031 });
1032 assert!(!in_input_dispatch());
1033 }
1034
1035 #[test]
1038 fn getcomputedstyle_flushes_the_pending_cascade() {
1039 let child = tree::with_tree(|t| {
1040 let root = t.create_root();
1041 let div = t.intern("div");
1042 let child = t.create_element(div);
1043 t.insert(child, root, 0);
1044 let key = t.intern("data-state");
1045 t.set_prop(child, key, Some("open".into()));
1046 t.set_class(child, "box");
1047 child
1048 });
1049 tree::set_engine(sk_css::Engine::compile(
1050 ".box { animation: none } \
1051 .box[data-state=open] { animation: enter 150ms linear } \
1052 .box[data-state=closed] { animation: exit 150ms linear } \
1053 @keyframes enter { from { opacity: 0 } } @keyframes exit { to { opacity: 0 } }",
1054 ));
1055 tree::restyle_all();
1056 let name_now = || {
1057 dom::computed_style(child)
1058 .unwrap_or_default()
1059 .lines()
1060 .find_map(|l| l.strip_prefix("animation-name=").map(str::to_string))
1061 .unwrap_or_default()
1062 };
1063 assert_eq!(name_now(), "enter");
1064
1065 tree::with_tree(|t| {
1066 let key = t.intern("data-state");
1067 t.set_prop(child, key, Some("closed".into()));
1068 });
1069 assert_eq!(name_now(), "exit", "the read must see its own mutation");
1070
1071 assert!(
1072 flush_changes(),
1073 "a forced flush still owes the frame a repaint"
1074 );
1075 }
1076
1077 #[test]
1078 fn an_infinite_animation_dies_with_its_node_when_the_wave_reuses_nothing() {
1079 tree::set_engine(sk_css::Engine::compile(
1080 ".spin { animation: spin 1s linear infinite } @keyframes spin { to { opacity: 0.5 } }",
1081 ));
1082 let spinner = tree::with_tree(|t| {
1083 let root = t.create_root();
1084 let div = t.intern("div");
1085 let spinner = t.create_element(div);
1086 t.set_class(spinner, "spin");
1087 t.insert(spinner, root, 0);
1088 spinner
1089 });
1090 assert!(flush_changes());
1091 assert!(animating(), "the spinner runs");
1092
1093 let anchor = tree::with_tree(|t| {
1094 t.remove(spinner);
1095 t.create_anchor()
1096 });
1097 assert_ne!(anchor, spinner, "a freed id is not reused before the sweep");
1098 flush_changes();
1099 assert!(!animating(), "nothing is left running");
1100 let reused = tree::with_tree(|t| t.create_anchor());
1101 assert_eq!(reused, spinner, "after the sweep it is");
1102 }
1103
1104 #[test]
1105 fn display_none_stops_the_animations_under_it_and_showing_restarts_them() {
1106 tree::set_engine(sk_css::Engine::compile(
1107 ".spin { animation: spin 1s linear infinite } .gone { display: none } \
1108 @keyframes spin { to { opacity: 0.5 } }",
1109 ));
1110 let (panel, spinner) = tree::with_tree(|t| {
1111 let root = t.create_root();
1112 let div = t.intern("div");
1113 let panel = t.create_element(div);
1114 let spinner = t.create_element(div);
1115 t.set_class(spinner, "spin");
1116 t.insert(panel, root, 0);
1117 t.insert(spinner, panel, 0);
1118 (panel, spinner)
1119 });
1120 flush_changes();
1121 tree::advance_animations();
1122 tree::take_anim_events();
1123 assert!(animating(), "the spinner runs");
1124
1125 tree::with_tree(|t| t.set_class(panel, "gone"));
1126 flush_changes();
1127 assert!(!animating(), "nothing runs under display: none");
1128 let cancelled: Vec<_> = tree::take_anim_events()
1129 .into_iter()
1130 .filter(|e| e.node == spinner && e.kind == sk_css::AnimEventKind::AnimationCancel)
1131 .collect();
1132 assert_eq!(cancelled.len(), 1, "one animationcancel for the spinner");
1133
1134 let late = tree::with_tree(|t| {
1135 let div = t.intern("div");
1136 let late = t.create_element(div);
1137 t.set_class(late, "spin");
1138 t.insert(late, panel, 1);
1139 late
1140 });
1141 flush_changes();
1142 assert!(
1143 !animating(),
1144 "a node mounted under display: none does not start ({late})"
1145 );
1146
1147 tree::with_tree(|t| t.set_class(panel, ""));
1148 flush_changes();
1149 assert!(animating(), "showing the panel restarts what is under it");
1150 let mut hot = std::collections::HashSet::new();
1151 tree::moving_paths(std::time::Instant::now(), &mut hot);
1152 assert!(hot.contains(&spinner) && hot.contains(&late));
1153
1154 tree::with_tree(|t| t.set_class(spinner, "spin gone"));
1155 flush_changes();
1156 hot.clear();
1157 tree::moving_paths(std::time::Instant::now(), &mut hot);
1158 assert!(!hot.contains(&spinner) && hot.contains(&late));
1159 }
1160
1161 #[test]
1162 fn only_a_moving_nodes_ancestors_are_hot() {
1163 tree::set_engine(sk_css::Engine::compile(
1164 ".spin { animation: spin 1s linear infinite } .held { animation-play-state: paused } \
1165 @keyframes spin { to { opacity: 0.5 } }",
1166 ));
1167 let (list, row, spinner, other, held) = tree::with_tree(|t| {
1168 let root = t.create_root();
1169 let div = t.intern("div");
1170 let list = t.create_element(div);
1171 let row = t.create_element(div);
1172 let spinner = t.create_element(div);
1173 let other = t.create_element(div);
1174 let held = t.create_element(div);
1175 t.set_class(spinner, "spin");
1176 t.set_class(held, "spin held");
1177 t.insert(list, root, 0);
1178 t.insert(row, list, 0);
1179 t.insert(spinner, row, 0);
1180 t.insert(other, list, 1);
1181 t.insert(held, other, 0);
1182 (list, row, spinner, other, held)
1183 });
1184 flush_changes();
1185 let mut hot = std::collections::HashSet::new();
1186 tree::moving_paths(std::time::Instant::now(), &mut hot);
1187 let root = tree::read_tree(|t| t.root);
1188 for id in [spinner, row, list, root] {
1189 assert!(hot.contains(&id), "{id} is on the spinner's path");
1190 }
1191 assert!(!hot.contains(&other), "a sibling subtree stays replayable");
1192 assert!(!hot.contains(&held), "a paused animation is not moving");
1193
1194 tree::with_tree(|t| t.set_class(spinner, ""));
1195 flush_changes();
1196 hot.clear();
1197 tree::moving_paths(std::time::Instant::now(), &mut hot);
1198 assert!(hot.is_empty(), "nothing moves: {hot:?}");
1199 }
1200
1201 #[test]
1203 fn custom_properties_inherit_through_the_real_tree() {
1204 let (mid, leaf) = tree::with_tree(|t| {
1205 let root = t.create_root();
1206 let div = t.intern("div");
1207 let mid = t.create_element(div);
1208 let leaf = t.create_element(div);
1209 t.insert(leaf, mid, 0);
1211 t.insert(mid, root, 0);
1212 t.set_class(mid, "page");
1213 t.set_class(leaf, "leaf");
1214 (mid, leaf)
1215 });
1216 tree::set_engine(sk_css::Engine::compile(
1217 ":root { --v: 0.2 } .page { --v: 0.8 } .leaf { opacity: var(--v) }",
1218 ));
1219 tree::restyle_all();
1220 assert_eq!(opacity_of(leaf), Some(0.8));
1221
1222 tree::with_tree(|t| t.set_class(mid, "other"));
1223 flush_changes();
1224 assert_eq!(opacity_of(leaf), Some(0.2));
1225 }
1226
1227 #[test]
1228 fn an_inline_custom_property_reaches_the_subtree() {
1229 let leaf = tree::with_tree(|t| {
1230 let root = t.create_root();
1231 let div = t.intern("div");
1232 let host = t.create_element(div);
1233 let leaf = t.create_element(div);
1234 t.insert(host, root, 0);
1235 t.insert(leaf, host, 0);
1236 t.set_class(leaf, "leaf");
1237 let key = t.intern("--v");
1238 t.set_style(host, key, "0.35".into());
1239 leaf
1240 });
1241 tree::set_engine(sk_css::Engine::compile(".leaf { opacity: var(--v, 1) }"));
1242 tree::restyle_all();
1243 assert_eq!(opacity_of(leaf), Some(0.35));
1244 }
1245
1246 #[test]
1247 fn a_class_change_restyles_the_whole_subtree_under_it() {
1248 let (mid, leaf) = tree::with_tree(|t| {
1249 let root = t.create_root();
1250 let div = t.intern("div");
1251 let mid = t.create_element(div);
1252 let leaf = t.create_element(div);
1253 t.insert(mid, root, 0);
1254 t.insert(leaf, mid, 0);
1255 t.set_class(leaf, "leaf");
1256 (mid, leaf)
1257 });
1258 tree::set_engine(sk_css::Engine::compile(
1259 ".leaf { opacity: 0.1 } .page .leaf { opacity: 0.9 }",
1260 ));
1261 tree::restyle_all();
1262 assert_eq!(opacity_of(leaf), Some(0.1));
1263
1264 tree::with_tree(|t| t.set_class(mid, "page"));
1265 flush_changes();
1266 assert_eq!(opacity_of(leaf), Some(0.9));
1267 }
1268
1269 #[test]
1270 fn a_parent_gaining_the_key_of_a_parent_keyed_rule_restyles_its_children() {
1271 let (mid, first, second) = tree::with_tree(|t| {
1272 let root = t.create_root();
1273 let div = t.intern("div");
1274 let mid = t.create_element(div);
1275 let first = t.create_element(div);
1276 let second = t.create_element(div);
1277 t.insert(mid, root, 0);
1278 t.insert(first, mid, 0);
1279 t.insert(second, mid, 1);
1280 (mid, first, second)
1281 });
1282 tree::set_engine(sk_css::Engine::compile(
1283 "* { opacity: 0.1 } .stack > * { opacity: 0.5 } .space > * + * { opacity: 0.9 } \
1284 #list > * { opacity: 0.3 }",
1285 ));
1286 tree::restyle_all();
1287 assert_eq!(
1288 (opacity_of(first), opacity_of(second)),
1289 (Some(0.1), Some(0.1))
1290 );
1291
1292 tree::with_tree(|t| t.set_class(mid, "stack"));
1293 flush_changes();
1294 assert_eq!(
1295 (opacity_of(first), opacity_of(second)),
1296 (Some(0.5), Some(0.5))
1297 );
1298
1299 tree::with_tree(|t| t.set_class(mid, "space"));
1300 flush_changes();
1301 assert_eq!(
1302 (opacity_of(first), opacity_of(second)),
1303 (Some(0.1), Some(0.9))
1304 );
1305
1306 tree::with_tree(|t| {
1307 t.set_class(mid, "");
1308 let key = t.intern("id");
1309 t.set_prop(mid, key, Some("list".into()));
1310 });
1311 flush_changes();
1312 assert_eq!(
1313 (opacity_of(first), opacity_of(second)),
1314 (Some(0.3), Some(0.3))
1315 );
1316 }
1317
1318 #[test]
1320 fn a_repeated_class_is_one_entry_of_the_class_list() {
1321 tree::with_tree(|t| {
1322 let root = t.create_root();
1323 let tag = t.intern("svg");
1324 let svg = t.create_element(tag);
1325 t.insert(svg, root, 0);
1326 t.set_class(svg, "lucide w-4 h-4 lucide-plus w-4 h-4");
1327 let n = t.node(svg).unwrap();
1328 assert_eq!(n.classes, ["lucide", "w-4", "h-4", "lucide-plus"]);
1329 assert_eq!(n.class_attr, "lucide w-4 h-4 lucide-plus w-4 h-4");
1330 });
1331 }
1332
1333 #[test]
1334 fn an_inherited_var_flip_restyles_the_descendants_that_read_it() {
1335 let (mid, leaf) = tree::with_tree(|t| {
1336 let root = t.create_root();
1337 let div = t.intern("div");
1338 let mid = t.create_element(div);
1339 let leaf = t.create_element(div);
1340 t.insert(mid, root, 0);
1341 t.insert(leaf, mid, 0);
1342 t.set_class(mid, "a");
1343 t.set_class(leaf, "leaf");
1344 (mid, leaf)
1345 });
1346 tree::set_engine(sk_css::Engine::compile(
1347 ".a { --v: 0.25 } .b { --v: 0.75 } .leaf { opacity: var(--v, 1) }",
1348 ));
1349 tree::restyle_all();
1350 assert_eq!(opacity_of(leaf), Some(0.25));
1351
1352 tree::with_tree(|t| t.set_class(mid, "b"));
1353 flush_changes();
1354 assert_eq!(opacity_of(leaf), Some(0.75));
1355 }
1356
1357 #[test]
1358 fn a_sibling_combinator_still_sees_a_class_change_next_door() {
1359 let (first, second) = tree::with_tree(|t| {
1360 let root = t.create_root();
1361 let div = t.intern("div");
1362 let first = t.create_element(div);
1363 let second = t.create_element(div);
1364 t.insert(first, root, 0);
1365 t.insert(second, root, 0);
1366 t.set_class(second, "second");
1367 (first, second)
1368 });
1369 tree::set_engine(sk_css::Engine::compile(
1370 ".second { opacity: 0.2 } .marker + .second { opacity: 0.8 }",
1371 ));
1372 tree::restyle_all();
1373 assert_eq!(opacity_of(second), Some(0.2));
1374
1375 tree::with_tree(|t| t.set_class(first, "marker"));
1376 flush_changes();
1377 assert_eq!(opacity_of(second), Some(0.8));
1378 }
1379
1380 #[test]
1381 fn inserting_a_child_recascades_the_siblings_a_structural_pseudo_reads() {
1382 let (parent, only) = tree::with_tree(|t| {
1383 let root = t.create_root();
1384 let div = t.intern("div");
1385 let parent = t.create_element(div);
1386 let only = t.create_element(div);
1387 t.insert(parent, root, 0);
1388 t.insert(only, parent, 0);
1389 t.set_class(only, "item");
1390 (parent, only)
1391 });
1392 tree::set_engine(sk_css::Engine::compile(
1393 ".item { opacity: 0.3 } .item:last-child { opacity: 0.7 }",
1394 ));
1395 tree::restyle_all();
1396 assert_eq!(
1397 opacity_of(only),
1398 Some(0.7),
1399 "the only child is the last child"
1400 );
1401
1402 tree::with_tree(|t| {
1403 let div = t.intern("div");
1404 let second = t.create_element(div);
1405 t.insert(second, parent, 0);
1406 t.set_class(second, "item");
1407 });
1408 flush_changes();
1409 assert_eq!(opacity_of(only), Some(0.3));
1410 }
1411
1412 #[test]
1413 fn a_prepend_moves_the_nth_child_answer_of_every_later_sibling() {
1414 let (parent, items) = tree::with_tree(|t| {
1415 let root = t.create_root();
1416 let div = t.intern("div");
1417 let parent = t.create_element(div);
1418 t.insert(parent, root, 0);
1419 let items: Vec<u32> = (0..4)
1420 .map(|_| {
1421 let id = t.create_element(div);
1422 t.insert(id, parent, 0);
1423 t.set_class(id, "item");
1424 id
1425 })
1426 .collect();
1427 (parent, items)
1428 });
1429 tree::set_engine(sk_css::Engine::compile(
1430 ".item { opacity: 0.3 } .item:nth-child(4) { opacity: 0.7 }",
1431 ));
1432 tree::restyle_all();
1433 assert_eq!(opacity_of(items[3]), Some(0.7));
1434
1435 let first = tree::with_tree(|t| {
1436 let div = t.intern("div");
1437 let first = t.create_element(div);
1438 t.insert(first, parent, items[0]);
1439 first
1440 });
1441 flush_changes();
1442 assert_eq!(
1443 opacity_of(items[2]),
1444 Some(0.7),
1445 "third item is the fourth child now"
1446 );
1447 assert_eq!(
1448 opacity_of(items[3]),
1449 Some(0.3),
1450 "and the last one the fifth"
1451 );
1452
1453 tree::with_tree(|t| t.remove(first));
1454 flush_changes();
1455 assert_eq!(opacity_of(items[2]), Some(0.3));
1456 assert_eq!(opacity_of(items[3]), Some(0.7));
1457 }
1458
1459 #[test]
1460 fn empty_follows_inserts_removes_and_text() {
1461 let boxed = tree::with_tree(|t| {
1462 let root = t.create_root();
1463 let div = t.intern("div");
1464 let boxed = t.create_element(div);
1465 t.insert(boxed, root, 0);
1466 t.set_class(boxed, "box");
1467 boxed
1468 });
1469 tree::set_engine(sk_css::Engine::compile(
1470 ".box { opacity: 0.3 } .box:empty { opacity: 0.7 }",
1471 ));
1472 tree::restyle_all();
1473 assert_eq!(opacity_of(boxed), Some(0.7));
1474
1475 let child = tree::with_tree(|t| {
1476 let span = t.intern("span");
1477 let child = t.create_element(span);
1478 t.insert(child, boxed, 0);
1479 child
1480 });
1481 flush_changes();
1482 assert_eq!(opacity_of(boxed), Some(0.3), "an element child");
1483
1484 tree::with_tree(|t| t.remove(child));
1485 flush_changes();
1486 assert_eq!(opacity_of(boxed), Some(0.7), "removed again");
1487
1488 let text = tree::with_tree(|t| {
1489 let text = t.create_text();
1490 t.insert(text, boxed, 0);
1491 text
1492 });
1493 flush_changes();
1494 assert_eq!(
1495 opacity_of(boxed),
1496 Some(0.7),
1497 "an empty text node is still empty"
1498 );
1499 tree::with_tree(|t| t.set_text(text, "hi".into()));
1500 flush_changes();
1501 assert_eq!(opacity_of(boxed), Some(0.3), "text with data");
1502 }
1503
1504 #[test]
1505 fn has_follows_changes_anywhere_under_the_anchor() {
1506 let (card, inner) = tree::with_tree(|t| {
1507 let root = t.create_root();
1508 let div = t.intern("div");
1509 let card = t.create_element(div);
1510 let inner = t.create_element(div);
1511 t.insert(card, root, 0);
1512 t.insert(inner, card, 0);
1513 t.set_class(card, "card");
1514 (card, inner)
1515 });
1516 tree::set_engine(sk_css::Engine::compile(
1517 ".card { opacity: 0.3 } .card:has(> .icon) { opacity: 0.6 } .card:has([data-on]) { opacity: 0.9 }",
1518 ));
1519 tree::restyle_all();
1520 assert_eq!(opacity_of(card), Some(0.3));
1521
1522 let icon = tree::with_tree(|t| {
1523 let i = t.intern("i");
1524 let icon = t.create_element(i);
1525 t.set_class(icon, "icon");
1526 t.insert(icon, card, 0);
1527 icon
1528 });
1529 flush_changes();
1530 assert_eq!(opacity_of(card), Some(0.6), "a direct child arrived");
1531
1532 tree::with_tree(|t| t.remove(icon));
1533 flush_changes();
1534 assert_eq!(opacity_of(card), Some(0.3), "and left");
1535
1536 let deep = tree::with_tree(|t| {
1537 let span = t.intern("span");
1538 let deep = t.create_element(span);
1539 t.insert(deep, inner, 0);
1540 deep
1541 });
1542 flush_changes();
1543 let on = tree::with_tree(|t| t.intern("data-on"));
1544 tree::with_tree(|t| t.set_prop(deep, on, Some(String::new())));
1545 flush_changes();
1546 assert_eq!(opacity_of(card), Some(0.9), "an attribute two levels down");
1547 }
1548
1549 #[test]
1550 fn has_left_of_a_combinator_reaches_the_descendants_that_read_it() {
1551 let (panel, title, slot) = tree::with_tree(|t| {
1552 let root = t.create_root();
1553 let div = t.intern("div");
1554 let panel = t.create_element(div);
1555 let title = t.create_element(div);
1556 let slot = t.create_element(div);
1557 t.insert(panel, root, 0);
1558 t.insert(title, panel, 0);
1559 t.insert(slot, panel, 0);
1560 t.set_class(panel, "panel");
1561 t.set_class(title, "title");
1562 (panel, title, slot)
1563 });
1564 tree::set_engine(sk_css::Engine::compile(
1565 ".title { opacity: 0.3 } .panel:has(.editor) .title { opacity: 0.8 }",
1566 ));
1567 tree::restyle_all();
1568 assert_eq!(opacity_of(title), Some(0.3));
1569
1570 tree::with_tree(|t| {
1571 let div = t.intern("div");
1572 let editor = t.create_element(div);
1573 t.set_class(editor, "editor");
1574 t.insert(editor, slot, 0);
1575 });
1576 flush_changes();
1577 assert_eq!(
1578 opacity_of(title),
1579 Some(0.8),
1580 "the editor arrived next door to the title"
1581 );
1582 let _ = panel;
1583 }
1584
1585 #[test]
1586 fn a_wave_of_hundreds_of_separate_marks_restyles_every_one() {
1587 let ids = tree::with_tree(|t| {
1588 let root = t.create_root();
1589 let div = t.intern("div");
1590 let ids: Vec<u32> = (0..200)
1591 .map(|_| {
1592 let id = t.create_element(div);
1593 t.insert(id, root, 0);
1594 id
1595 })
1596 .collect();
1597 ids
1598 });
1599 tree::set_engine(sk_css::Engine::compile(".on { opacity: 0.6 }"));
1600 tree::restyle_all();
1601
1602 tree::with_tree(|t| {
1603 for &id in &ids {
1604 t.set_class(id, "on");
1605 }
1606 });
1607 flush_changes();
1608 for &id in &ids {
1609 assert_eq!(opacity_of(id), Some(0.6), "node {id} was left unstyled");
1610 }
1611 }
1612
1613 #[test]
1614 fn media_conditions_follow_the_published_env() {
1615 let child = tree::with_tree(|t| {
1616 let root = t.create_root();
1617 let tag = t.intern("div");
1618 let child = t.create_element(tag);
1619 t.insert(child, root, 0);
1620 t.set_class(child, "box");
1621 child
1622 });
1623 tree::set_engine(sk_css::Engine::compile(
1624 ".box { opacity: 0.1 } @media (min-width: 640px) { .box { opacity: 0.9 } }",
1625 ));
1626
1627 set_env(env(500.0, 600.0, false, false));
1628 flush_changes();
1629 assert_eq!(opacity_of(child), Some(0.1));
1630
1631 assert!(set_env(env(700.0, 600.0, false, false)));
1632 assert!(flush_changes());
1633 assert_eq!(opacity_of(child), Some(0.9));
1634 }
1635
1636 fn inert_of(id: u32) -> Option<bool> {
1637 tree::read_tree(|t| {
1638 t.node(id).and_then(|n| n.computed.as_ref()).map(|c| {
1639 c.extras
1640 .pointer_events_none
1641 .expect("the cascade resolves this for every element")
1642 })
1643 })
1644 }
1645
1646 #[test]
1649 fn pointer_events_none_inherits_and_can_be_opted_out_of() {
1650 let (panel, child, opted_in, deep) = tree::with_tree(|t| {
1651 let root = t.create_root();
1652 let tag = t.intern("div");
1653 let mut kid = |parent: u32, class: &str| {
1654 let id = t.create_element(tag);
1655 t.insert(id, parent, 0);
1656 t.set_class(id, class);
1657 id
1658 };
1659 let panel = kid(root, "inert");
1660 let child = kid(panel, "plain");
1661 let opted_in = kid(panel, "live");
1662 let deep = kid(opted_in, "plain");
1663 (panel, child, opted_in, deep)
1664 });
1665 tree::set_engine(sk_css::Engine::compile(
1666 ".inert { pointer-events: none } .live { pointer-events: auto }",
1667 ));
1668 flush_changes();
1669
1670 assert_eq!(inert_of(panel), Some(true));
1671 assert_eq!(inert_of(child), Some(true), "inertness inherits");
1672 assert_eq!(inert_of(opted_in), Some(false), "`auto` opts back in");
1673 assert_eq!(inert_of(deep), Some(false), "…and that inherits too");
1674 }
1675
1676 #[test]
1677 fn focus_refuses_what_css_hides() {
1678 let ids = tree::with_tree(|t| {
1679 let root = t.create_root();
1680 let tag = t.intern("div");
1681 let mut kid = |parent: u32, class: &str| {
1682 let id = t.create_element(tag);
1683 t.insert(id, parent, 0);
1684 t.set_class(id, class);
1685 id
1686 };
1687 let hidden = kid(root, "hidden");
1688 let under_hidden = kid(hidden, "plain");
1689 let shown = kid(hidden, "shown");
1690 let gone = kid(root, "gone");
1691 let under_gone = kid(gone, "plain");
1692 let sr = kid(root, "sr");
1693 let plain = kid(root, "plain");
1694 [under_hidden, shown, under_gone, sr, plain]
1695 });
1696 tree::set_engine(sk_css::Engine::compile(
1697 ".hidden { visibility: hidden } .shown { visibility: visible } .gone { display: none } \
1698 .sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0, 0, 0, 0) }",
1699 ));
1700 flush_changes();
1701 let [under_hidden, shown, under_gone, sr, plain] = ids;
1702 assert!(
1703 render::style_refuses_focus(under_hidden),
1704 "visibility inherits"
1705 );
1706 assert!(
1707 !render::style_refuses_focus(shown),
1708 "the nearest declaration decides"
1709 );
1710 assert!(
1711 render::style_refuses_focus(under_gone),
1712 "a display: none subtree is not rendered"
1713 );
1714 assert!(
1715 !render::style_refuses_focus(sr),
1716 "a screen-reader-only box is visible to CSS"
1717 );
1718 assert!(!render::style_refuses_focus(plain));
1719 assert!(tree::read_tree(
1720 |t| !render::css_visible(t, under_hidden) && render::css_visible(t, sr)
1721 ));
1722 }
1723}
1724
1725pub fn dispatch_event(node: u32, event: u32, payload: &EventPayload) -> bool {
1730 dispatch_event_with(node, event, payload, None)
1731}
1732
1733thread_local! {
1734 static POINTER_AT: std::cell::Cell<Option<(f64, f64)>> = const { std::cell::Cell::new(None) };
1736}
1737
1738pub(crate) fn pointer_at_next_dispatch(x: f64, y: f64) {
1741 POINTER_AT.with(|c| c.set(Some((x, y))));
1742}
1743
1744pub fn dispatch_event_with(
1747 node: u32,
1748 event: u32,
1749 payload: &EventPayload,
1750 data: Option<Value>,
1751) -> bool {
1752 let at = POINTER_AT.with(|c| c.take());
1754 let f = tree::dispatcher();
1755 if f == 0 {
1756 return true;
1757 }
1758 let span = perf::Span::start();
1759 let proceed = dispatch_event_inner(f, node, event, payload, data, at);
1760 perf::note_js(span.ms());
1761 proceed
1762}
1763
1764fn dispatch_event_inner(
1765 f: u64,
1766 node: u32,
1767 event: u32,
1768 payload: &EventPayload,
1769 data: Option<Value>,
1770 at: Option<(f64, f64)>,
1771) -> bool {
1772 sk_runtime::bridge::settle_owed_drain();
1773 let owe = in_input_dispatch();
1776 if owe {
1777 sk_runtime::bridge::owe_drain();
1778 }
1779 JsRuntime::with(|rt| {
1780 let key = payload.key.map(|k| rt.ctx().string(k));
1781 let (x, y) = at.map_or((Value::undefined(), Value::undefined()), |(x, y)| {
1782 (Value::double(x), Value::double(y))
1783 });
1784 let args = [
1785 Value::int32(node as i32),
1786 Value::int32(event as i32),
1787 Value::double(payload.a),
1788 Value::double(payload.b),
1789 Value::double(payload.c),
1790 Value::double(payload.d),
1791 key.unwrap_or_else(Value::undefined),
1792 data.unwrap_or_else(Value::undefined),
1793 x,
1794 y,
1795 ];
1796 let proceed = match rt.ctx().call(Value(f), Value::undefined(), &args) {
1797 Ok(v) => v.as_bool().unwrap_or(true),
1798 Err(sk_runtime::redjs::api::Error::Exception(e)) => {
1799 let err = rt.describe(e);
1800 eprintln!("[js dispatch] {}\n{}", err.header, err.stack);
1801 log::record("js", format!("[js dispatch] {}\n{}", err.header, err.stack));
1802 true
1803 }
1804 Err(_) => true,
1805 };
1806 if !owe {
1807 rt.ctx().drain_microtasks();
1808 }
1809 proceed
1810 })
1811}