tawasuyu/llimphi
Sovereign retained-mode GPU UI framework in Rust (wgpu+vello+taffy+parley), Elm loop, 40+ widgets.
⎇ 168cd187519c0ad575d3ce63baee2f164c38d9d1
llimphi-compositor/src/lib.rs
Historia
Quién tocó qué
crudo
chore: refresco desde el monorepo — 128 miembros, los 76 widgets y los 11 módulos
1//! llimphi-compositor — el núcleo declarativo de Llimphi, sin winit.
2//!
3//! Aquí vive el árbol de vista `View<Msg>` (DSL declarativo), su instalación
4//! sobre taffy (`mount`), el pintado a `vello::Scene` (`paint`/`paint_gpu`) y
5//! el hit-test. Nada de esto necesita una ventana ni `llimphi-hal`: la
6//! composición `view → layout → scene` es pura y reutilizable.
7//!
8//! El runtime que la maneja vive aparte:
9//! - `llimphi-ui` la corre sobre winit (`run<A: App>()`).
10//! - a futuro, un runtime sobre el framebuffer del kernel `wawa` puede
11//! reusar exactamente este compositor sin arrastrar winit.
12//!
13//! `wgpu` entra sólo por la firma de [`GpuPaintFn`] (tipos de Device/Queue/
14//! Encoder/TextureView); `wgpu` no depende de winit, así que el compositor
15//! sigue libre de windowing.
16
17// `no_std` cuando se pide el perfil bare-metal (W3.b de PLAN-LLIMPHI.md). El
18// compositor es aritmética sobre un árbol y emisión de órdenes de dibujo: nada
19// de eso necesitaba un sistema operativo, sólo lo heredaba de `std`.
20#![cfg_attr(not(feature = "std"), no_std)]
21
22// `format!` y `vec!` para todo el crate.
23#[macro_use]
24extern crate alloc;
25
26// Preludio de `alloc`: bajo `no_std` estos tipos ya no vienen solos.
27#[allow(unused_imports)]
28use alloc::{boxed::Box, string::{String, ToString}, vec::Vec};
29
30use hashbrown::HashMap;
31use alloc::sync::Arc;
32
33/// El reloj de las animaciones. **En cualquier target nativo esto ES
34/// `crate::Instant`** — `web_time` lo re-exporta sin envoltorio ni coste.
35/// En wasm32 se apoya en `performance.now()`, porque allí
36/// `crate::Instant::now()` no está implementado y panica en runtime.
37///
38/// El compositor no llama a `now()` en el camino de producción (el runtime le
39/// pasa el instante del frame, y los tests instantes fabricados), pero el
40/// **tipo** tiene que ser el mismo que el del runtime — y el de `llimphi-ui`
41/// está atado al `Instant` con que winit tipa `ControlFlow::WaitUntil` en web.
42#[cfg(feature = "std")]
43pub use web_time::Instant;
44
45/// El reloj de las animaciones **sin sistema operativo**.
46///
47/// `web-time` no es `#![no_std]` —reexporta `std::time`— y era la ÚNICA cosa que
48/// impedía que el compositor cruzara a wawa: todo lo demás ya viajaba. Acá se
49/// reemplaza por lo mínimo que el compositor realmente usa, que resultó ser
50/// asombrosamente poco: `saturating_duration_since` y comparar. `Instant::now()`
51/// no existe a propósito —en el kernel no hay un reloj global al que preguntarle
52/// la hora—, y tampoco hace falta: el runtime pasa el instante del fotograma.
53/// Que no exista convierte un uso equivocado en un error de compilación en vez
54/// de una animación congelada.
55#[cfg(not(feature = "std"))]
56pub use reloj::Instant;
57
58#[cfg(not(feature = "std"))]
59mod reloj {
60 use core::time::Duration;
61
62 /// Instante monotónico, en **microsegundos desde el arranque**.
63 ///
64 /// El kernel de wawa lo construye con [`Instant::desde_micros`] a partir de
65 /// su contador del PIT (100 Hz). Microsegundos y no milisegundos porque a
66 /// 60 fps un fotograma dura 16.667 µs: en milisegundos la animación
67 /// avanzaría a saltos de un 6% de frame.
68 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
69 pub struct Instant(u64);
70
71 impl Instant {
72 /// Un instante a partir del contador monotónico del sistema.
73 pub const fn desde_micros(micros: u64) -> Self {
74 Self(micros)
75 }
76
77 /// Los microsegundos que lleva adentro.
78 pub const fn micros(self) -> u64 {
79 self.0
80 }
81
82 /// Tiempo transcurrido desde `earlier`; cero si `earlier` es posterior.
83 ///
84 /// Satura en vez de entrar en pánico, igual que el de `std`: en un
85 /// kernel, que un reloj vuelva atrás no puede tumbar el compositor.
86 pub fn saturating_duration_since(&self, earlier: Self) -> Duration {
87 Duration::from_micros(self.0.saturating_sub(earlier.0))
88 }
89 }
90}
91
92
93// =============================================================================
94// Matemática de coma flotante sin `std`
95// -----------------------------------------------------------------------------
96// `ceil`, `sqrt` y compañía son MÉTODOS que aporta la stdlib, no operaciones
97// del lenguaje: sin `std` no existen. La tentación es importar
98// `kurbo::common::FloatFuncs`, pero eso es una trampa de `cfg` —kurbo sólo lo
99// define cuando SU feature `std` está apagada, así que el import compilaría en
100// wawa y fallaría en Linux (ya pasó en `llimphi-theme`)—. Dos funciones
101// explícitas evitan el problema entero.
102// =============================================================================
103
104/// Redondeo hacia arriba, con o sin sistema operativo.
105///
106/// `allow(dead_code)` porque **sus llamadores dependen del perfil**: en el
107/// build con `std` no queda ninguno, y borrarla rompería el `no_std`. Es el
108/// costo de que este crate compile en los dos mundos.
109#[allow(dead_code)]
110#[inline]
111pub(crate) fn ceil_f32(x: f32) -> f32 {
112 #[cfg(feature = "std")]
113 {
114 x.ceil()
115 }
116 #[cfg(not(feature = "std"))]
117 {
118 libm::ceilf(x)
119 }
120}
121
122/// Raíz cuadrada, con o sin sistema operativo.
123#[inline]
124pub(crate) fn sqrt_f64(x: f64) -> f64 {
125 #[cfg(feature = "std")]
126 {
127 x.sqrt()
128 }
129 #[cfg(not(feature = "std"))]
130 {
131 libm::sqrt(x)
132 }
133}
134
135/// El lienzo sobre el que se pinta — `vello::Scene` en Linux,
136/// `llimphi_cpu::Escena` en wawa (W3.b de `PLAN-LLIMPHI.md`).
137///
138/// El compositor no nombra a ninguno de los dos: nombra a `Lienzo`, y el alias
139/// lo conmuta `llimphi-text` según la feature de backend. Los dos tipos exponen
140/// los mismos ocho métodos con las mismas firmas —`llimphi_cpu::Escena` se
141/// diseñó **espejando** a `vello::Scene`, no envolviéndola, justamente para
142/// esto—, así que las 4.000 líneas de `render.rs` no distinguen sobre cuál están
143/// pintando. Cambiar de backend es cambiar una feature, no reescribir el paint.
144pub use llimphi_text::Lienzo;
145
146// -----------------------------------------------------------------------------
147// El hub de reexports para los widgets (W4.6)
148// -----------------------------------------------------------------------------
149// Hasta acá el catálogo de widgets colgaba de `llimphi-ui`, que reexporta todo
150// esto — y de paso winit, accesskit, arboard y vello. O sea que un botón, para
151// decir «pinto un rect redondeado», arrastraba el shell de escritorio entero y
152// quedaba fuera del alcance de una app enjaulada.
153//
154// No hacía falta: lo que los widgets usan de `llimphi-ui` es, casi sin
155// excepción, lo que `llimphi-ui` reexporta de acá abajo. Ofrecerlo desde el
156// compositor los vuelve **agnósticos del backend** sin tocarles una línea de
157// composición — es la Regla 2 del repo aplicada al catálogo.
158// -----------------------------------------------------------------------------
159
160/// El árbol de layout y taffy. Los widgets lo usan para `Style`, `Size`, `Rect`
161/// y el `prelude` de dimensiones.
162pub use llimphi_layout;
163/// El motor de texto: `Alignment`, `Typesetter`, `measurement`, y —vía él— los
164/// tipos de `peniko` y `kurbo` con los que se describen colores y formas.
165pub use llimphi_text;
166/// Colores y pinceles. Atajo para `llimphi_text::peniko`, que es donde vive.
167pub use llimphi_text::peniko;
168
169/// El modelo de entrada: `KeyEvent`, `ImeEvent`, `Key`… (W4.7). Vive acá y no
170/// en el shell porque un evento de teclado es un DATO del modelo — quién lo
171/// produjo (winit, el canal de scancodes del kernel, un test) es asunto del
172/// sustrato, igual que quién presenta el framebuffer.
173pub mod input;
174pub use input::{
175 fijar_politica_rueda, politica_rueda, FuenteRueda, ImeEvent, Key, KeyEvent, KeyState,
176 Modifiers, NamedKey, PoliticaRueda, SentidoRueda, WheelDelta,
177};
178
179use llimphi_layout::taffy::NodeId;
180use llimphi_layout::{ComputedLayout, LayoutTree, Style};
181use llimphi_text::peniko::kurbo::{
182 Affine, Ellipse, Point, Rect as KurboRect, RoundedRect, RoundedRectRadii, Stroke,
183};
184use llimphi_text::peniko::{BlendMode, Color, Fill, Gradient, ImageBrush as Image, Mix};
185
186/// Censo de props raras de un árbol `View` — cuántos nodos pagan la caja.
187///
188/// El ahorro del reparto [`ViewRare`] depende de **una sola cifra**: la fracción
189/// de nodos que lleva alguna prop rara. Un árbol donde casi ninguno la lleva
190/// (grillas, listas, texto) ahorra los ~1.840 B por nodo enteros; uno donde casi
191/// todos la llevan (mucho handler, mucha animación) sólo cambia bytes inline por
192/// bytes en el heap y **suma** una asignación por nodo. `stress_grid` es el
193/// primer caso — o sea el mejor —, así que su número no se puede extrapolar a
194/// una app real sin medirla. Esto es lo que la mide.
195#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
196pub struct CensoRare {
197 /// Nodos del árbol.
198 pub nodos: usize,
199 /// Nodos que materializaron la caja de props raras.
200 pub con_rare: usize,
201}
202
203impl CensoRare {
204 /// Bytes del árbol **antes** del reparto: todo nodo pagaba el `View` gordo.
205 pub const VIEW_ANTES: usize = 2472;
206
207 /// Fracción de nodos que paga la caja, en `[0, 1]`.
208 pub fn fraccion(&self) -> f64 {
209 if self.nodos == 0 {
210 return 0.0;
211 }
212 self.con_rare as f64 / self.nodos as f64
213 }
214
215 /// Bytes que ocuparía el árbol con el `View` viejo (2.472 B por nodo).
216 pub fn bytes_antes(&self) -> usize {
217 self.nodos * Self::VIEW_ANTES
218 }
219
220 /// Bytes que ocupa hoy: el `View` flaco por nodo + una caja por el que la usa.
221 pub fn bytes_ahora<Msg>(&self) -> usize {
222 self.nodos * core::mem::size_of::<View<Msg>>()
223 + self.con_rare * core::mem::size_of::<ViewRare<Msg>>()
224 }
225}
226
227/// Recorre el árbol y cuenta nodos vs. nodos con caja. Ver [`CensoRare`].
228pub fn censo_rare<Msg>(v: &View<Msg>) -> CensoRare {
229 let mut c = CensoRare::default();
230 censo_rec(v, &mut c);
231 c
232}
233
234fn censo_rec<Msg>(v: &View<Msg>, c: &mut CensoRare) {
235 c.nodos += 1;
236 if v.rare.is_some() {
237 c.con_rare += 1;
238 }
239 for h in &v.children {
240 censo_rec(h, c);
241 }
242}
243
244
245/// Nombre de cada prop rara, en el orden de bits de [`mascara_rare`].
246pub const NOMBRES_RARE: [&str; 59] = [
247 "intrinsic", "corner_radii", "shadow", "fill_gradient", "border", "image", "image_fit", "mask_image", "mask_placement", "mask_extra", "gpu_painter", "over_painter", "on_click_at", "on_click_screen", "on_right_click", "on_right_click_at", "on_right_click_screen", "on_middle_click", "drag", "drag_at", "drag_velocity", "drag_payload", "on_drop", "drop_hover_fill", "clip_inset", "clip_ellipse", "clip_polygon", "clip_path_svg", "clip_ref_inset", "on_pointer_enter", "on_pointer_leave", "on_pointer_move_at", "on_scroll", "on_scroll_take", "on_scale", "on_rotate", "on_double_tap", "on_double_tap_at", "on_long_press", "on_long_press_at", "focusable", "text_select_key", "anim", "animated_size", "hero", "transform", "transform_rel", "transform_origin", "sticky", "tooltip", "cursor", "ripple", "layout_builder", "backdrop_blur", "filter", "blend", "repaint_boundary", "memo", "double_tap_exclusive",
248];
249
250/// Bytes que ocupa cada prop rara dentro de [`ViewRare`], mismo orden.
251///
252/// Con esto se calcula, sin recompilar, cuánto pesaría `View` si tal prop
253/// volviera adentro — la decisión que el censo informa. Así se eligieron los
254/// cuatro que YA volvieron (`text`, `painter`, `alpha`, `semantics`).
255pub fn tam_rare<Msg>() -> [usize; 59] {
256 [
257 core::mem::size_of::<Option<IntrinsicSize>>(),
258 core::mem::size_of::<Option<RoundedRectRadii>>(),
259 core::mem::size_of::<Option<Shadow>>(),
260 core::mem::size_of::<Option<Gradient>>(),
261 core::mem::size_of::<Option<Border>>(),
262 core::mem::size_of::<Option<Image>>(),
263 core::mem::size_of::<Option<ImageFit>>(),
264 core::mem::size_of::<Option<Image>>(),
265 core::mem::size_of::<Option<MaskPlacement>>(),
266 core::mem::size_of::<Vec<(Image, MaskCompose)>>(),
267 core::mem::size_of::<Option<GpuPaintFn>>(),
268 core::mem::size_of::<Option<PaintFn>>(),
269 core::mem::size_of::<Option<ClickAtFn<Msg>>>(),
270 core::mem::size_of::<Option<ClickAtFn<Msg>>>(),
271 core::mem::size_of::<Option<Msg>>(),
272 core::mem::size_of::<Option<ClickAtFn<Msg>>>(),
273 core::mem::size_of::<Option<ClickAtFn<Msg>>>(),
274 core::mem::size_of::<Option<Msg>>(),
275 core::mem::size_of::<Option<DragFn<Msg>>>(),
276 core::mem::size_of::<Option<DragAtFn<Msg>>>(),
277 core::mem::size_of::<Option<DragVelocityFn<Msg>>>(),
278 core::mem::size_of::<Option<u64>>(),
279 core::mem::size_of::<Option<DropFn<Msg>>>(),
280 core::mem::size_of::<Option<Color>>(),
281 core::mem::size_of::<Option<[f32; 4]>>(),
282 core::mem::size_of::<Option<[f32; 14]>>(),
283 core::mem::size_of::<Option<(bool, Vec<[f32; 4]>)>>(),
284 core::mem::size_of::<Option<(bool, String)>>(),
285 core::mem::size_of::<Option<[f32; 4]>>(),
286 core::mem::size_of::<Option<Msg>>(),
287 core::mem::size_of::<Option<Msg>>(),
288 core::mem::size_of::<Option<ClickAtFn<Msg>>>(),
289 core::mem::size_of::<Option<ScrollFn<Msg>>>(),
290 core::mem::size_of::<Option<ScrollTakeFn<Msg>>>(),
291 core::mem::size_of::<Option<ScaleFn<Msg>>>(),
292 core::mem::size_of::<Option<RotateFn<Msg>>>(),
293 core::mem::size_of::<Option<Msg>>(),
294 core::mem::size_of::<Option<ClickAtFn<Msg>>>(),
295 core::mem::size_of::<Option<Msg>>(),
296 core::mem::size_of::<Option<ClickAtFn<Msg>>>(),
297 core::mem::size_of::<Option<u64>>(),
298 core::mem::size_of::<Option<u64>>(),
299 core::mem::size_of::<Option<Anim>>(),
300 core::mem::size_of::<Option<SizeAnim>>(),
301 core::mem::size_of::<Option<Hero>>(),
302 core::mem::size_of::<Option<Affine>>(),
303 core::mem::size_of::<Option<(f64, f64)>>(),
304 core::mem::size_of::<Option<TransformPivot>>(),
305 core::mem::size_of::<Option<[Option<f32>; 4]>>(),
306 core::mem::size_of::<Option<String>>(),
307 core::mem::size_of::<Option<Cursor>>(),
308 core::mem::size_of::<Option<Ripple>>(),
309 core::mem::size_of::<Option<LayoutBuilderFn<Msg>>>(),
310 core::mem::size_of::<Option<f32>>(),
311 core::mem::size_of::<Vec<FilterOp>>(),
312 core::mem::size_of::<Option<BlendMode>>(),
313 core::mem::size_of::<Option<u64>>(),
314 core::mem::size_of::<Option<MemoNode<Msg>>>(),
315 core::mem::size_of::<Option<()>>(),
316 ]
317}
318
319/// Bit `k` prendido = el nodo usa la prop `NOMBRES_RARE[k]`.
320pub fn mascara_rare<Msg>(r: &ViewRare<Msg>) -> u64 {
321 let mut m = 0u64;
322 if r.intrinsic.is_some() { m |= 1 << 0; }
323 if r.corner_radii.is_some() { m |= 1 << 1; }
324 if r.shadow.is_some() { m |= 1 << 2; }
325 if r.fill_gradient.is_some() { m |= 1 << 3; }
326 if r.border.is_some() { m |= 1 << 4; }
327 if r.image.is_some() { m |= 1 << 5; }
328 if r.image_fit.is_some() { m |= 1 << 6; }
329 if r.mask_image.is_some() { m |= 1 << 7; }
330 if r.mask_placement.is_some() { m |= 1 << 8; }
331 if !r.mask_extra.is_empty() { m |= 1 << 9; }
332 if r.gpu_painter.is_some() { m |= 1 << 10; }
333 if r.over_painter.is_some() { m |= 1 << 11; }
334 if r.on_click_at.is_some() { m |= 1 << 12; }
335 if r.on_click_screen.is_some() { m |= 1 << 13; }
336 if r.on_right_click.is_some() { m |= 1 << 14; }
337 if r.on_right_click_at.is_some() { m |= 1 << 15; }
338 if r.on_right_click_screen.is_some() { m |= 1 << 16; }
339 if r.on_middle_click.is_some() { m |= 1 << 17; }
340 if r.drag.is_some() { m |= 1 << 18; }
341 if r.drag_at.is_some() { m |= 1 << 19; }
342 if r.drag_velocity.is_some() { m |= 1 << 20; }
343 if r.drag_payload.is_some() { m |= 1 << 21; }
344 if r.on_drop.is_some() { m |= 1 << 22; }
345 if r.drop_hover_fill.is_some() { m |= 1 << 23; }
346 if r.clip_inset.is_some() { m |= 1 << 24; }
347 if r.clip_ellipse.is_some() { m |= 1 << 25; }
348 if r.clip_polygon.is_some() { m |= 1 << 26; }
349 if r.clip_path_svg.is_some() { m |= 1 << 27; }
350 if r.clip_ref_inset.is_some() { m |= 1 << 28; }
351 if r.on_pointer_enter.is_some() { m |= 1 << 29; }
352 if r.on_pointer_leave.is_some() { m |= 1 << 30; }
353 if r.on_pointer_move_at.is_some() { m |= 1 << 31; }
354 if r.on_scroll.is_some() { m |= 1 << 32; }
355 if r.on_scroll_take.is_some() { m |= 1 << 33; }
356 if r.on_scale.is_some() { m |= 1 << 34; }
357 if r.on_rotate.is_some() { m |= 1 << 35; }
358 if r.on_double_tap.is_some() { m |= 1 << 36; }
359 if r.on_double_tap_at.is_some() { m |= 1 << 37; }
360 if r.on_long_press.is_some() { m |= 1 << 38; }
361 if r.on_long_press_at.is_some() { m |= 1 << 39; }
362 if r.focusable.is_some() { m |= 1 << 40; }
363 if r.text_select_key.is_some() { m |= 1 << 41; }
364 if r.anim.is_some() { m |= 1 << 42; }
365 if r.animated_size.is_some() { m |= 1 << 43; }
366 if r.hero.is_some() { m |= 1 << 44; }
367 if r.transform.is_some() { m |= 1 << 45; }
368 if r.transform_rel.is_some() { m |= 1 << 46; }
369 if r.transform_origin.is_some() { m |= 1 << 47; }
370 if r.sticky.is_some() { m |= 1 << 48; }
371 if r.tooltip.is_some() { m |= 1 << 49; }
372 if r.cursor.is_some() { m |= 1 << 50; }
373 if r.ripple.is_some() { m |= 1 << 51; }
374 if r.layout_builder.is_some() { m |= 1 << 52; }
375 if r.backdrop_blur.is_some() { m |= 1 << 53; }
376 if !r.filter.is_empty() { m |= 1 << 54; }
377 if r.blend.is_some() { m |= 1 << 55; }
378 if r.repaint_boundary.is_some() { m |= 1 << 56; }
379 if r.memo.is_some() { m |= 1 << 57; }
380 if r.double_tap_exclusive.is_some() { m |= 1 << 58; }
381 m
382}
383
384/// Una máscara por nodo **con caja** (ver [`mascara_rare`]). Es el dato crudo
385/// del que salen todos los censos: marginales por campo, y —lo que de verdad
386/// decide— cuántos nodos dejarían de pagar la caja si tal conjunto de props
387/// volviera a vivir inline en `View`.
388pub fn mascaras_rare<Msg>(v: &View<Msg>) -> Vec<u64> {
389 let mut out = Vec::new();
390 mascaras_rec(v, &mut out);
391 out
392}
393
394fn mascaras_rec<Msg>(v: &View<Msg>, out: &mut Vec<u64>) {
395 if let Some(r) = v.rare.as_ref() {
396 out.push(mascara_rare(r));
397 }
398 for h in &v.children {
399 mascaras_rec(h, out);
400 }
401}
402
403/// Censo **por campo** (marginales), derivado de [`mascaras_rare`].
404pub fn censo_campos<Msg>(v: &View<Msg>) -> Vec<(&'static str, usize)> {
405 let ms = mascaras_rare(v);
406 let mut cuenta = [0usize; 58];
407 for m in &ms {
408 for (k, c) in cuenta.iter_mut().enumerate() {
409 if m & (1 << k) != 0 { *c += 1; }
410 }
411 }
412 let mut out: Vec<(&'static str, usize)> = NOMBRES_RARE
413 .iter()
414 .zip(cuenta.iter())
415 .filter(|(_, &c)| c > 0)
416 .map(|(n, &c)| (*n, c))
417 .collect();
418 out.sort_by(|a, b| b.1.cmp(&a.1));
419 out
420}
421/// Lee una prop **rara** de un [`View`] (ver [`ViewRare`]) devolviendo una copia,
422/// o su default si el nodo nunca asignó la caja.
423///
424/// `raro!(v, clip_inset)` dice exactamente lo que decía `v.clip_inset` antes de
425/// que las props raras se mudaran a [`ViewRare`]. Es para **inspeccionar** un
426/// árbol —tests de widgets, sobre todo—; para escribir están los builders de
427/// siempre, que no cambiaron.
428///
429/// Sólo aplica a `View`: [`MountedNode`] conserva los campos planos y se lee
430/// como siempre.
431///
432/// ```ignore
433/// assert!(raro!(vista.children[0], backdrop_blur).is_none());
434/// ```
435#[macro_export]
436macro_rules! raro {
437 ($v:expr, $campo:ident) => {
438 $v.rare
439 .as_ref()
440 .map_or_else(::core::default::Default::default, |r| r.$campo.clone())
441 };
442}
443
444mod anim;
445mod hero;
446mod layout_builder;
447mod render;
448mod ripple;
449mod semantics;
450mod sugerencia;
451mod view;
452pub use anim::{
453 ease_out_cubic, reconcile_size_anim, Anim, AnimRegistry, SizeAnim, SizeAnimRegistry,
454 SwitchStyle,
455};
456pub use hero::{Hero, HeroRegistry};
457pub use layout_builder::{collect_builder_constraints, expand_layout_builders, has_layout_builder};
458pub use render::*;
459pub use ripple::{Ripple, RippleRegistry};
460pub use semantics::{Role, SemanticsFlags, SemanticsSpec};
461pub use sugerencia::{describir, DetectorBoundaries, SugerenciaBoundary};
462
463/// Texto a pintar dentro de un nodo. Alineación por defecto `Center`
464/// (horizontal y vertical), apta para labels de botón. Para layouts tipo
465/// editor o párrafo, usar `.text_aligned(...)` con `Alignment::Start`.
466#[derive(Clone)]
467pub struct TextSpec {
468 pub content: String,
469 pub size_px: f32,
470 pub color: Color,
471 pub alignment: llimphi_text::Alignment,
472 /// `true` = forzar variante italic en la fuente activa. Default false.
473 pub italic: bool,
474 /// Peso de fuente CSS: 400 = normal, 700 = bold. parley elige la
475 /// variante más cercana de la familia activa (o la sintetiza). Se usa
476 /// tanto al **medir** como al **pintar**, así medida y dibujo coinciden.
477 /// Default 400.
478 pub weight: f32,
479 /// Límite de líneas (CSS `-webkit-line-clamp` / Flutter `maxLines`). `None`
480 /// = sin límite (envuelve libre). Cuando el texto excede, se trunca: con
481 /// [`Self::ellipsis`] la última línea termina en `…`, sin él se corta seco.
482 /// Afecta medida (taffy reserva el alto de N líneas) y pintado.
483 pub max_lines: Option<usize>,
484 /// Si `true` y `max_lines` trunca, la última línea visible termina en `…`.
485 /// Sin efecto si `max_lines` es `None`. Default false.
486 pub ellipsis: bool,
487 /// CSS-style font-family string (acepta lista con fallbacks). `None`
488 /// = la fuente default de parley.
489 pub font_family: Option<String>,
490 /// Múltiplo de interlínea (`line-height` / `font-size`). 1.2 es el
491 /// default que usaban todos los callers; puriy lo sobreescribe con el
492 /// valor computado de CSS. Se usa tanto al **medir** (para que taffy
493 /// reserve el alto correcto) como al **pintar**, así medida y dibujo
494 /// coinciden.
495 pub line_height: f32,
496 /// Colores por rango de **bytes** sobre `content`, para texto multicolor
497 /// (syntax highlighting) en una sola pasada de shaping. `None` = color
498 /// uniforme (`color`). Cuando es `Some`, el runtime usa
499 /// `Typesetter::layout_runs` + `draw_layout_runs`, y `color` actúa como
500 /// color por defecto de lo no cubierto por ningún run.
501 pub runs: Option<Vec<(usize, usize, Color)>>,
502 /// Subrayado activo. El runtime pinta la línea bajo la línea base usando
503 /// las métricas (`underline_offset`, `underline_size`) que parley deriva
504 /// de la fuente — así un texto a 12pt y otro a 24pt tienen un subrayado
505 /// proporcional sin que el caller calcule nada.
506 pub underline: bool,
507 /// Tachado activo. Mismo régimen que [`Self::underline`] pero sobre el
508 /// strikethrough metric — útil para listas to-do, items removidos en un
509 /// diff, precios viejos.
510 pub strikethrough: bool,
511 /// **Spans inline mixtos** (RichText): overrides de
512 /// tamaño/peso/italic/familia/color/underline/strikethrough por rango
513 /// de bytes (parley convention). `None` = texto uniforme (camino
514 /// `layout_clamped`); `Some([])` se trata como `None`. Cuando hay
515 /// spans, el runtime usa `Typesetter::layout_spans` (Layout<RunBrush>
516 /// con `max_width`/wrap) + `draw_layout_runs_xf`; los campos del
517 /// `TextSpec` son **defaults a nivel bloque** que cada span puede
518 /// sobreescribir. Tier 2 final de PARIDAD-FLUTTER (Bloque 13).
519 pub spans: Option<Vec<llimphi_text::TextSpan>>,
520 /// `letter-spacing`: px **extra** entre letras (CSS). 0 = normal. Afecta
521 /// shaping y medida. Sólo el camino uniforme (`layout_clamped`); el camino
522 /// de spans (RichText) lo ignora en v1.
523 pub letter_spacing: f32,
524 /// `word-spacing`: px **extra** entre palabras (CSS). 0 = normal. Mismo
525 /// régimen que [`Self::letter_spacing`].
526 pub word_spacing: f32,
527 /// `white-space: nowrap`/`pre`: si `true`, el texto **no envuelve** —
528 /// se shapea en una sola línea (`break_all_lines(None)`) sin importar el
529 /// ancho disponible, y desborda la caja (lo recorta `overflow: hidden` si
530 /// lo hay). Afecta medida (taffy reserva el ancho de la línea completa) y
531 /// pintado. Default false (wrap libre, comportamiento previo). Sólo el
532 /// camino uniforme (`layout_clamped`); el de spans (RichText) lo ignora en
533 /// v1, igual que el clamp.
534 pub no_wrap: bool,
535 /// `overflow-wrap: break-word`/`anywhere` (o `word-break: break-all`): si
536 /// `true`, una palabra más ancha que la caja se **parte** para que entre,
537 /// en vez de desbordar. Afecta medida (taffy puede reservar menos ancho) y
538 /// pintado. Default false (la palabra larga desborda — comportamiento
539 /// previo). Sólo el camino uniforme (`layout_clamped`); el de spans
540 /// (RichText) lo ignora en v1, igual que `no_wrap`/clamp.
541 pub overflow_wrap: bool,
542 /// `font-feature-settings` (+ `font-kerning` plegado como `kern`) en formato
543 /// CSS crudo (`"liga" 1, "kern" 0`). Vacío = default de la fuente. Afecta
544 /// shaping y medida (ligaduras/kerning cambian el ancho). Sólo el camino
545 /// uniforme (`layout_clamped`); el de spans (RichText) lo ignora en v1.
546 pub font_features: String,
547 /// `font-variation-settings` en formato CSS crudo (`"wght" 700`). Vacío =
548 /// ejes en su default. Mismo régimen que [`Self::font_features`].
549 pub font_variations: String,
550 /// `font-stretch`/`font-width` como **porcentaje** (100 = normal, <100
551 /// condensada, >100 expandida). Afecta shaping y medida (la face
552 /// condensada/expandida cambia el ancho). Sólo el camino uniforme
553 /// (`layout_clamped`); el de spans (RichText) lo ignora en v1.
554 pub font_width: f32,
555}
556
557/// Fase de un drag activo. `Move` se emite por cada `CursorMoved` con el
558/// delta desde el evento anterior; `End` se emite al soltar el botón.
559#[derive(Debug, Clone, Copy, PartialEq, Eq)]
560pub enum DragPhase {
561 Move,
562 End,
563}
564
565/// Handler de drag. Recibe la fase + delta (`dx`, `dy`) **desde el evento
566/// anterior** (no acumulado desde el press). Devolver `None` deja el drag
567/// activo sin disparar Msg. `Arc<dyn Fn>` para que el runtime pueda
568/// clonarlo barato al iniciar el drag y mantenerlo vivo aunque el cache
569/// de la vista se regenere mientras tanto.
570pub type DragFn<Msg> = Arc<dyn Fn(DragPhase, f32, f32) -> Option<Msg> + Send + Sync>;
571
572/// Handler de drop. El runtime lo invoca cuando un drag activo se suelta
573/// sobre este nodo. Recibe el `payload` `u64` que el origen del drag
574/// declaró vía [`View::drag_payload`]. Devolver `None` ignora el drop.
575///
576/// Los IDs `u64` son opacos para el runtime: el widget elige una
577/// convención (índice de tile, hash del item, etc.) y el handler decide
578/// qué Msg emitir en función de ese ID.
579pub type DropFn<Msg> = Arc<dyn Fn(u64) -> Option<Msg> + Send + Sync>;
580
581/// Handler de click con posición. Recibe `(x_local, y_local, rect_w,
582/// rect_h)`: las dos primeras son la posición del cursor **relativa a
583/// la esquina superior-izquierda del nodo** y las dos últimas son el
584/// ancho/alto actual del nodo en pixels — útil cuando el caller
585/// necesita centrar o normalizar. Devolver `None` no dispara update.
586pub type ClickAtFn<Msg> = Arc<dyn Fn(f32, f32, f32, f32) -> Option<Msg> + Send + Sync>;
587
588/// Handler de rueda **local a un nodo**. Recibe el delta `(dx, dy)` en
589/// líneas lógicas (misma normalización que `App::on_wheel`: `dy` positivo
590/// = scroll hacia abajo). El runtime lo invoca cuando la rueda gira con el
591/// cursor sobre este nodo, ANTES de caer al `App::on_wheel` global: si el
592/// handler devuelve `Some(Msg)`, el evento se consume aquí. Permite áreas
593/// de scroll autocontenidas (el widget `scroll` lo usa) sin que cada app
594/// rutee la rueda a mano por su `Model`. Devolver `None` deja pasar el
595/// evento al `on_wheel` global.
596pub type ScrollFn<Msg> = Arc<dyn Fn(f32, f32) -> Option<Msg> + Send + Sync>;
597
598/// Handler de rueda con **reparto parcial** (scroll anidado real): recibe el
599/// delta `(dx, dy)` en líneas y devuelve `(msg, rest_x, rest_y)` — el `Msg`
600/// por lo que consumió (o `None` si no consumió nada) y el **sobrante** en la
601/// misma unidad, que el runtime sigue repartiendo al siguiente scrollable de
602/// la cadena (el ancestro). Un mismo evento puede así mover al hijo hasta su
603/// tope Y al padre con el resto, en el mismo frame. Ver
604/// [`View::on_scroll_take`] y [`consume_scroll_chain`].
605pub type ScrollTakeFn<Msg> = Arc<dyn Fn(f32, f32) -> (Option<Msg>, f32, f32) + Send + Sync>;
606
607/// Variante de [`DragFn`] que **conoce la posición inicial del press**
608/// relativa al rect del nodo. Útil cuando el caller necesita identificar
609/// qué entidad (Concepto, lemming, etc.) bajo el cursor agarró el drag.
610/// Recibe `(phase, dx, dy, initial_lx, initial_ly)`.
611pub type DragAtFn<Msg> = Arc<dyn Fn(DragPhase, f32, f32, f32, f32) -> Option<Msg> + Send + Sync>;
612
613/// Variante de [`DragFn`] que recibe la **velocidad del drag al soltarlo**
614/// (`vx`, `vy` en px/s). El runtime mide el desplazamiento sobre los
615/// últimos ~100 ms de movimiento (ventana móvil de hasta ocho samples)
616/// y la pasa en `DragPhase::End`. Durante `DragPhase::Move` ambas son
617/// `0.0` — la velocidad sólo es significativa al final. Permite
618/// **fling-desde-drag**: el caller arranca un ticker con esa velocidad y
619/// la decae con [`fling_step`](https://docs.rs/) hasta asentar. Reemplaza
620/// la estimación manual que antes tenía que llevar el caller con
621/// `Instant::now()` por su cuenta.
622pub type DragVelocityFn<Msg> =
623 Arc<dyn Fn(DragPhase, f32, f32, f32, f32) -> Option<Msg> + Send + Sync>;
624
625/// Fase de un **gesto continuo** (pinch-to-zoom de momento; rotación a futuro).
626/// El runtime emite `Begin` al iniciar el gesto, `Update` por cada cambio
627/// incremental y `End` al terminar. El camino de Ctrl+rueda (universal, sin
628/// trackpad) emite un único `Update` por click de rueda — no hay un "inicio"
629/// ni "fin" naturales, así que el handler debe tolerar `Update`s sueltos sin
630/// `Begin` previo (es lo común en desktop). El camino de trackpad
631/// (`PinchGesture`, sólo macOS/iOS) sí entrega `Begin`/`Update*`/`End`.
632#[derive(Debug, Clone, Copy, PartialEq, Eq)]
633pub enum GesturePhase {
634 Begin,
635 Update,
636 End,
637}
638
639/// Handler de gesto de **escala** (pinch-to-zoom). Recibe `(phase, factor,
640/// focal_x, focal_y)`:
641/// - `factor`: cambio de escala **incremental y multiplicativo** desde el
642/// evento anterior — `1.0` = sin cambio, `>1.0` agranda (zoom in), `<1.0`
643/// achica (zoom out). El caller acumula con `mi_zoom *= factor` y, si
644/// quiere, lo clampa a su rango. En `Begin`/`End` el factor es `1.0`.
645/// - `focal_x`/`focal_y`: punto focal del gesto **relativo a la esquina
646/// superior-izquierda del rect del nodo** (mismo espacio que los handlers
647/// `*_at`). Es el punto que debe quedar fijo bajo el cursor al hacer zoom —
648/// el caller lo usa para zoomear "hacia el cursor" en vez de hacia el
649/// centro. En Ctrl+rueda es la posición del cursor; en trackpad, idem.
650///
651/// Devolver `Some(Msg)` dispara una transición; `None` ignora el evento. El
652/// runtime lo resuelve con [`hit_test_scale`]: el nodo más al frente bajo el
653/// cursor que declare un `on_scale` consume el gesto. Es la base del zoom de
654/// los canvases (pineal/cosmos/nakui).
655pub type ScaleFn<Msg> = Arc<dyn Fn(GesturePhase, f32, f32, f32) -> Option<Msg> + Send + Sync>;
656
657/// Handler de gesto de **rotación** (trackpad, sólo macOS — winit no emite
658/// `RotationGesture` en Wayland/Windows). Análogo a [`ScaleFn`] pero el
659/// segundo argumento es el **delta de ángulo incremental en radianes**
660/// (positivo = horario) en lugar del factor de escala; `(focal_x, focal_y)`
661/// es el punto bajo el cursor relativo al rect del nodo. El nodo más al
662/// frente bajo el cursor que declare un `on_rotate` consume el gesto. Base
663/// para rotar canvases/imágenes con dos dedos. Ver [`View::on_rotate`].
664pub type RotateFn<Msg> = Arc<dyn Fn(GesturePhase, f32, f32, f32) -> Option<Msg> + Send + Sync>;
665
666/// Restricciones de tamaño que un [`LayoutBuilderFn`] recibe: las dimensiones
667/// del slot que el layout le asignó al nodo (en px físicos). Análogo a las
668/// `BoxConstraints` de Flutter `LayoutBuilder` / al `MediaQuery` pero **local
669/// al nodo** (no a la ventana). El builder construye su subárbol en función de
670/// esto — p. ej. una columna si `max_width < 600`, dos si es ancho.
671#[derive(Debug, Clone, Copy, PartialEq)]
672pub struct Constraints {
673 pub max_width: f32,
674 pub max_height: f32,
675}
676
677/// Constructor **diferido** de subárbol sensible al tamaño (Flutter
678/// `LayoutBuilder`). El runtime resuelve el tamaño del slot del nodo en una
679/// primera pasada de layout y luego invoca esta closure con esas
680/// [`Constraints`] para producir los hijos — así "construir distinto según el
681/// espacio disponible" deja de exigir conocer el tamaño al armar el `View`. Ver
682/// [`View::layout_builder`].
683pub type LayoutBuilderFn<Msg> = Arc<dyn Fn(Constraints) -> View<Msg> + Send + Sync>;
684
685/// Constructor **diferido** del contenido de un [`View::memo`] (Bloque 25).
686/// Produce el subárbol (un único `View`) que va DENTRO del nodo memo. El runtime
687/// lo llama sólo cuando `deps` (o el tamaño del slot) cambió; si no, reusa el
688/// `Mounted` cacheado sin reconstruir el `View`.
689pub type MemoBuilderFn<Msg> = Arc<dyn Fn() -> View<Msg> + Send + Sync>;
690
691/// Nodo **memoizado** (Bloque 25 de `PLAN-NUCLEO-RETENIDO.md`): un subárbol
692/// cuyo `View` NO se reconstruye —ni se re-monta ni se re-layoutea— si sus
693/// `deps` no cambiaron. El nodo memo lleva un `Style` con **tamaño definido**
694/// (length/percent, no auto): el runtime lo monta como hoja de ese tamaño,
695/// computa el subárbol en un `LayoutTree` aislado (que taffy cachea) y splica
696/// su `Mounted` cacheado. `builder` = `Some` mientras está sin resolver;
697/// `resolve_memos` lo extrae y el nodo queda como marcador. Ver [`View::memo`].
698pub struct MemoNode<Msg> {
699 pub key: u64,
700 pub deps: u64,
701 pub builder: Option<MemoBuilderFn<Msg>>,
702}
703
704/// Rect absoluto del nodo (en coordenadas físicas del frame). Lo
705/// recibe el callback de [`View::paint_with`] para que pueda
706/// posicionar sus primitivas custom dentro del nodo.
707#[derive(Debug, Clone, Copy, Default)]
708pub struct PaintRect {
709 pub x: f32,
710 pub y: f32,
711 pub w: f32,
712 pub h: f32,
713}
714
715/// Callback de pintura custom. El runtime lo invoca durante el paint
716/// del nodo (entre el `fill`/`image` y el `text`) con el `Scene` vivo
717/// + el `Typesetter` cacheado del runtime + el rect absoluto del nodo.
718/// Pensado para "canvas elements" tipo `dominium-canvas`,
719/// `pluma-editor` (osciloscopio de coherencia), `cosmos` (charts).
720///
721/// El `Typesetter` se pasa porque crearlo por frame es caro
722/// (`FontContext::new` enumera las fontes del sistema vía fontique).
723/// Los callers que no necesiten texto pueden ignorar el argumento.
724///
725/// El callback no debe llamar a `scene.push_layer` sin un `pop_layer`
726/// correspondiente, ni reset el scene — sólo agregar primitivas que
727/// pertenezcan al rect del nodo.
728pub type PaintFn = Arc<
729 dyn Fn(&mut Lienzo, &mut llimphi_text::Typesetter, PaintRect) + Send + Sync,
730>;
731
732/// Callback de pintura GPU directo, sin vello intermedio. Recibe el
733/// `device`/`queue` ya construidos por el runtime más un
734/// `CommandEncoder` y la `TextureView` del frame (la intermediate
735/// `Rgba8Unorm` de `WinitSurface`), todo durante el paint del nodo.
736///
737/// El caller abre su propio `begin_render_pass` con `LoadOp::Load` para
738/// no sobrescribir lo que ya pintó vello, dibuja sus primitivas y
739/// cierra el pass. El runtime se encarga de dispatchear (`queue.submit`)
740/// el encoder ya con todas las pasadas de todos los nodos acumuladas —
741/// es un solo submit por frame.
742///
743/// **Orden de pintura en Fase 1**: todos los `gpu_painter` corren
744/// DESPUÉS de la pasada completa de vello (fill, image, painter,
745/// text) sobre el `mounted` tree. Entre sí mantienen el orden DFS
746/// pre-orden. Si una app necesita pintar texto **encima** del render
747/// GPU directo, la forma idiomática es ponerlo en `App::view_overlay`,
748/// que se renderiza como una segunda Scene de vello encima de todo.
749///
750/// Pensado para apps con volumen masivo de primitivos (cosmos
751/// starfield Gaia, tinkuy particle viewer, nakui viewport, pineal
752/// denso) — el hook que paga el costo de mantener pipelines WGSL
753/// propias en `llimphi-raster` (ver `02_ruway/llimphi/SDD.md`
754/// §"Roadmap — GPU directo wgpu").
755#[cfg(feature = "gpu")]
756pub type GpuPaintFn = Arc<
757 dyn Fn(
758 &wgpu::Device,
759 &wgpu::Queue,
760 &mut wgpu::CommandEncoder,
761 &wgpu::TextureView,
762 PaintRect,
763 (u32, u32),
764 ) + Send
765 + Sync,
766>;
767
768/// Sin la feature `gpu` no hay `wgpu`, y por lo tanto no hay pintor GPU
769/// directo — pero el TIPO tiene que seguir existiendo.
770///
771/// Es una decisión de diff, no de diseño: el campo `gpu_painter` aparece en dos
772/// structs y se mueve por nombre corto en dos literales dentro de un crate de
773/// 10.000 líneas. Ponerle `#[cfg]` a cada uno de esos sitios sería revolver el
774/// núcleo del compositor para nada. Cambiando sólo la FORMA del alias, todo ese
775/// cuerpo queda intacto y el campo simplemente nunca se puebla: el único
776/// constructor —[`View::gpu_paint_with`]— tampoco existe sin la feature.
777#[cfg(not(feature = "gpu"))]
778pub type GpuPaintFn = Arc<dyn Fn(PaintRect, (u32, u32)) + Send + Sync>;
779
780/// Callback de pintura vello "over": idéntico en firma a [`PaintFn`]
781/// `(&mut Scene, &mut Typesetter, PaintRect)`, pero el runtime lo invoca
782/// en una pasada vello FINAL, **después** de todos los `gpu_painter` del
783/// frame. Sus primitivas se rasterizan sobre fondo transparente y se
784/// componen con alpha encima de la intermedia (que ya tiene
785/// vello-base + GPU directo). Resuelve el z-order inverso al de
786/// [`GpuPaintFn`]: permite pintar texto/sprites AA por vello **encima**
787/// de celdas instanciadas por GPU (dominium grid, futuro motor voxel).
788///
789/// Orden total del frame: `[vello base] → [gpu_painter] → [over_painter]
790/// → [overlay/menús]`. Los menús (`view_overlay`) siguen quedando por
791/// encima del over-layer. Ver [`View::paint_over`]. Es un alias de
792/// [`PaintFn`]; existe sólo para documentar la semántica temporal.
793pub type OverPaintFn = PaintFn;
794
795/// Sombra proyectada detrás del rect del nodo (drop shadow), rasterizada
796/// con el `draw_blurred_rounded_rect` nativo de vello. Se pinta **antes**
797/// del relleno, así el fill (si es opaco) tapa la parte solapada y la
798/// sombra sólo asoma por el desenfoque + el offset. El radio sigue al del
799/// nodo (más `spread`).
800#[derive(Clone, Copy, Debug, PartialEq)]
801pub struct Shadow {
802 pub color: Color,
803 /// Desviación estándar del gaussiano (qué tan difusa). En px.
804 pub blur: f64,
805 /// Desplazamiento de la sombra respecto del nodo.
806 pub dx: f64,
807 pub dy: f64,
808 /// Cuánto crece (px) el rect de la sombra respecto del nodo.
809 pub spread: f64,
810}
811
812impl Shadow {
813 /// Sombra con color + blur explícitos, sin offset ni spread.
814 pub fn new(color: Color, blur: f64) -> Self {
815 Self { color, blur, dx: 0.0, dy: 0.0, spread: 0.0 }
816 }
817
818 /// Elevación suave y tasteful: negro translúcido, leve caída hacia
819 /// abajo. El default razonable para cards/menús/modales.
820 pub fn soft(alpha: u8, blur: f64) -> Self {
821 Self {
822 color: Color::from_rgba8(0, 0, 0, alpha),
823 blur,
824 dx: 0.0,
825 dy: blur * 0.4,
826 spread: 0.0,
827 }
828 }
829
830 pub fn offset(mut self, dx: f64, dy: f64) -> Self {
831 self.dx = dx;
832 self.dy = dy;
833 self
834 }
835
836 pub fn spread(mut self, spread: f64) -> Self {
837 self.spread = spread;
838 self
839 }
840}
841
842/// Borde (stroke) pintado sobre el contorno redondeado del nodo, **inset**
843/// hacia adentro media línea para que el grosor quede dentro del rect
844/// (convención CSS `box-sizing: border-box`). Se pinta después del relleno.
845#[derive(Clone, Copy, Debug)]
846pub struct Border {
847 pub width: f64,
848 pub color: Color,
849}
850
851impl Border {
852 pub fn new(width: f64, color: Color) -> Self {
853 Self { width, color }
854 }
855}
856
857/// Una operación de filtro CSS (`filter: blur()/brightness()/…`) aplicada al
858/// **propio subárbol** del nodo. A diferencia de `backdrop_blur` (que afecta lo
859/// pintado *debajo*), un `FilterOp` modifica el contenido del nodo. El runtime
860/// los aplica como post-pasada GPU sobre la intermediate, restringidos al rect
861/// del nodo, en el orden de la lista. La lista crece por fase (CSS Filter
862/// Effects 1): `Blur` (7.1232) + `ColorMatrix` (7.1233). Fase 7.1232.
863#[derive(Clone, Debug, PartialEq)]
864pub enum FilterOp {
865 /// `filter: blur(<px>)`. `px` es la desviación estándar del Gauss (igual
866 /// convención que CSS). Se aplica con `BlurCompositor`, el mismo camino que
867 /// `backdrop_blur`.
868 Blur(f32),
869 /// Filtros de color (`brightness`/`contrast`/`grayscale`/`sepia`/`saturate`/
870 /// `invert`/`hue-rotate`/`opacity`) colapsados a una **matriz de color 4×5**
871 /// row-major: por fila `[c0, c1, c2, c3, bias]`, salida R/G/B/A
872 /// (`out = M·rgba + bias`). Se aplica con `ColorFilterCompositor`. Fase
873 /// 7.1233.
874 ColorMatrix([f32; 20]),
875 /// `filter: drop-shadow(<ox> <oy> [blur] [color])`. Se pinta como una sombra
876 /// Gaussiana del **border-box** detrás del nodo (con `draw_blurred_rounded_rect`,
877 /// igual primitiva que `Shadow`/box-shadow). v1: sombra del rect, no de la
878 /// silueta alpha del subárbol. A diferencia de `Blur`/`ColorMatrix`, NO es
879 /// post-pasada GPU — se pinta en vello antes del relleno, por lo que
880 /// `collect_filters` la ignora. Fase 7.1234.
881 DropShadow(Shadow),
882}
883
884/// Punto de pivote de `transform` (CSS `transform-origin`). Cada eje se resuelve
885/// contra el rect del nodo como `px + frac · tamaño`: `px` (ya escalado por zoom
886/// por el caller) cubre offsets absolutos y `frac` los porcentuales (`0.5` = 50%
887/// del ancho/alto). El default CSS `50% 50%` (centro) es
888/// `{ px: (0.0, 0.0), frac: (0.5, 0.5) }`; un nodo con `transform_origin: None`
889/// usa ese centro. Modela `px + %` por eje igual que `transform_rel` modela el
890/// `translate(<%>)` — necesario porque el % depende del layout, desconocido hasta
891/// `paint`.
892#[derive(Debug, Clone, Copy, PartialEq)]
893pub struct TransformPivot {
894 /// Offset absoluto en px (ya × zoom) por eje `(x, y)`.
895 pub px: (f64, f64),
896 /// Fracción del tamaño del rect por eje `(x, y)` (`0.5` = 50%).
897 pub frac: (f64, f64),
898}
899
900impl Default for TransformPivot {
901 fn default() -> Self {
902 // CSS `transform-origin: 50% 50%` — centro del rect.
903 Self { px: (0.0, 0.0), frac: (0.5, 0.5) }
904 }
905}
906
907/// Nodo de la vista declarativa. Estilo de layout (taffy) + relleno opcional
908/// (vello) + texto opcional (skrifa+vello) + Msg al click opcional + hijos.
909pub struct View<Msg> {
910 pub style: Style,
911 pub fill: Option<Color>,
912 /// Relleno cuando el cursor está sobre este nodo. Sin valor (`None`)
913 /// = no se reacciona al hover.
914 pub hover_fill: Option<Color>,
915 pub radius: f64,
916 /// **Subárbol over** (ver [`View::over`]): este nodo y todos sus
917 /// descendientes se pintan en la pasada vello FINAL, después del pase
918 /// GPU directo — con toda la maquinaria normal (fills, texto, imágenes,
919 /// painters, hover). Es el primitivo para UI **encima** de contenido
920 /// `gpu_paint_with` (OSC de un reproductor, HUD sobre un canvas GPU).
921 /// El hit-test no cambia (usa el layout, no la pasada de pintura).
922 /// `false` = pinta en la pasada base, como siempre (coste cero).
923 pub over_layer: bool,
924 pub on_click: Option<Msg>,
925 /// Si `true`, los descendientes se recortan al rect del nodo (vía
926 /// `scene.push_layer` con `Mix::Clip`). El hit-test también respeta
927 /// el recorte: clicks fuera del rect ignoran a los hijos.
928 pub clip: bool,
929 pub children: Vec<View<Msg>>,
930 pub text: Option<TextSpec>,
931 /// Callback de pintura custom. Si está presente, el runtime lo
932 /// invoca durante el paint del nodo con el `Scene` vivo + el rect
933 /// absoluto. Pensado para "canvas elements" (dominium, pluma,
934 /// cosmos) que pintan primitivas custom no expresables como una
935 /// composición de Views.
936 pub painter: Option<PaintFn>,
937 /// Opacidad multiplicada sobre TODO el subtree (este nodo + hijos),
938 /// en `[0.0, 1.0]`. Se realiza con `scene.push_layer(Mix::Normal, a, …)`
939 /// alrededor del rect del nodo: el subárbol se rasteriza en una capa
940 /// intermedia y se compone al alfa indicado contra lo que ya hay
941 /// detrás. `None` = sin capa (caso de la abrumadora mayoría de
942 /// nodos). Útil para fade-in/out de overlays, ghosts mientras se
943 /// arrastra, modales que aparecen, panels "vidrio". Note que la
944 /// composición tiene costo (allocate + blit), por lo que sólo
945 /// poblar este slot cuando hace falta — no es un atributo gratis.
946 pub alpha: Option<f32>,
947 /// **Semántica accesible** del nodo (rol, label, value, flags ARIA). El
948 /// runtime la traduce a un árbol AccessKit por frame para alimentar
949 /// lectores de pantalla (NVDA/VoiceOver/Orca/TalkBack). `None` = no
950 /// declarada (el lector lee el texto plano si lo hay, sin rol específico).
951 /// Ver [`SemanticsSpec`].
952 pub semantics: Option<SemanticsSpec>,
953 /// Props raras, boxeadas aparte (ver [`ViewRare`]). `None` —el caso
954 /// normal— son 8 B; sólo el nodo que usa alguna paga la asignación.
955 pub rare: Option<Box<ViewRare<Msg>>>,
956}
957
958/// Props **raras** de un [`View`]: las que lleva una minoría de los nodos de
959/// cualquier árbol real (animaciones, máscaras, clips exóticos, la docena de
960/// handlers de gesto, semántica de accesibilidad…).
961///
962/// Viven acá y no en `View` porque `View` se asigna **una vez por nodo y por
963/// frame**, y el perfilador de asignaciones (Bloque 21) mostró que a 200k nodos
964/// esa sola struct era el 90 % del heap del frame — 484 MB, `size_of::<View>()`
965/// × nodos, clavado. Cada campo raro que vivía inline se cobraba en los 200.000
966/// nodos aunque lo usaran diez. Acá se cobra un puntero (8 B) en el que no lo
967/// usa, y una asignación en el que sí.
968///
969/// Es el mismo reparto que hacen Blink (`RareInheritedData`) y Servo por la
970/// misma razón. La API pública no cambia: los builders de [`View`] escriben acá
971/// solos vía `View::raro`.
972pub struct ViewRare<Msg> {
973 /// Tamaño natural del contenido reemplazado de este nodo (ver
974 /// [`IntrinsicSize`]). Lo pone [`View::intrinsic`]; sólo se registra para
975 /// medir si el nodo es HOJA.
976 pub intrinsic: Option<IntrinsicSize>,
977 /// Radio **por esquina** (top-left, top-right, bottom-right, bottom-left),
978 /// que sobreescribe a `radius` cuando está presente. Permite cards con
979 /// sólo las esquinas de arriba redondeadas, pestañas, bocadillos de chat,
980 /// etc. (CSS `border-radius` con 4 valores). `None` = usar el `radius`
981 /// uniforme. Ver [`View::radius_corners`]. La **sombra** sigue usando un
982 /// radio escalar (el blur nativo de vello no acepta radios por esquina);
983 /// el **borde** sí respeta las cuatro esquinas.
984 pub corner_radii: Option<RoundedRectRadii>,
985 /// Sombra proyectada detrás del nodo (drop shadow). `None` = sin sombra
986 /// (la mayoría de nodos). Ver [`Shadow`].
987 pub shadow: Option<Shadow>,
988 /// Relleno con **gradiente**, autoreado en el cuadrado unidad `[0,1]²` y
989 /// mapeado al rect del nodo. Gana sobre `fill` como base; `hover_fill`
990 /// (un color) lo sigue overrideando en hover. Ver [`View::fill_gradient`].
991 pub fill_gradient: Option<Gradient>,
992 /// Borde (stroke) sobre el contorno redondeado. Ver [`Border`].
993 pub border: Option<Border>,
994 /// Imagen a pintar dentro del rect del nodo. Se centra y escala
995 /// según [`Self::image_fit`] (default `Contain` = preservar
996 /// aspect ratio cabiendo). El alfa por píxel de la imagen y el
997 /// `Image::alpha` global se respetan; el `fill` (si lo hay) se
998 /// pinta debajo como background. El clip al `node_rrect` respeta
999 /// `radius`/`corner_radii`, así avatares y cards con esquinas
1000 /// redondeadas funcionan sin envolver en un padre `clip(true)`.
1001 pub image: Option<Image>,
1002 /// Política de encaje de [`Self::image`] en el rect del nodo
1003 /// (CSS `object-fit`). `None` = `Contain` (el default histórico).
1004 /// Ver [`ImageFit`] y [`View::image_fit`].
1005 pub image_fit: Option<ImageFit>,
1006 /// **Máscara de luminancia** (CSS `mask-image`). Si está presente, el
1007 /// runtime aísla el subárbol del nodo en una capa y luego lo enmascara con
1008 /// la luminancia de esta imagen (`push_luminance_mask_layer` de vello):
1009 /// blanco = visible, negro = oculto, gris = semitransparente. El encaje lo
1010 /// fija [`Self::mask_placement`] (size/position/repeat); sin él la imagen se
1011 /// estira al border-box. `None` = sin máscara. Ver [`View::mask_image`].
1012 pub mask_image: Option<Image>,
1013 /// Encaje de [`Self::mask_image`] (CSS `mask-size`/`-position`/`-repeat`).
1014 /// `None` = estirar al border-box (Fase 7.1226). Sólo se consulta si
1015 /// `mask_image` está presente. Ver [`MaskPlacement`] y
1016 /// [`View::mask_placement`]. Fase 7.1227.
1017 pub mask_placement: Option<MaskPlacement>,
1018 /// Capas de máscara ADICIONALES (`mask-image: url(a), url(b), …`): cada una
1019 /// es `(imagen, operador)`. Comparten [`Self::mask_placement`] con la capa 0
1020 /// ([`Self::mask_image`]); se combinan con ella según el operador. Vacío =
1021 /// una sola capa. Ver [`View::mask_extra`]. Fase 7.1231.
1022 pub mask_extra: Vec<(Image, MaskCompose)>,
1023 /// Pintor GPU directo. Se invoca DESPUÉS de la pasada vello del
1024 /// frame; comparte tree y orden DFS con los demás. Ver
1025 /// [`GpuPaintFn`].
1026 pub gpu_painter: Option<GpuPaintFn>,
1027 /// Pintor vello "over": closure que pinta DESPUÉS del pase GPU del
1028 /// frame, sobre una escena vello que el runtime compone con alpha
1029 /// encima de la intermedia. Sirve para sprites/texto AA encima de
1030 /// celdas instanciadas por GPU. Ver [`View::paint_over`] y
1031 /// [`OverPaintFn`]. Misma firma que [`PaintFn`] — sólo cambia
1032 /// *cuándo* corre (post-GPU). `None` = sin over-layer (coste cero).
1033 pub over_painter: Option<PaintFn>,
1034 /// Handler de click que recibe la posición **relativa al rect del
1035 /// nodo** (esquina superior-izquierda del nodo = `(0, 0)`). Útil
1036 /// para canvas elements que quieren mapear el click a coordenadas
1037 /// de mundo. Si está presente, gana sobre `on_click`. Devolver
1038 /// `None` no dispara update.
1039 pub on_click_at: Option<ClickAtFn<Msg>>,
1040 /// Gemelo de izquierda de [`Self::on_right_click_screen`]: click izquierdo con
1041 /// coords **absolutas de ventana**, para anclar un popup (select/dropdown) en
1042 /// la capa `view_overlay`.
1043 pub on_click_screen: Option<ClickAtFn<Msg>>,
1044 /// Equivalente a `on_click` pero para el botón derecho del ratón.
1045 /// Pensado para menús contextuales: el nodo declara qué `Msg`
1046 /// emitir cuando se le hace right-click, y la app abre el overlay
1047 /// con el menú.
1048 pub on_right_click: Option<Msg>,
1049 /// Variante posicional de [`Self::on_right_click`]. Útil para
1050 /// grillas que necesitan saber *qué celda* del rect recibió el
1051 /// click derecho (la celda no es un nodo aparte, sino una región
1052 /// dentro del nodo). Si está presente, gana sobre `on_right_click`.
1053 pub on_right_click_at: Option<ClickAtFn<Msg>>,
1054 /// Como [`Self::on_right_click_at`] pero recibe coords **absolutas de
1055 /// ventana** (no locales al nodo). Para anclar menús contextuales en la
1056 /// posición del puntero: `on_right_click_at` (local) sirve a grillas/canvas
1057 /// que necesitan saber QUÉ región del rect se clickeó; éste sirve a popups
1058 /// que quieren la posición en pantalla. Los backends le pasan el cursor
1059 /// absoluto. Convive con `on_right_click_at` (un nodo puede tener ambos).
1060 pub on_right_click_screen: Option<ClickAtFn<Msg>>,
1061 /// Equivalente a `on_click` pero para el botón del medio del ratón
1062 /// (rueda presionada). Pensado para abrir en pestaña nueva — los
1063 /// browsers usan middle-click como atajo equivalente a Ctrl+Click.
1064 pub on_middle_click: Option<Msg>,
1065 /// Handler de drag. Si está presente, este nodo arrastra (y NO emite
1066 /// `on_click` al presionar — un nodo es uno u otro).
1067 pub drag: Option<DragFn<Msg>>,
1068 /// Variante de drag que recibe la posición inicial del press relativa
1069 /// al rect del nodo. Gana sobre `drag` si ambos están presentes.
1070 pub drag_at: Option<DragAtFn<Msg>>,
1071 /// Variante de drag que recibe la **velocidad** al soltar (`vx`, `vy`
1072 /// en px/s) además del delta puntual. Gana sobre `drag`/`drag_at`
1073 /// cuando está presente — un nodo elige un único sabor de drag. Habilita
1074 /// fling-desde-drag (el caller arranca un ticker con esa velocidad y la
1075 /// decae con [`fling_step`]).
1076 pub drag_velocity: Option<DragVelocityFn<Msg>>,
1077 /// Payload `u64` que viaja con el drag iniciado sobre este nodo. Lo
1078 /// recibe el handler [`Self::on_drop`] del drop target. Sin payload,
1079 /// el drag funciona igual pero ningún drop target reacciona.
1080 pub drag_payload: Option<u64>,
1081 /// Handler invocado al soltar un drag sobre este nodo (drop target).
1082 pub on_drop: Option<DropFn<Msg>>,
1083 /// Color a pintar mientras un drag activo está hovereando este drop
1084 /// target. Sobrepone a `fill`/`hover_fill` cuando aplica.
1085 pub drop_hover_fill: Option<Color>,
1086 /// Si `Some([top, right, bottom, left])`, recorta los descendientes a un
1087 /// rect ENCOGIDO por esos insets (px) desde el rect del nodo — modela
1088 /// `clip-path: inset(...)`. Implica clip aunque `clip == false`.
1089 pub clip_inset: Option<[f32; 4]>,
1090 /// Si `Some(spec)` (14 floats), recorta los descendientes a una ELIPSE —
1091 /// modela `clip-path: circle()`/`ellipse()`. El centro (4) se resuelve
1092 /// contra el rect: `cx = cx_px + cx_pct/100·w`, `cy = cy_px +
1093 /// cy_pct/100·h`. Cada radio (5: `[px, pct_w, pct_h, pct_diag, side]`) con
1094 /// `side == 0` suma `px + pct_w/100·w + pct_h/100·h + pct_diag/100·diag`
1095 /// (`diag = √(w²+h²)/√2`); con `side != 0` se computa desde la distancia
1096 /// del centro a los bordes (`1`/`2` = closest/farthest sobre los 4 lados;
1097 /// `3`/`4` = ídem sobre el eje del radio). Layout: `[cx×2, cy×2, rx×5,
1098 /// ry×5]`. Implica clip aunque `clip == false`. Si conviven `clip_inset` y
1099 /// `clip_ellipse`, gana la elipse (una sola capa de recorte por nodo).
1100 pub clip_ellipse: Option<[f32; 14]>,
1101 /// Si `Some((evenodd, puntos))`, recorta los descendientes a un POLÍGONO —
1102 /// modela `clip-path: polygon()`. Cada punto `[x_px, x_pct, y_px, y_pct]`
1103 /// resuelve `(x_px + x_pct/100·w, y_px + y_pct/100·h)` contra el rect.
1104 /// `evenodd` elige la regla de relleno. Implica clip aunque `clip ==
1105 /// false`. Prioridad de recorte por nodo: polygon > elipse > inset > rect.
1106 pub clip_polygon: Option<(bool, Vec<[f32; 4]>)>,
1107 /// Si `Some((evenodd, d))`, recorta los descendientes a un PATH SVG —
1108 /// modela `clip-path: path()`. `d` es el string SVG crudo (user units px,
1109 /// relativos al origen del rect); el pintado lo parsea con
1110 /// `BezPath::from_svg` y lo traslada al origen del nodo. Si el parseo
1111 /// falla, no recorta. Implica clip aunque `clip == false`. Prioridad:
1112 /// path > polygon > elipse > inset > rect.
1113 pub clip_path_svg: Option<(bool, String)>,
1114 /// Si `Some([t,r,b,l])`, el clip-path se resuelve contra una caja de
1115 /// referencia (`<geometry-box>`) que es el rect del nodo ENCOGIDO por esos
1116 /// insets px (padding-box = border; content-box = border+padding). El
1117 /// pintado lo aplica ANTES de resolver la forma; sin forma, recorta a ese
1118 /// rect. `None` = referencia = border-box (rect completo). Fase 7.1225.
1119 pub clip_ref_inset: Option<[f32; 4]>,
1120 /// Msg a emitir cuando el cursor entra al rect del nodo (transición
1121 /// no-hover → hover). Útil para previews tipo "URL del link al
1122 /// pasar el mouse".
1123 pub on_pointer_enter: Option<Msg>,
1124 /// Msg a emitir cuando el cursor sale del rect del nodo.
1125 pub on_pointer_leave: Option<Msg>,
1126 /// Handler de **movimiento del cursor** sobre el nodo: recibe `(local_x,
1127 /// local_y, rect_w, rect_h)` en CADA `CursorMoved` mientras el cursor está
1128 /// encima (no sólo en la transición de entrada, a diferencia de
1129 /// [`Self::on_pointer_enter`]). Análogo posicional de hover, base de cosas
1130 /// como el thumbnail que sigue al cursor sobre un timeline o un drawer que
1131 /// reacciona a la posición. `None` no dispara update.
1132 pub on_pointer_move_at: Option<ClickAtFn<Msg>>,
1133 /// Handler de rueda local. Si está presente y el cursor cae sobre este
1134 /// nodo, el runtime lo invoca antes del `App::on_wheel` global; un
1135 /// `Some(Msg)` consume el evento. Base de las áreas de scroll
1136 /// autocontenidas. Ver [`ScrollFn`].
1137 pub on_scroll: Option<ScrollFn<Msg>>,
1138 /// Variante con **reparto parcial** del delta (scroll anidado real):
1139 /// consume lo que puede y devuelve el sobrante, que sigue al ancestro.
1140 /// Tiene prioridad sobre `on_scroll` si ambos están. Ver [`ScrollTakeFn`].
1141 pub on_scroll_take: Option<ScrollTakeFn<Msg>>,
1142 /// Handler de gesto de **escala** (pinch-to-zoom). Si está presente y el
1143 /// gesto cae sobre este nodo (Ctrl+rueda en desktop, pinch de trackpad en
1144 /// macOS), el runtime lo invoca con el factor incremental + el punto focal
1145 /// local. Base del zoom de canvases. Ver [`ScaleFn`] y [`View::on_scale`].
1146 pub on_scale: Option<ScaleFn<Msg>>,
1147 /// Handler de gesto de **rotación** (dos dedos en trackpad, macOS). Si
1148 /// está presente y el gesto cae sobre este nodo, el runtime lo invoca con
1149 /// el delta de ángulo incremental (radianes) + el punto focal local. Ver
1150 /// [`RotateFn`] y [`View::on_rotate`].
1151 pub on_rotate: Option<RotateFn<Msg>>,
1152 /// Msg a emitir en **doble-tap** (dos presses izquierdos sobre este nodo
1153 /// dentro de una ventana temporal corta y muy cerca). Es un evento
1154 /// **aditivo**: si el nodo también tiene `on_click`, éste igual dispara en
1155 /// cada press; el doble-tap llega además en el segundo. Para doble-tap
1156 /// exclusivo, pon el handler en un nodo sin `on_click`. Ver
1157 /// [`View::on_double_tap`].
1158 pub on_double_tap: Option<Msg>,
1159 /// Variante posicional de [`Self::on_double_tap`]: recibe la posición del
1160 /// segundo tap relativa al rect del nodo (para zoom-to-point, etc.). Gana
1161 /// sobre `on_double_tap` si ambos están.
1162 pub on_double_tap_at: Option<ClickAtFn<Msg>>,
1163 /// El doble-tap de este nodo **arbitra contra su propio click**: deja de ser
1164 /// aditivo. El runtime retiene el click del primer tap hasta que venza la
1165 /// ventana del doble (`llimphi_ui::doble_tap_califica`) y, si llega el
1166 /// segundo, lo **descarta** — así el doble-tap dispara su `Msg` y nada más.
1167 ///
1168 /// Existe porque el diente de un rag-sidebar hace las dos cosas con el mismo
1169 /// botón: un click despliega su panel, dos fijan el espacio. Sin arbitrar,
1170 /// un doble-click desplegaba y replegaba el panel de paso — y en FIJO eso
1171 /// suelta y vuelve a tomar la franja reservada del escritorio, que se ve.
1172 /// Es **opt-in** justamente porque cuesta latencia: el que no lo pide (una
1173 /// fila de árbol que selecciona con uno y abre con dos, el texto de una
1174 /// terminal) sigue con el doble-tap aditivo y su click instantáneo.
1175 pub double_tap_exclusive: Option<()>,
1176 /// Msg a emitir en **long-press** (mantener el botón izquierdo sobre este
1177 /// nodo ~500 ms sin moverse ni soltar). El runtime lo arbitra por tiempo:
1178 /// si el cursor se aleja (pasó a drag/scroll) o se suelta antes, se
1179 /// cancela. Evento **aditivo** (ver [`Self::on_double_tap`]); el caso
1180 /// limpio es un nodo con drag-to-pan + long-press y sin `on_click` (un
1181 /// canvas). Útil para menús contextuales táctiles / selección. Ver
1182 /// [`View::on_long_press`].
1183 pub on_long_press: Option<Msg>,
1184 /// Variante posicional de [`Self::on_long_press`]: recibe la posición del
1185 /// press relativa al rect del nodo (para abrir el menú en el punto). Gana
1186 /// sobre `on_long_press` si ambos están.
1187 pub on_long_press_at: Option<ClickAtFn<Msg>>,
1188 /// Marca este nodo como **enfocable** con el id opaco `u64`. El runtime
1189 /// mantiene el foco (uno por ventana) y lo mueve con Tab/Shift+Tab en
1190 /// orden de árbol (pre-orden) y al clickear un nodo enfocable; notifica
1191 /// a la app vía `App::on_focus` para que pinte el ring y rutee el
1192 /// teclado. El id lo elige el caller (índice de campo, hash, etc.).
1193 pub focusable: Option<u64>,
1194 /// Marca este nodo de **texto** como seleccionable con el mouse fuera del
1195 /// editor (arrastrar resalta, Ctrl/Cmd+C copia). El `u64` es una **key
1196 /// estable** entre rebuilds del `View` (los `NodeId` de taffy cambian cada
1197 /// frame, así que la selección retenida en el runtime se ancla a esta key,
1198 /// igual que `animated`). Sólo tiene efecto en nodos con `text` uniforme
1199 /// (no `runs`/`spans`). Ver [`View::selectable`].
1200 pub text_select_key: Option<u64>,
1201 /// Animación **implícita** de las props de paint (fill/radius): cuando el
1202 /// valor cambia entre frames, el runtime interpola en vez de saltar. `None`
1203 /// = sin animación (la abrumadora mayoría). La `key` debe ser estable entre
1204 /// rebuilds. Ver [`Anim`] y [`View::animated`]. Lo consume el runtime vía
1205 /// [`AnimRegistry::reconcile`] (DESPUÉS de layout, ANTES de paint).
1206 pub anim: Option<Anim>,
1207 /// **Animación implícita de tamaño** (Flutter `AnimatedSize` /
1208 /// Compose `animateContentSize()`). `None` = sin animación. La key
1209 /// debe ser estable entre rebuilds. A diferencia de [`Self::anim`]
1210 /// (props de paint, reconcilia DESPUÉS de layout), el tamaño tiene
1211 /// que estar firme **antes** del layout — siblings/hijos dependen
1212 /// del rect del nodo. El runtime llama
1213 /// [`reconcile_size_anim`] sobre el `View` tree **antes** de
1214 /// `mount` y parcha `style.size` con el valor interpolado. Sólo se
1215 /// activa si ambos `style.size.width` y `style.size.height` son
1216 /// `Dimension::Length(_)`. Ver [`SizeAnim`] y [`View::animated_size`].
1217 pub animated_size: Option<SizeAnim>,
1218 /// **Hero shared-element**: marca este nodo como una identidad estable
1219 /// entre frames. Si la misma `key` aparece en otra posición en un frame
1220 /// siguiente, el runtime interpola `transform` para "volar" del rect
1221 /// anterior al actual durante la `duration` declarada. Ver
1222 /// [`Hero`] y [`HeroRegistry`]. `None` = sin hero (la abrumadora mayoría).
1223 pub hero: Option<Hero>,
1224 /// Transformación afín 2D aplicada a este nodo y todo su subtree
1225 /// **alrededor del centro de su propio rect** (convención CSS
1226 /// `transform-origin: 50% 50%`). El runtime resuelve el centro en
1227 /// `paint` (sólo entonces conoce el layout computado) y compone
1228 /// `T(centro) · transform · T(-centro)` sobre la transformación
1229 /// acumulada del padre, así nodos anidados transforman en el espacio
1230 /// ya transformado de su ancestro — igual que CSS. `None` = identidad
1231 /// (la abrumadora mayoría de nodos). Pensado para `transform`/
1232 /// `@keyframes` CSS de puriy (rotate/scale/translate). El hit-test
1233 /// **respeta** el afín (un nodo transformado recibe clicks donde se ve
1234 /// pintado). Limitación restante: los `painter`/`runs` custom no heredan
1235 /// el afín, y la posición local que reciben los handlers `*_at` se
1236 /// reporta en espacio de pantalla, no en el espacio local del nodo.
1237 pub transform: Option<Affine>,
1238 /// Traslación RELATIVA al tamaño del propio nodo, en fracciones de su rect
1239 /// computado: `(fx, fy)` ⇒ desplaza `(fx · w, fy · h)` px. Se resuelve en
1240 /// `paint`/`hit_test` (única instancia donde se conoce el tamaño usado) y
1241 /// se compone como el factor más externo del afín del nodo, ANTES del
1242 /// centrado por `transform-origin`. Pensado para el `translate(<%>)` de CSS
1243 /// (p. ej. el truco de centrado `translate(-50%, -50%)` ⇒ `(-0.5, -0.5)`),
1244 /// que no es expresable como `Affine` fijo porque el % depende del layout.
1245 /// `None` = sin traslación relativa (la abrumadora mayoría). Compone con
1246 /// `transform` (afín fijo) si ambos están: `T_rel · transform`.
1247 pub transform_rel: Option<(f64, f64)>,
1248 /// Punto de pivote de `transform` (CSS `transform-origin`). `None` ⇒ el
1249 /// default CSS `50% 50%` (centro del rect) — el caso mayoritario. Ver
1250 /// [`TransformPivot`] y [`View::transform_origin`].
1251 pub transform_origin: Option<TransformPivot>,
1252 /// `position: sticky` (CSS): insets `[top, right, bottom, left]` en px
1253 /// relativos al **scrollport** (el ancestro que recorta, `clip==true`).
1254 /// El nodo se pinta en su posición de flujo normal hasta que el scroll lo
1255 /// lleva al umbral del inset; ahí se "pega" a esa distancia del borde del
1256 /// scrollport, sin salir de él. Como el scroll ya está horneado en el
1257 /// layout (el rect del nodo refleja el desplazamiento), `paint` resuelve el
1258 /// enganche con pura aritmética de rects — no necesita conocer el offset de
1259 /// scroll. `None` ⇒ nodo no-sticky (la abrumadora mayoría). Ver
1260 /// [`View::sticky`]. Limitación v1: el clamp usa el scrollport como caja
1261 /// contenedora (no el bloque contenedor CSS exacto); alcanza para el caso
1262 /// canónico (header/columna sticky a nivel de página).
1263 pub sticky: Option<[Option<f32>; 4]>,
1264 /// Texto de **tooltip**: si está, el runtime/cliente puede mostrar un
1265 /// rótulo flotante cuando el cursor se posa sobre este nodo. Llimphi sólo
1266 /// transporta el dato hasta el [`MountedNode`]; *quién* lo pinta (un overlay
1267 /// del runtime, una surface popup del cliente) lo decide el consumidor. El
1268 /// hit-test de hover ya localiza el nodo bajo el cursor. `None` = sin tip.
1269 pub tooltip: Option<String>,
1270 /// Forma del puntero del mouse mientras está sobre este nodo (o un
1271 /// descendiente sin cursor propio — se hereda del ancestro más cercano que
1272 /// lo declare). El runtime lo resuelve en el hit-test de hover y lo aplica a
1273 /// la ventana. `None` = hereda (default flecha en la raíz). Ver [`Cursor`] y
1274 /// [`View::cursor`]. Llimphi-native (sin winit); el runtime lo mapea.
1275 pub cursor: Option<Cursor>,
1276 /// Feedback de tap **ripple/InkWell**: al presionar este nodo, el runtime
1277 /// emite una salpicadura Material (círculo que se expande desde el punto y
1278 /// se desvanece, recortado al contorno del nodo). Es puro feedback visual,
1279 /// aditivo al `on_click`; vive en el runtime ([`RippleRegistry`]), no en el
1280 /// `Model`. `None` = sin ripple. Ver [`View::ripple`].
1281 pub ripple: Option<Ripple>,
1282 /// Constructor **diferido** sensible al tamaño (`LayoutBuilder`). Si está
1283 /// presente, este nodo NO usa sus `children` estáticos: el runtime resuelve
1284 /// su slot en una primera pasada de layout y luego invoca esta closure con
1285 /// las [`Constraints`] resueltas para producir el subárbol. `None` = nodo
1286 /// normal (la abrumadora mayoría). Ver [`View::layout_builder`].
1287 pub layout_builder: Option<LayoutBuilderFn<Msg>>,
1288 /// Backdrop blur sobre el contenido pintado **debajo** de este nodo.
1289 /// Ver [`View::backdrop_blur`] / [`MountedNode::backdrop_blur`]. v1:
1290 /// sólo se aplica a nodos top-level sin clip/alpha ancestral.
1291 pub backdrop_blur: Option<f32>,
1292 /// Filtros CSS (`filter: …`) sobre el propio subárbol del nodo. Vacío = sin
1293 /// filtro. Ver [`View::filter`] / [`FilterOp`]. Fase 7.1232.
1294 pub filter: Vec<FilterOp>,
1295 /// **Modo de mezcla** del nodo entero contra su backdrop (CSS
1296 /// `mix-blend-mode`). `Some(bm)` ⇒ el subárbol del nodo se rasteriza en una
1297 /// capa aislada (`scene.push_layer(bm, …)` alrededor del rect) y se mezcla
1298 /// con el modo `bm` contra todo lo pintado antes en el stacking context.
1299 /// `None` = source-over normal (la abrumadora mayoría). Ver [`View::blend`].
1300 /// Fase 7.1237.
1301 pub blend: Option<BlendMode>,
1302 /// **RepaintBoundary** (Bloque 23 de `PLAN-NUCLEO-RETENIDO.md`): marca este
1303 /// subárbol como candidato a **cachear su rasterización** entre frames. Si
1304 /// el subárbol es paint-puro (sin painter/gpu/over/anim/ripple/gradiente/
1305 /// imagen/hover adentro) y está en una posición "limpia" (sin transform/clip/
1306 /// alpha ancestral), el runtime rasteriza su sub-escena una vez y la **reusa**
1307 /// (append trasladado) mientras su contenido no cambie — evitando re-pintarlo.
1308 /// `key` estable entre rebuilds. `None` = nodo normal (la abrumadora mayoría).
1309 /// Ver [`View::repaint_boundary`].
1310 pub repaint_boundary: Option<u64>,
1311 /// **Memo** (Bloque 25): si está presente, el contenido de este nodo se
1312 /// construye vía el `builder` diferido y se **reusa entre frames** mientras
1313 /// `deps` no cambie (no se reconstruye el `View` ni se re-monta/re-layoutea).
1314 /// El nodo debe tener un `Style` con tamaño definido. `None` = nodo normal.
1315 /// Ver [`View::memo`].
1316 pub memo: Option<MemoNode<Msg>>,
1317}
1318
1319impl<Msg> Default for ViewRare<Msg> {
1320 fn default() -> Self {
1321 Self {
1322 intrinsic: None,
1323 corner_radii: None,
1324 shadow: None,
1325 fill_gradient: None,
1326 border: None,
1327 image: None,
1328 image_fit: None,
1329 mask_image: None,
1330 mask_placement: None,
1331 mask_extra: Vec::new(),
1332 gpu_painter: None,
1333 over_painter: None,
1334 on_click_at: None,
1335 on_click_screen: None,
1336 on_right_click: None,
1337 on_right_click_at: None,
1338 on_right_click_screen: None,
1339 on_middle_click: None,
1340 drag: None,
1341 drag_at: None,
1342 drag_velocity: None,
1343 drag_payload: None,
1344 on_drop: None,
1345 drop_hover_fill: None,
1346 clip_inset: None,
1347 clip_ellipse: None,
1348 clip_polygon: None,
1349 clip_path_svg: None,
1350 clip_ref_inset: None,
1351 on_pointer_enter: None,
1352 on_pointer_leave: None,
1353 on_pointer_move_at: None,
1354 on_scroll: None,
1355 on_scroll_take: None,
1356 on_scale: None,
1357 on_rotate: None,
1358 on_double_tap: None,
1359 on_double_tap_at: None,
1360 double_tap_exclusive: None,
1361 on_long_press: None,
1362 on_long_press_at: None,
1363 focusable: None,
1364 text_select_key: None,
1365 anim: None,
1366 animated_size: None,
1367 hero: None,
1368 transform: None,
1369 transform_rel: None,
1370 transform_origin: None,
1371 sticky: None,
1372 tooltip: None,
1373 cursor: None,
1374 ripple: None,
1375 layout_builder: None,
1376 backdrop_blur: None,
1377 filter: Vec::new(),
1378 blend: None,
1379 repaint_boundary: None,
1380 memo: None,
1381 }
1382 }
1383}
1384
1385impl<Msg: 'static> View<Msg> {
1386 /// Transforma el `Msg` de **todo el árbol** vía `f`, devolviendo
1387 /// `View<Msg2>`. Es la pieza que permite **embeber el `view` de un sub-app**
1388 /// en un host (junto con [`crate::Handle::lift`] para sus efectos): el host
1389 /// pinta `sub_view.map(Msg::Sub)` y los eventos del sub-árbol vuelven como
1390 /// su propio `Msg`. Patrón estándar de anidado Elm. `f` se comparte (`Arc`)
1391 /// entre todos los callbacks e hijos, así que debe ser `Send + Sync`.
1392 pub fn map<Msg2, F>(self, f: F) -> View<Msg2>
1393 where
1394 Msg2: 'static,
1395 F: Fn(Msg) -> Msg2 + Send + Sync + 'static,
1396 {
1397 self.map_shared(Arc::new(f))
1398 }
1399
1400 fn map_shared<Msg2: 'static>(
1401 self,
1402 f: Arc<dyn Fn(Msg) -> Msg2 + Send + Sync>,
1403 ) -> View<Msg2> {
1404 let View {
1405 style,
1406 text,
1407 painter,
1408 alpha,
1409 semantics,
1410 fill,
1411 hover_fill,
1412 radius,
1413 clip,
1414 over_layer,
1415 on_click,
1416 children,
1417 rare,
1418 } = self;
1419 // Wrappers: cada callback que produce `Option<Msg>` se reenvía y su
1420 // resultado se eleva con `f`. `f` se clona por callback (todos comparten
1421 // el mismo `Arc`).
1422 View {
1423 style,
1424 fill,
1425 hover_fill,
1426 radius,
1427 clip,
1428 over_layer,
1429 text,
1430 painter,
1431 alpha,
1432 semantics,
1433 on_click: on_click.map(|m| f(m)),
1434 children: children
1435 .into_iter()
1436 .map(|c| c.map_shared(f.clone()))
1437 .collect(),
1438 // Props raras: se mapean SÓLO si el nodo las tiene. Así un subárbol
1439 // mapeado conserva el `None` y no paga la caja (ver [`ViewRare`]).
1440 rare: rare.map(move |caja| {
1441 let ViewRare {
1442 intrinsic,
1443 corner_radii,
1444 shadow,
1445 fill_gradient,
1446 border,
1447 image,
1448 image_fit,
1449 mask_image,
1450 mask_placement,
1451 mask_extra,
1452 gpu_painter,
1453 over_painter,
1454 on_click_at,
1455 on_click_screen,
1456 on_right_click,
1457 on_right_click_at,
1458 on_right_click_screen,
1459 on_middle_click,
1460 drag,
1461 drag_at,
1462 drag_velocity,
1463 drag_payload,
1464 on_drop,
1465 drop_hover_fill,
1466 clip_inset,
1467 clip_ellipse,
1468 clip_polygon,
1469 clip_path_svg,
1470 clip_ref_inset,
1471 on_pointer_enter,
1472 on_pointer_leave,
1473 on_pointer_move_at,
1474 on_scroll,
1475 on_scroll_take,
1476 on_scale,
1477 on_rotate,
1478 on_double_tap,
1479 on_double_tap_at,
1480 on_long_press,
1481 on_long_press_at,
1482 focusable,
1483 text_select_key,
1484 anim,
1485 animated_size,
1486 hero,
1487 transform,
1488 transform_rel,
1489 transform_origin,
1490 sticky,
1491 tooltip,
1492 cursor,
1493 ripple,
1494 layout_builder,
1495 backdrop_blur,
1496 filter,
1497 blend,
1498 repaint_boundary,
1499 memo,
1500 double_tap_exclusive,
1501 } = *caja;
1502 Box::new(ViewRare {
1503 intrinsic,
1504 corner_radii,
1505 shadow,
1506 fill_gradient,
1507 border,
1508 image,
1509 image_fit,
1510 mask_image,
1511 mask_placement,
1512 mask_extra,
1513 gpu_painter,
1514 over_painter,
1515 on_click_at: on_click_at.map(|h| {
1516 let f = f.clone();
1517 Arc::new(move |a, b, c, d| h(a, b, c, d).map(|m| f(m))) as ClickAtFn<Msg2>
1518 }),
1519 on_click_screen: on_click_screen.map(|h| {
1520 let f = f.clone();
1521 Arc::new(move |a, b, c, d| h(a, b, c, d).map(|m| f(m))) as ClickAtFn<Msg2>
1522 }),
1523 on_right_click: on_right_click.map(|m| f(m)),
1524 on_right_click_at: on_right_click_at.map(|h| {
1525 let f = f.clone();
1526 Arc::new(move |a, b, c, d| h(a, b, c, d).map(|m| f(m))) as ClickAtFn<Msg2>
1527 }),
1528 on_right_click_screen: on_right_click_screen.map(|h| {
1529 let f = f.clone();
1530 Arc::new(move |a, b, c, d| h(a, b, c, d).map(|m| f(m))) as ClickAtFn<Msg2>
1531 }),
1532 on_middle_click: on_middle_click.map(|m| f(m)),
1533 drag: drag.map(|h| {
1534 let f = f.clone();
1535 Arc::new(move |p, dx, dy| h(p, dx, dy).map(|m| f(m))) as DragFn<Msg2>
1536 }),
1537 drag_at: drag_at.map(|h| {
1538 let f = f.clone();
1539 Arc::new(move |p, dx, dy, lx, ly| h(p, dx, dy, lx, ly).map(|m| f(m)))
1540 as DragAtFn<Msg2>
1541 }),
1542 drag_velocity: drag_velocity.map(|h| {
1543 let f = f.clone();
1544 Arc::new(move |p, dx, dy, vx, vy| h(p, dx, dy, vx, vy).map(|m| f(m)))
1545 as DragVelocityFn<Msg2>
1546 }),
1547 drag_payload,
1548 on_drop: on_drop.map(|h| {
1549 let f = f.clone();
1550 Arc::new(move |payload| h(payload).map(|m| f(m))) as DropFn<Msg2>
1551 }),
1552 drop_hover_fill,
1553 clip_inset,
1554 clip_ellipse,
1555 clip_polygon,
1556 clip_path_svg,
1557 clip_ref_inset,
1558 on_pointer_enter: on_pointer_enter.map(|m| f(m)),
1559 on_pointer_leave: on_pointer_leave.map(|m| f(m)),
1560 on_pointer_move_at: on_pointer_move_at.map(|h| {
1561 let f = f.clone();
1562 Arc::new(move |a, b, c, d| h(a, b, c, d).map(|m| f(m))) as ClickAtFn<Msg2>
1563 }),
1564 on_scroll: on_scroll.map(|h| {
1565 let f = f.clone();
1566 Arc::new(move |dx, dy| h(dx, dy).map(|m| f(m))) as ScrollFn<Msg2>
1567 }),
1568 on_scroll_take: on_scroll_take.map(|h| {
1569 let f = f.clone();
1570 Arc::new(move |dx, dy| {
1571 let (msg, rx, ry) = h(dx, dy);
1572 (msg.map(|m| f(m)), rx, ry)
1573 }) as ScrollTakeFn<Msg2>
1574 }),
1575 on_scale: on_scale.map(|h| {
1576 let f = f.clone();
1577 Arc::new(move |ph, s, cx, cy| h(ph, s, cx, cy).map(|m| f(m))) as ScaleFn<Msg2>
1578 }),
1579 on_rotate: on_rotate.map(|h| {
1580 let f = f.clone();
1581 Arc::new(move |ph, r, cx, cy| h(ph, r, cx, cy).map(|m| f(m))) as RotateFn<Msg2>
1582 }),
1583 // — layout_builder produce un View<Msg>: recursa el map —
1584 on_double_tap: on_double_tap.map(|m| f(m)),
1585 on_double_tap_at: on_double_tap_at.map(|h| {
1586 let f = f.clone();
1587 Arc::new(move |a, b, c, d| h(a, b, c, d).map(|m| f(m))) as ClickAtFn<Msg2>
1588 }),
1589 on_long_press: on_long_press.map(|m| f(m)),
1590 // — ClickAtFn (lx, ly, w, h) —
1591 on_long_press_at: on_long_press_at.map(|h| {
1592 let f = f.clone();
1593 Arc::new(move |a, b, c, d| h(a, b, c, d).map(|m| f(m))) as ClickAtFn<Msg2>
1594 }),
1595 // — drag / scroll / gestos —
1596 focusable,
1597 text_select_key,
1598 anim,
1599 animated_size,
1600 hero,
1601 transform,
1602 transform_rel,
1603 transform_origin,
1604 sticky,
1605 tooltip,
1606 cursor,
1607 ripple,
1608 layout_builder: layout_builder.map(|h| {
1609 let f = f.clone();
1610 Arc::new(move |c| h(c).map_shared(f.clone())) as LayoutBuilderFn<Msg2>
1611 }),
1612 // — hijos: recursión —
1613 backdrop_blur,
1614 filter,
1615 blend,
1616 repaint_boundary,
1617 // El builder del memo produce `View<Msg>`; lo envolvemos para que
1618 // produzca `View<Msg2>` mapeando su resultado con `f`.
1619 memo: memo.map(|m| MemoNode {
1620 key: m.key,
1621 deps: m.deps,
1622 builder: m.builder.map(|b| {
1623 let f = f.clone();
1624 Arc::new(move || b().map_shared(f.clone())) as MemoBuilderFn<Msg2>
1625 }),
1626 }),
1627 double_tap_exclusive,
1628 // — Msg simples —
1629 })
1630 }),
1631 }
1632 }
1633}
1634
1635/// Versión "instalada" del árbol: cada nodo tiene su NodeId de taffy, color
1636/// y handler. Se mantiene en orden de inserción (recorrido pre-orden), así
1637/// el hit-test puede iterar al revés para honrar el orden de pintado.
1638///
1639/// `pub` (con campos `pub`) porque el runtime (llimphi-ui) lee el árbol
1640/// montado para hit-test y para la pasada GPU directa, pero vive en otro
1641/// crate. No se construye fuera de [`mount`].
1642pub struct Mounted<Msg> {
1643 pub root: NodeId,
1644 pub nodes: Vec<MountedNode<Msg>>,
1645 /// Contenido de texto por nodo-hoja, para que el runtime lo mida con
1646 /// parley durante `compute_with_measure` y taffy reserve el alto real
1647 /// del texto envuelto (varias líneas) en vez de una sola. Sin esto un
1648 /// párrafo que envuelve a N líneas se aplastaría en la altura de una
1649 /// (el bug clásico de "textos aplastados"). Sólo se pueblan hojas con
1650 /// texto uniforme (sin `runs` multicolor, que el caller dimensiona).
1651 pub text_measures: HashMap<NodeId, TextMeasure>,
1652 /// Tamaño INTRÍNSECO por nodo-hoja de contenido reemplazado (una imagen),
1653 /// para que el runtime lo mida igual que mide el texto. Ver
1654 /// [`IntrinsicSize`] y [`measure_intrinsic_node`].
1655 pub intrinsic_measures: HashMap<NodeId, IntrinsicSize>,
1656}
1657
1658/// Tamaño natural de un contenido REEMPLAZADO (hoy: una imagen), para que el
1659/// layout lo trate como CSS trata a un `<img>`: prefiere su tamaño natural,
1660/// nunca pasa del espacio disponible, y **puede encogerse hasta 0**.
1661///
1662/// Existe porque un `Style` solo no puede expresar eso. Una hoja con `size`
1663/// definido aporta ese mismo ancho a min-content Y a max-content: el contenedor
1664/// que la tiene adentro no puede encoger por debajo del ancho natural de la
1665/// imagen. Y una hoja con `size` en porcentaje aporta 0 a los DOS: encoge bien,
1666/// pero adentro de un padre shrink-to-fit (un `float`, un `inline-block`) el
1667/// padre mide 0 y la imagen desaparece. Las dos se midieron sobre el corpus de
1668/// puriy y cada una rompe una punta.
1669///
1670/// Con la medida, la hoja aporta **0 a min-content y su ancho natural a
1671/// max-content**, que es lo que hace un browser. Es el mismo mecanismo que
1672/// [`TextMeasure`], que ya existía para el texto.
1673#[derive(Clone, Copy, Debug, PartialEq)]
1674pub struct IntrinsicSize {
1675 pub width: f32,
1676 pub height: f32,
1677}
1678
1679/// Datos de un nodo-hoja de texto necesarios para medirlo (shaping +
1680/// line-break) sin volver a tocar el `View`. Lo consume el runtime en la
1681/// función de medición que le pasa a [`LayoutTree::compute_with_measure`].
1682#[derive(Clone)]
1683pub struct TextMeasure {
1684 pub content: String,
1685 pub size_px: f32,
1686 pub alignment: llimphi_text::Alignment,
1687 pub italic: bool,
1688 pub font_family: Option<String>,
1689 pub line_height: f32,
1690 pub weight: f32,
1691 pub max_lines: Option<usize>,
1692 pub ellipsis: bool,
1693 /// Idem [`TextSpec::underline`]. Se replica en la medida porque parley
1694 /// no cambia de ancho con decoración (no toca el shaping); pero la clave
1695 /// del caché de shaping sí cambia, y queremos que medida y pintado
1696 /// peguen la misma entrada del caché.
1697 pub underline: bool,
1698 /// Idem [`TextSpec::strikethrough`]. Mismo razonamiento que `underline`.
1699 pub strikethrough: bool,
1700 /// Idem [`TextSpec::spans`]. La medida usa el mismo
1701 /// `Typesetter::layout_spans` que el pintado, así taffy reserva el alto
1702 /// real considerando overrides de `size_px` por span (un `<h1>` inline
1703 /// dentro de un párrafo agranda esa línea). `None`/`vacío` = medir con
1704 /// `layout_clamped` (camino uniforme).
1705 pub spans: Option<Vec<llimphi_text::TextSpan>>,
1706 /// Idem [`TextSpec::letter_spacing`]. Entra en la medida porque cambia el
1707 /// ancho del shaping (y la clave del caché).
1708 pub letter_spacing: f32,
1709 /// Idem [`TextSpec::word_spacing`]. Mismo razonamiento que `letter_spacing`.
1710 pub word_spacing: f32,
1711 /// Idem [`TextSpec::no_wrap`]. Entra en la medida porque cambia el ancho
1712 /// reservado: con `no_wrap` el texto se mide en una sola línea (ancho
1713 /// completo) en vez de envolver al `available`.
1714 pub no_wrap: bool,
1715 /// Idem [`TextSpec::overflow_wrap`]. Entra en la medida porque parte la
1716 /// palabra larga: con el flag, el ancho mínimo del bloque deja de estar
1717 /// fijado por el token más ancho.
1718 pub overflow_wrap: bool,
1719 /// Idem [`TextSpec::font_features`]. Entra en la medida porque ligaduras/
1720 /// kerning cambian el ancho del shaping (y la clave del caché).
1721 pub font_features: String,
1722 /// Idem [`TextSpec::font_variations`]. Mismo razonamiento que `font_features`.
1723 pub font_variations: String,
1724 /// Idem [`TextSpec::font_width`]. Entra en la medida porque la face
1725 /// condensada/expandida cambia el ancho del shaping (y la clave del caché).
1726 pub font_width: f32,
1727}
1728
1729/// Cómo encajar una imagen en el rect del nodo (CSS `object-fit` /
1730/// Flutter `BoxFit`). El runtime calcula la escala y el origen
1731/// correspondientes a esta política y siempre recorta al
1732/// `node_rrect` del nodo, así el clip respeta `radius` /
1733/// `corner_radii`.
1734#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1735pub enum ImageFit {
1736 /// Preservar aspect ratio, **caber** dentro del rect (escala =
1737 /// `min(sx, sy)`). Deja banda en el eje menos restrictivo.
1738 /// CSS `object-fit: contain` / Flutter `BoxFit.contain`. **Default
1739 /// histórico** — lo que hacía `View::image()` antes del Bloque 12.
1740 Contain,
1741 /// Preservar aspect ratio, **cubrir** todo el rect (escala =
1742 /// `max(sx, sy)`). Recorta el sobrante en el eje menos
1743 /// restrictivo (el clip al `node_rrect` lo absorbe). CSS
1744 /// `object-fit: cover` / Flutter `BoxFit.cover` — ideal para
1745 /// avatares y hero images.
1746 Cover,
1747 /// Estirar la imagen para ocupar el rect, **sin** preservar
1748 /// aspect ratio (`sx`/`sy` independientes). CSS `object-fit:
1749 /// fill` / Flutter `BoxFit.fill`.
1750 Fill,
1751 /// **No** escalar la imagen — pintarla a su tamaño original,
1752 /// centrada en el rect. Si la imagen excede el rect, el clip al
1753 /// `node_rrect` la recorta. CSS `object-fit: none` / Flutter
1754 /// `BoxFit.none`.
1755 None,
1756}
1757
1758/// Longitud de un eje de [`MaskSize`]/posición de máscara, **sin resolver** —
1759/// el paint la resuelve contra el rect del nodo. Neutral respecto de CSS: el
1760/// frontend (p. ej. puriy) traduce `mask-size`/`mask-position` a esto. Fase
1761/// 7.1227.
1762#[derive(Debug, Clone, Copy, PartialEq)]
1763pub enum MaskLen {
1764 /// Tamaño intrínseco de la imagen (en size) / offset 0 (en position).
1765 Auto,
1766 /// Longitud absoluta en px.
1767 Px(f32),
1768 /// Porcentaje: en size, del lado correspondiente del rect; en position,
1769 /// alineación CSS (el `p%` de la máscara cae sobre el `p%` del rect).
1770 Pct(f32),
1771}
1772
1773/// `mask-size` neutral (espejo de `BackgroundSize`). Ver [`MaskPlacement`].
1774/// Fase 7.1227.
1775#[derive(Debug, Clone, Copy, PartialEq)]
1776pub enum MaskSize {
1777 /// Tamaño intrínseco de la imagen-máscara.
1778 Auto,
1779 /// Escalar preservando aspecto hasta **cubrir** el rect.
1780 Cover,
1781 /// Escalar preservando aspecto hasta **caber** en el rect.
1782 Contain,
1783 /// Tamaño explícito por eje (`Auto` en un eje = derivar por aspecto).
1784 Explicit { x: MaskLen, y: MaskLen },
1785}
1786
1787/// Modo de una máscara (CSS `mask-mode`). Decide qué canal del píxel-máscara
1788/// modula el alpha del contenido. Fase 7.1228.
1789#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
1790pub enum MaskMode {
1791 /// La **luminancia** del píxel multiplica el alpha (negro = oculto, blanco =
1792 /// visible). Lo usa CSS para máscaras SVG `<mask>`. Es el default del
1793 /// compositor cuando no hay `MaskPlacement` (camino estirado, Fase 7.1226).
1794 #[default]
1795 Luminance,
1796 /// El **canal alpha** del píxel modula el alpha (transparente = oculto). Es
1797 /// el default CSS para imágenes raster (`mask-mode: match-source`). Se pinta
1798 /// con `Compose::DestIn` en vez de la capa de luminancia.
1799 Alpha,
1800}
1801
1802/// Operador de combinación entre capas de máscara (CSS `mask-composite`). Mapea
1803/// a un `Compose` Porter-Duff de vello cuando una capa extra se compone sobre
1804/// las de abajo. Fase 7.1231.
1805#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
1806pub enum MaskCompose {
1807 /// La capa se **suma** sobre las de abajo (source-over). Default CSS.
1808 #[default]
1809 Add,
1810 /// La capa **resta** (source-out: la fuente donde NO solapa el destino).
1811 Subtract,
1812 /// **Intersección** (source-in: la fuente donde solapa el destino).
1813 Intersect,
1814 /// **Exclusión** (xor: las regiones no solapadas de ambas).
1815 Exclude,
1816}
1817
1818/// Encaje y modo de una **máscara** (CSS `mask-size` + `mask-position` +
1819/// `mask-repeat` + `mask-mode`), resuelto contra el rect del nodo en el paint,
1820/// con la misma aritmética que `background-image`. En el [`MountedNode`] viaja
1821/// como `Option`: `None` = estirar la máscara al border-box en modo luminancia
1822/// (comportamiento de la Fase 7.1226). Fase 7.1227 (encaje), 7.1228 (modo).
1823#[derive(Debug, Clone, Copy, PartialEq)]
1824pub struct MaskPlacement {
1825 /// Tamaño del tile.
1826 pub size: MaskSize,
1827 /// Offset/alineación horizontal del primer tile.
1828 pub pos_x: MaskLen,
1829 /// Offset/alineación vertical del primer tile.
1830 pub pos_y: MaskLen,
1831 /// Tilear en X (`mask-repeat` cubre el eje horizontal).
1832 pub repeat_x: bool,
1833 /// Tilear en Y.
1834 pub repeat_y: bool,
1835 /// Canal que modula el alpha (luminancia vs alpha). Fase 7.1228.
1836 pub mode: MaskMode,
1837 /// Insets `[top, right, bottom, left]` px del border-box a la caja de
1838 /// `mask-clip`: el efecto de la máscara se **recorta** a esa caja. `None` =
1839 /// border-box. Fase 7.1230.
1840 pub clip_inset: Option<[f32; 4]>,
1841 /// Insets `[top, right, bottom, left]` px del border-box a la caja de
1842 /// `mask-origin`: size/position/tiling se resuelven contra esa caja. `None`
1843 /// = border-box. Fase 7.1230.
1844 pub origin_inset: Option<[f32; 4]>,
1845}
1846
1847impl Default for ImageFit {
1848 fn default() -> Self {
1849 ImageFit::Contain
1850 }
1851}
1852
1853/// Forma del puntero del mouse. Subconjunto práctico, llimphi-native (el
1854/// compositor no depende de winit). El runtime (`llimphi-ui`) mapea 1:1 a
1855/// `winit::window::CursorIcon`. Nombres alineados con CSS/winit.
1856#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1857pub enum Cursor {
1858 /// Flecha por defecto.
1859 Default,
1860 /// Manito — sobre algo clickeable (links, botones).
1861 Pointer,
1862 /// I-beam — sobre texto editable/seleccionable.
1863 Text,
1864 /// Cruz — selección precisa (canvas, picker de color).
1865 Crosshair,
1866 /// Cuatro flechas — mover un objeto.
1867 Move,
1868 /// Mano abierta — agarrable (antes de arrastrar).
1869 Grab,
1870 /// Mano cerrada — arrastrando.
1871 Grabbing,
1872 /// Prohibido — drop no permitido / acción inválida.
1873 NotAllowed,
1874 /// Reloj/espera — operación bloqueante.
1875 Wait,
1876 /// Progreso — ocupado pero la UI responde.
1877 Progress,
1878 /// Interrogación — ayuda contextual.
1879 Help,
1880 /// Resize horizontal (columna / divisor vertical).
1881 ColResize,
1882 /// Resize vertical (fila / divisor horizontal).
1883 RowResize,
1884 /// Resize este-oeste.
1885 EwResize,
1886 /// Resize norte-sur.
1887 NsResize,
1888 /// Resize diagonal ↗↙.
1889 NeswResize,
1890 /// Resize diagonal ↖↘.
1891 NwseResize,
1892 /// Lupa + (zoom in).
1893 ZoomIn,
1894 /// Lupa − (zoom out).
1895 ZoomOut,
1896}
1897
1898#[derive(Clone)]
1899pub struct MountedNode<Msg> {
1900 pub id: NodeId,
1901 pub fill: Option<Color>,
1902 pub hover_fill: Option<Color>,
1903 pub radius: f64,
1904 pub corner_radii: Option<RoundedRectRadii>,
1905 pub shadow: Option<Shadow>,
1906 pub fill_gradient: Option<Gradient>,
1907 pub border: Option<Border>,
1908 pub text: Option<TextSpec>,
1909 pub image: Option<Image>,
1910 /// Política de encaje de [`Self::image`] (ver [`ImageFit`]). `None`
1911 /// = `Contain`.
1912 pub image_fit: Option<ImageFit>,
1913 /// Máscara de luminancia del subárbol (CSS `mask-image`). Ver
1914 /// [`View::mask_image`]. El paint aísla el subárbol y aplica la luminancia
1915 /// de esta imagen como alpha. `None` = sin máscara.
1916 pub mask_image: Option<Image>,
1917 /// Encaje de [`Self::mask_image`] (size/position/repeat). `None` = estirar
1918 /// al border-box. Ver [`MaskPlacement`]. Fase 7.1227.
1919 pub mask_placement: Option<MaskPlacement>,
1920 /// Capas de máscara adicionales `(imagen, operador)` (ver [`View::mask_extra`]).
1921 /// Comparten el `mask_placement` con la capa 0. Fase 7.1231.
1922 pub mask_extra: Vec<(Image, MaskCompose)>,
1923 pub painter: Option<PaintFn>,
1924 pub gpu_painter: Option<GpuPaintFn>,
1925 pub over_painter: Option<PaintFn>,
1926 /// Subárbol over (ver [`View::over`]): este nodo y sus descendientes
1927 /// pintan en la pasada vello final, después del pase GPU.
1928 pub over_layer: bool,
1929 pub on_click: Option<Msg>,
1930 pub on_click_at: Option<ClickAtFn<Msg>>,
1931 /// Gemelo de izquierda de [`Self::on_right_click_screen`]: click izquierdo con
1932 /// coords **absolutas de ventana**, para anclar un popup (select/dropdown).
1933 pub on_click_screen: Option<ClickAtFn<Msg>>,
1934 pub on_right_click: Option<Msg>,
1935 pub on_right_click_at: Option<ClickAtFn<Msg>>,
1936 pub on_right_click_screen: Option<ClickAtFn<Msg>>,
1937 pub on_middle_click: Option<Msg>,
1938 pub drag: Option<DragFn<Msg>>,
1939 pub drag_at: Option<DragAtFn<Msg>>,
1940 pub drag_velocity: Option<DragVelocityFn<Msg>>,
1941 pub drag_payload: Option<u64>,
1942 pub on_drop: Option<DropFn<Msg>>,
1943 pub drop_hover_fill: Option<Color>,
1944 pub clip: bool,
1945 pub clip_inset: Option<[f32; 4]>,
1946 pub clip_ellipse: Option<[f32; 14]>,
1947 pub clip_polygon: Option<(bool, Vec<[f32; 4]>)>,
1948 pub clip_path_svg: Option<(bool, String)>,
1949 pub clip_ref_inset: Option<[f32; 4]>,
1950 pub on_pointer_enter: Option<Msg>,
1951 pub on_pointer_leave: Option<Msg>,
1952 pub on_pointer_move_at: Option<ClickAtFn<Msg>>,
1953 pub on_scroll: Option<ScrollFn<Msg>>,
1954 /// Handler de scroll con reparto parcial. Ver [`ScrollTakeFn`].
1955 pub on_scroll_take: Option<ScrollTakeFn<Msg>>,
1956 /// Handler de gesto de escala (pinch-to-zoom) de este nodo. Ver
1957 /// [`View::on_scale`] y [`ScaleFn`].
1958 pub on_scale: Option<ScaleFn<Msg>>,
1959 /// Handler de gesto de rotación (trackpad) de este nodo. Ver
1960 /// [`View::on_rotate`] y [`RotateFn`].
1961 pub on_rotate: Option<RotateFn<Msg>>,
1962 /// Handlers de doble-tap (ver [`View::on_double_tap`]).
1963 pub on_double_tap: Option<Msg>,
1964 pub on_double_tap_at: Option<ClickAtFn<Msg>>,
1965 /// Ver [`ViewRare::double_tap_exclusive`]: el runtime lo lee en el press
1966 /// para saber si retiene el click del primer tap.
1967 pub double_tap_exclusive: Option<()>,
1968 /// Handlers de long-press (ver [`View::on_long_press`]).
1969 pub on_long_press: Option<Msg>,
1970 pub on_long_press_at: Option<ClickAtFn<Msg>>,
1971 pub focusable: Option<u64>,
1972 /// Key estable de selección de texto (ver [`View::selectable`]).
1973 pub text_select_key: Option<u64>,
1974 pub alpha: Option<f32>,
1975 pub anim: Option<Anim>,
1976 /// Animación implícita de tamaño (ver [`View::animated_size`]). El
1977 /// runtime ya parchó `style.size` antes del layout — este campo se
1978 /// guarda principalmente para inspección/tests.
1979 pub animated_size: Option<SizeAnim>,
1980 /// Semántica accesible del nodo (ver [`View::semantics`]). El runtime la
1981 /// lee en cada paint para reconstruir el árbol AccessKit del frame.
1982 pub semantics: Option<SemanticsSpec>,
1983 /// Marca de hero shared-element (ver [`View::hero`]). El runtime lo lee
1984 /// en [`HeroRegistry::reconcile`] para enlazar identidad entre frames y
1985 /// escribir `transform` con la afín "fly" cuando el rect cambia.
1986 pub hero: Option<Hero>,
1987 /// Subescena a pintar **DEBAJO** del contenido de este nodo, en su
1988 /// posición z (y dentro del clip/transform de sus ancestros). La escribe
1989 /// el runtime — [`AnimRegistry::prepare_underlays`]: el fantasma del
1990 /// contenido viejo de un `switch` con `exit_under` — no el `View`. El
1991 /// paint la apendea componiendo la afín acumulada de los ancestros,
1992 /// ANTES del transform/alpha propios del nodo (que pertenecen al
1993 /// contenido NUEVO).
1994 pub underlay: Option<Lienzo>,
1995 /// Transformación afín 2D del nodo (alrededor del centro de su rect).
1996 /// Ver [`View::transform`]. `paint` la compone con la del padre.
1997 pub transform: Option<Affine>,
1998 /// Traslación relativa al tamaño del nodo (fracciones de su rect). Ver
1999 /// [`View::transform_rel`]. `paint`/`hit_test` la resuelven contra el rect.
2000 pub transform_rel: Option<(f64, f64)>,
2001 /// Pivote de `transform` (CSS `transform-origin`). `None` ⇒ centro. Ver
2002 /// [`TransformPivot`] / [`View::transform_origin`].
2003 pub transform_origin: Option<TransformPivot>,
2004 /// `position: sticky`: insets `[top, right, bottom, left]` px relativos al
2005 /// scrollport. Ver [`View::sticky`]. `paint` lo resuelve con los rects
2006 /// computados (el scroll ya está en el layout). `None` ⇒ no-sticky.
2007 pub sticky: Option<[Option<f32>; 4]>,
2008 /// Texto de tooltip de este nodo (ver [`View::tooltip`]). El consumidor lo
2009 /// lee tras un hit-test de hover para pintar el rótulo flotante.
2010 pub tooltip: Option<String>,
2011 /// Forma del puntero sobre este nodo (ver [`View::cursor`]). El runtime la
2012 /// resuelve heredando del ancestro más cercano que la declare.
2013 pub cursor: Option<Cursor>,
2014 /// Ripple/InkWell de este nodo (ver [`View::ripple`]). El runtime lo
2015 /// dispara en el press y lo pinta vía [`RippleRegistry`].
2016 pub ripple: Option<Ripple>,
2017 /// `true` si este nodo era un [`View::layout_builder`] (constructor diferido)
2018 /// al montarse. El runtime lo usa tras la primera pasada de layout para leer
2019 /// el rect del slot (vía [`collect_builder_constraints`]) e invocar la
2020 /// closure. Tras expandirse, el nodo final ya es normal (`false`).
2021 pub is_layout_builder: bool,
2022 /// **Backdrop blur** (CSS `backdrop-filter: blur(N)` / Flutter
2023 /// `BackdropFilter`). Sigma del Gauss en pixels; el runtime aplica una
2024 /// pasada separable (H+V) sobre la intermediate restringida al rect del
2025 /// nodo, **antes** de pintar el subárbol del nodo. El subárbol se compone
2026 /// sobre el backdrop ya borroso vía un buffer secundario. `None` = sin
2027 /// blur (la abrumadora mayoría). Limitación v1: el nodo no debe estar
2028 /// dentro de un ancestro con clip/alpha (los subárboles separados pintan
2029 /// fuera de esas capas — documentado en `PARIDAD-FLUTTER.md` Bloque 11).
2030 pub backdrop_blur: Option<f32>,
2031 /// Filtros CSS (`filter: …`) sobre el propio subárbol (ver [`View::filter`]
2032 /// / [`FilterOp`]). El runtime los recolecta con [`collect_filters`] y los
2033 /// aplica como post-pasada GPU sobre la intermediate, restringidos al rect
2034 /// del nodo, **después** de la rasterización. Vacío = sin filtro. Fase
2035 /// 7.1232.
2036 pub filter: Vec<FilterOp>,
2037 /// Modo de mezcla del nodo entero contra su backdrop (CSS `mix-blend-mode`).
2038 /// Ver [`View::blend`] / [`MountedNode`]. `paint_range` abre una capa de
2039 /// blend (`push_layer(bm, …)`) alrededor del rect del nodo que envuelve
2040 /// fill + contenido + hijos y se cierra al fin del subárbol, mezclando el
2041 /// resultado contra lo ya pintado. `None` = source-over. Fase 7.1237.
2042 pub blend: Option<BlendMode>,
2043 /// Key de [`View::repaint_boundary`] si este nodo abre un límite de
2044 /// repintado cacheable. `None` = normal. Lo consume `paint_cached`.
2045 pub repaint_boundary: Option<u64>,
2046 /// Key de [`View::memo`] si este nodo es un marcador de subárbol memoizado
2047 /// (Bloque 25). El runtime lo splica tras el layout. `None` = normal.
2048 pub memo_ref: Option<u64>,
2049 /// Índice (exclusivo) del fin del subárbol en `Mounted::nodes`. Los
2050 /// descendientes ocupan `[idx + 1, subtree_end)`. Hace de "barrera" en
2051 /// paint/hit_test para `pop_layer` y para saltar subárboles enteros.
2052 pub subtree_end: usize,
2053}
2054
2055#[cfg(test)]
2056mod tamanos {
2057 use super::*;
2058
2059 /// Guarda de regresión sobre el tamaño de los dos tipos que se asignan una
2060 /// vez POR NODO en cada frame. El contador de asignaciones de Bloque 21
2061 /// (`LLIMPHI_PERF` + `perf-alloc`) mostró que el heap por frame es ~6 KB por
2062 /// nodo y que el 96 % de esos bytes son `View` + `MountedNode`: no son
2063 /// muchas asignaciones, son POCAS y ENORMES (un `Vec` de hijos de una
2064 /// columna de 71 nodos pesa ~170 KB). El costo no está en el número de
2065 /// viajes al allocator sino en el `size_of` de estos structs, así que
2066 /// cualquier variante gorda que se agregue sin boxear se paga multiplicada
2067 /// por el árbol entero.
2068 ///
2069 /// Los topes son generosos a propósito: esto no persigue un número exacto,
2070 /// avisa cuando alguien duplica el struct sin darse cuenta.
2071 #[test]
2072 fn view_y_mounted_no_engordan_en_silencio() {
2073 let view = core::mem::size_of::<View<()>>();
2074 let mounted = core::mem::size_of::<MountedNode<()>>();
2075 eprintln!("size_of::<View<()>>() = {view} B · size_of::<MountedNode<()>>() = {mounted} B");
2076 // Desglose de los campos candidatos a boxear (palanca 2). `cargo test -p
2077 // llimphi-compositor tamanos -- --nocapture` lo imprime.
2078 macro_rules! p {
2079 ($($t:ty),* $(,)?) => {$(
2080 eprintln!(" {:>5} B {}", core::mem::size_of::<$t>(), stringify!($t));
2081 )*};
2082 }
2083 eprintln!(" {:>5} B ViewRare<()>", core::mem::size_of::<ViewRare<()>>());
2084 p!(
2085 Style,
2086 Option<TextSpec>,
2087 Option<Gradient>,
2088 Option<Image>,
2089 Option<Shadow>,
2090 Option<Border>,
2091 Option<SemanticsSpec>,
2092 Option<Anim>,
2093 Option<SizeAnim>,
2094 Option<Ripple>,
2095 Option<Hero>,
2096 Option<MemoNode<()>>,
2097 Option<[f32; 14]>,
2098 Vec<FilterOp>,
2099 Vec<View<()>>,
2100 );
2101 // El tope de `View` es apretado a propósito: 2026-07-28 el reparto
2102 // caliente/[`ViewRare`] lo bajó de 2.472 B a 632, y después el censo
2103 // contra un árbol REAL (`llimphi-gallery --censo`) devolvió inline los
2104 // cuatro campos que la mayoría de los nodos usa igual —`text`,
2105 // `painter`, `alpha`, `semantics`—, dejándolo en 920. De esos 920 son
2106 // 544 el `Style` de taffy. Cualquier prop nueva va a `ViewRare` salvo
2107 // que el censo diga otra cosa; este assert es lo que lo hace cumplir.
2108 assert!(view <= 1024, "View<Msg> engordó a {view} B (tope 1024: ¿la prop nueva va en ViewRare?)");
2109 assert!(mounted <= 3072, "MountedNode<Msg> engordó a {mounted} B (tope 3072)");
2110 }
2111}