Skip to main content

sk_tree/
lib.rs

1//! sk-tree — the retained node tree that Vue's custom renderer mutates through `__sk_*` host
2//! functions, and the per-frame lowering of that tree into gpui elements.
3//!
4//! JS holds dense `u32` node ids (0 = none); tags, style keys and event names are interned once via
5//! `__sk_intern` so the hot path carries no strings. Structural ops apply synchronously; `insert` is
6//! also move (implicit detach), `remove` destroys the whole subtree. Mutations mark the tree dirty
7//! and the frame pump notifies the root view after the JS wave.
8
9#[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/// The numeric payload a native input event carries into JS. Mouse: a=x b=y c=button, d=modifier
103/// bits | click count << 4. Wheel: a=deltaX b=deltaY. Input: `key` = the new value. Scroll:
104/// a=scrollLeft b=scrollTop. Modifier bits: 1 ctrl, 2 shift, 4 alt, 8 meta.
105#[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            // SAFETY: the live context of this host function.
144            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
201// The array form of `:style` (`display: ["-webkit-box", "flex"]`) keeps the last value the browser
202// accepts, and only the engine can say which one that is here.
203host_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
303// Ids comma-joined, `""` for no match, or `"!<advisory>"` for a selector the engine cannot run.
304host_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
321// Dev-build performance advisories. `__sk_perf_frame()` counts built frames; `__sk_perf_visible(id)`
322// answers "<elements>,<in view>" for `id`'s subtree against its scroll container, or "".
323sk_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
347// `__sk_focus(id, op)`: op 0 `el.focus()` answers "moved:<old id>" (JS fires blur/focusout on the old
348// one, then focus/focusin), "already", "pending" (queued for the frame tick) or "refused" (not
349// focusable, detached, or hidden by CSS); op 1 `el.blur()` answers "blurred" or "". With no window
350// (module-scope code at startup) a focus is queued and a blur is a no-op.
351host_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
385// `name=value` lines, empty for a node that is not a loaded `<video>`.
386host_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
391// One scalar media property by code (`video::media_prop`): a number, or `undefined` for a node that
392// is not a live media element.
393host_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
406// `canPlayType(type)` -> "" | "maybe" | "probably", probed live on this machine — never a static
407// table (the owner constraint in sk_video's docs).
408host_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
508// A browser lays out on read; here layout happens during a frame, so a DOM read before the first
509// frame would see 0. The read forces a layout through the host hook ([`sync_layout`]).
510
511thread_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    /// Set inside JS dispatches no gpui listener is under ([`off_input`]).
516    static OFF_INPUT: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
517    /// [`render::build_count`] at the last flush that took changes; while equal, nothing has laid it out.
518    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
522/// True while a gpui listener (or gpui's own draw) has called into JS. The forced layout must not
523/// draw then: gpui took the frame's listeners out, and focus listeners run inside `Window::draw`.
524pub 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    /// The same mark whatever encloses it (listeners gpui runs from inside its draw).
539    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
553/// Runs `f` as JS no gpui listener is under (frame tick, pump, devtools events, `window.defer`).
554/// It does not hide an enclosing input dispatch.
555pub(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
571/// Installs the host's "draw one frame now" callback (`sk-tree` cannot depend on `sk-app`).
572pub fn set_sync_layout(f: fn()) {
573    SYNC_LAYOUT.with(|c| c.set(Some(f)));
574}
575
576/// Folds pending changes and draws one frame so a layout read answers from real rectangles.
577/// Re-entrant calls are dropped; a no-op with no hook installed.
578pub fn sync_layout() {
579    if IN_SYNC_LAYOUT.with(|c| c.get()) {
580        return;
581    }
582    sync_layout_inner();
583}
584
585/// [`sync_layout`], recorded in the devtools frame trace.
586pub(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    /// A forced layout drew after the last change; a drawn frame waits to be presented.
629    DrawnBySync,
630}
631
632pub fn flush_changes() -> bool {
633    flush_changes_kind() != Flush::Unchanged
634}
635
636/// Like [`flush_changes`], but tells a wave a forced layout already drew from one that needs a draw.
637static TREE_REVISION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
638
639/// Advances on every flush that found the tree changed, whichever path flushed it: a frame, an
640/// input dispatch, a forced layout or a devtools command.
641pub 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
681/// Whether [`frame_tick`] polls something that is loading or playing (video, Lottie, stickers,
682/// image loads), which tells nobody when it has a new frame.
683pub fn media_polls() -> bool {
684    video::any_playing()
685        || lottie::any_playing()
686        || img::loads_pending()
687        || render::sticker::polls()
688}
689
690/// Publishes the renderer's D3D11 device so Media Foundation decodes onto gpui's texture pool.
691///
692/// # Safety
693/// `ptr` must be a live `ID3D11Device` COM pointer owned by the caller.
694#[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/// A lazy provider of the renderer's D3D11 device, resolved when the first video backend asks.
700#[cfg(windows)]
701pub use video_device::{SharedDeviceProvider, SharedVideoDevice};
702
703/// # Safety
704/// The provider's successful lease must retain its live D3D11 device.
705#[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
712/// The renderer recreated its D3D11 device: every `<sk-surface>` drops its GPU frame and producers
713/// hear [`surface::SurfaceEvent::DeviceLost`].
714pub fn surface_device_changed() {
715    surface::device_changed();
716}
717
718/// The renderer recreated its D3D11 device; rebuild every `<video>` on the new one, keeping
719/// position and transport state.
720pub fn video_device_changed() -> usize {
721    video::device_changed()
722}
723
724/// Per-frame work that needs a `Window`; call once per frame from the pump, before the draw.
725/// Returns `true` when the window must repaint.
726pub fn frame_tick(window: &mut gpui::Window, cx: &mut gpui::App) -> bool {
727    // The pump's, not an input listener's: a layout read in a handler may force a frame.
728    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    // `|` not `||`: every part must run each tick.
738    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
779/// Per-frame work a SECONDARY window does from its own `render()`: its atlas resources and focus.
780/// The JS-facing half stays in [`frame_tick`] (one JS realm, once per frame group).
781pub 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
795/// Forgets everything a window held, because it has closed. Its atlas went with it, so tiles it
796/// still owed are dropped: another window's `drop_image` could remove keys that window re-inserted.
797pub 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
806/// A paint-only frame is not presented while the page is hidden (`crate::live`); the draw that
807/// shows the window again paints the newest one.
808pub fn set_page_hidden(hidden: bool) {
809    live::set_hidden(hidden);
810    surface::feedback::set_page_hidden(hidden);
811}
812
813/// The app is quitting: `<sk-surface>` frames still waiting to be shown are dropped as closed.
814pub 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
822/// Publishes the window environment `@media` is evaluated against (viewport, colour scheme,
823/// reduced motion, DPI, display mode). Call every frame; a change dirties the tree and returns `true`.
824pub 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
837/// The last [`set_env`] value, the source `matchMedia` evaluates against (the primary window's).
838pub fn env() -> sk_css::Env {
839    tree::env()
840}
841
842/// Evaluates one media query against [`env`], as the cascade would. `Err` is the compile failure.
843pub 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    /// Attribute selectors read only the property map; `class` rides `set_class`.
930    #[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    /// A dispatch under `off_input` does not count as input, but never hides an enclosing one.
1011    #[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    /// `getComputedStyle` is a flush point: reka-ui's `<Presence>` reads style right after an
1036    /// attribute change, and a stale read unmounted dialogs without animating them.
1037    #[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    /// Custom properties inherit through the real tree, so restyle walks document order, not ids.
1202    #[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            // Inserted child-first so id order and document order disagree.
1210            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    /// The class list is a set, as `classList` is: a repeated class must not run its rules twice.
1319    #[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    /// `pointer-events` inherits, and an `opacity-0 pointer-events-none` panel parked over the live
1647    /// one would otherwise take every click aimed at it.
1648    #[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
1725/// Dispatches an input event into JS and runs its microtask checkpoint so Vue's flush lands in the
1726/// same frame. Needs `Phase::Commit` published; `false` means a handler called `preventDefault()`.
1727/// Under a gpui listener the checkpoint is owed and run after gpui's dispatch
1728/// (`render::settle_owed_later`), where an `onMounted` that measures can lay out.
1729pub fn dispatch_event(node: u32, event: u32, payload: &EventPayload) -> bool {
1730    dispatch_event_with(node, event, payload, None)
1731}
1732
1733thread_local! {
1734    /// The pointer position, window CSS px, for the next dispatch only.
1735    static POINTER_AT: std::cell::Cell<Option<(f64, f64)>> = const { std::cell::Cell::new(None) };
1736}
1737
1738/// The next [`dispatch_event`] carries the pointer at (`x`, `y`) as the dispatcher's ninth and tenth
1739/// arguments (a `wheel` payload has no room for `clientX` / `clientY`).
1740pub(crate) fn pointer_at_next_dispatch(x: f64, y: f64) {
1741    POINTER_AT.with(|c| c.set(Some((x, y))));
1742}
1743
1744/// [`dispatch_event`] with an object for the event to carry, passed as the dispatcher's eighth
1745/// argument: a ClipboardEvent's `clipboardData` (`crate::clipboard`).
1746pub fn dispatch_event_with(
1747    node: u32,
1748    event: u32,
1749    payload: &EventPayload,
1750    data: Option<Value>,
1751) -> bool {
1752    // Taken first, so a position set for a dispatch that goes nowhere never reaches the next one.
1753    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    // Under a gpui listener, owe the checkpoint before the call (owing holds the engine lock, or JSC
1774    // drains when the call ends). Nested under a script, the script's own checkpoint runs it.
1775    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}