1mod 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#[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
172host_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
265host_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
283sk_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
309host_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
347host_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
353host_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
368host_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
468thread_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 static OFF_INPUT: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
477 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
482pub 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 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
513pub(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
531pub fn set_sync_layout(f: fn()) {
533 SYNC_LAYOUT.with(|c| c.set(Some(f)));
534}
535
536pub fn sync_layout() {
539 if IN_SYNC_LAYOUT.with(|c| c.get()) {
540 return;
541 }
542 sync_layout_inner();
543}
544
545pub(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 DrawnBySync,
586}
587
588pub fn flush_changes() -> bool {
589 flush_changes_kind() != Flush::Unchanged
590}
591
592pub 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#[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#[cfg(windows)]
638pub use sk_video::mf::{SharedDeviceProvider, SharedVideoDevice};
639
640#[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
649pub fn video_device_changed() -> usize {
652 video::device_changed()
653}
654
655pub fn frame_tick(window: &mut gpui::Window, cx: &mut gpui::App) -> bool {
658 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 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
706pub 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
720pub 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
730pub 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
740pub 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
755pub fn env() -> sk_css::Env {
757 tree::env()
758}
759
760pub 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 #[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 #[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 #[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 #[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 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 #[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 #[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
1627pub fn dispatch_event(node: u32, event: u32, payload: &EventPayload) -> bool {
1632 dispatch_event_with(node, event, payload, None)
1633}
1634
1635thread_local! {
1636 static POINTER_AT: std::cell::Cell<Option<(f64, f64)>> = const { std::cell::Cell::new(None) };
1638}
1639
1640pub(crate) fn pointer_at_next_dispatch(x: f64, y: f64) {
1643 POINTER_AT.with(|c| c.set(Some((x, y))));
1644}
1645
1646pub fn dispatch_event_with(
1649 node: u32,
1650 event: u32,
1651 payload: &EventPayload,
1652 data: Option<Value>,
1653) -> bool {
1654 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 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}