aura-gui 0.1.0

UI nativa acelerada por GPU para escritorio, Android e iOS, en un solo crate: estilo tipo Tailwind, componentes, sombras, animaciones y agentes de IA. Reposo a cero. Licencia AGPL-3.0 o comercial.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! Estado por frame de la ventana: árbol de layout, escena, hitboxes y despacho,
//! más el ratón y el texto heredado que consultan los elementos.

use crate::view::dispatch::DispatchTree;
use crate::view::interactivity::HandlerEntry;
use crate::view::overlay::DeferredOverlay;
use crate::view::text_layout::TextLeaf;
use crate::view::theme::{ColorSpec, Token};
use crate::core::{Bounds, HitboxId, HitboxRegistry, Pixels, Point};
use crate::gpu::Scene;
use rustc_hash::FxHashMap;
use smallvec::SmallVec;
use std::rc::Rc;
use taffy::TaffyTree;

/// Datos que se conservan entre fases y se recrean cada frame.
pub struct FrameState {
    pub taffy: TaffyTree<TextLeaf>,
    pub scene: Scene,
    pub hitboxes: HitboxRegistry,
    pub handlers: Vec<HandlerEntry>,
    pub dispatch: DispatchTree,
    pub deferred: Vec<DeferredOverlay>,
    /// Rectángulo del cursor de texto enfocado, para colocar la ventana del IME.
    pub ime_area: Option<Bounds>,
    pub wants_animation_frame: bool,
    /// Elementos visibles para lectores de pantalla (solo se llena si `access_enabled`).
    pub access: Vec<crate::view::accessibility::AccessNode>,
    pub access_enabled: bool,
    /// Hitboxes de cada grupo con nombre, para `group_hover`.
    pub groups: FxHashMap<Rc<str>, SmallVec<[HitboxId; 2]>>,
}

impl Default for FrameState {
    fn default() -> Self {
        Self {
            taffy: TaffyTree::new(),
            scene: Scene::default(),
            hitboxes: HitboxRegistry::default(),
            handlers: Vec::new(),
            dispatch: DispatchTree::default(),
            deferred: Vec::new(),
            ime_area: None,
            wants_animation_frame: false,
            access: Vec::new(),
            access_enabled: false,
            groups: FxHashMap::default(),
        }
    }
}

impl FrameState {
    pub fn begin(&mut self) {
        self.taffy.clear();
        self.scene.clear();
        self.hitboxes.clear();
        self.handlers.clear();
        self.dispatch.clear();
        self.deferred.clear();
        self.ime_area = None;
        self.wants_animation_frame = false;
        self.access.clear();
        self.groups.clear();
    }
}

#[derive(Clone, Copy, Debug)]
pub struct MouseState {
    pub position: Point,
    pub pressed: Option<HitboxId>,
}

impl MouseState {
    /// Antes del primer evento el puntero no está sobre ningún elemento.
    pub const OUTSIDE: MouseState = MouseState { position: Point::new(Pixels(-1.0e6), Pixels(-1.0e6)), pressed: None };
}

/// Propiedades de texto que los descendientes heredan, como en CSS.
#[derive(Clone, Copy)]
pub struct InheritedText {
    pub color: ColorSpec,
    pub size: Pixels,
    pub bold: bool,
    pub italic: bool,
    pub underline: bool,
    pub wrap: bool,
}

impl Default for InheritedText {
    fn default() -> Self {
        Self { color: Token::Text.into(), size: Pixels(14.0), bold: false, italic: false, underline: false, wrap: true }
    }
}