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