Skip to main content

aylis_core/
handles.rs

1//! O apoio do acesso tipado gerado (`self.edtNome.set_text(ui, ...)`): cada componente de um
2//! form é um handle com o `ComponentId` dele, resolvido uma vez ao abrir o form. Ler e
3//! gravar não falham calados: a falha (o componente foi liberado, o valor não serve) aparece
4//! no log em modo dev e vai para a atividade do app (a gravação, o relato). Quem quer tratar
5//! usa os `try_` do [`Handle`].
6
7use crate::activity::Activity;
8use crate::component::ComponentId;
9use crate::error::Result;
10use crate::prop::PropValue;
11use crate::ui::Ui;
12
13/// Um componente de um form, pelo id (o que o código gerado cria para cada um).
14pub trait Handle: Copy {
15    fn id(&self) -> ComponentId;
16
17    /// Lê a propriedade, com o erro (componente liberado, propriedade que a classe não tem).
18    fn try_get(&self, ui: &Ui, prop: &str) -> Result<PropValue> {
19        ui.get_prop(self.id(), prop)
20    }
21
22    /// Grava a propriedade, com o erro (o valor não serve, o componente foi liberado).
23    fn try_set(&self, ui: &mut Ui, prop: &str, value: impl Into<PropValue>) -> Result<()> {
24        ui.set_prop(self.id(), prop, value)
25    }
26
27    /// Chama um método do componente, com o erro.
28    fn try_invoke(&self, ui: &mut Ui, method: &str, args: &[PropValue]) -> std::result::Result<PropValue, String> {
29        ui.invoke(self.id(), method, args)
30    }
31}
32
33/// Uma cor para o acesso tipado (`set_fill`): a cor ([`crate::Color`]) ou um nome do tema
34/// ([`ColorRef::token`]), que acompanha a troca de tema.
35#[derive(Clone, Debug, PartialEq)]
36pub struct ColorRef(PropValue);
37
38impl ColorRef {
39    /// Um nome de cor do tema ou do projeto (`primary`, `primary/40`).
40    pub fn token(name: &str) -> Self {
41        Self(PropValue::String(name.trim().to_string()))
42    }
43}
44
45impl From<crate::Color> for ColorRef {
46    fn from(c: crate::Color) -> Self {
47        Self(PropValue::Color(c))
48    }
49}
50
51impl From<ColorRef> for PropValue {
52    fn from(c: ColorRef) -> Self {
53        c.0
54    }
55}
56
57/// Uma referência a outro componente no acesso tipado (`set_popup_menu(ui, self.pmMenu)`):
58/// um handle qualquer, um id ou [`Ref::NONE`] (nenhum).
59#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
60pub struct Ref(pub Option<ComponentId>);
61
62impl Ref {
63    pub const NONE: Ref = Ref(None);
64}
65
66impl<H: Handle> From<H> for Ref {
67    fn from(h: H) -> Self {
68        Ref(Some(h.id()))
69    }
70}
71
72impl From<ComponentId> for Ref {
73    fn from(id: ComponentId) -> Self {
74        Ref(Some(id))
75    }
76}
77
78impl From<Option<ComponentId>> for Ref {
79    fn from(id: Option<ComponentId>) -> Self {
80        Ref(id)
81    }
82}
83
84impl From<Ref> for PropValue {
85    fn from(r: Ref) -> Self {
86        PropValue::Component(r.0)
87    }
88}
89
90/// Lê um enum (o primeiro valor, se o que está lá não for um dos nomes).
91pub fn read_enum<E: crate::prop::PropEnum>(ui: &Ui, id: ComponentId, prop: &str) -> E {
92    read(ui, id, prop).and_then(|v| v.to_enum::<E>().ok()).or_else(|| E::from_index(0)).expect("enum sem valores")
93}
94
95/// Lê um conjunto de enums (os nomes que não são do enum ficam de fora).
96pub fn read_set<E: crate::prop::PropEnum>(ui: &Ui, id: ComponentId, prop: &str) -> Vec<E> {
97    let names: Vec<String> = match read(ui, id, prop) {
98        Some(PropValue::Set(names)) => names,
99        Some(PropValue::String(s) | PropValue::Enum(s)) => s.split(',').map(|p| p.trim().to_string()).filter(|p| !p.is_empty()).collect(),
100        _ => Vec::new(),
101    };
102    names.iter().filter_map(|n| E::from_name(n)).collect()
103}
104
105/// Um conjunto de enums como a tela grava.
106pub fn set_value<E: crate::prop::PropEnum>(values: &[E]) -> PropValue {
107    PropValue::Set(values.iter().map(|v| v.name().to_string()).collect())
108}
109
110fn read_text(ui: &Ui, id: ComponentId, prop: &str) -> String {
111    read(ui, id, prop).and_then(|v| v.to_str().ok().map(str::to_string)).unwrap_or_default()
112}
113
114/// Lê uma data (`None`: vazia ou inválida).
115pub fn read_date(ui: &Ui, id: ComponentId, prop: &str) -> Option<crate::Date> {
116    crate::Date::parse_iso(&read_text(ui, id, prop))
117}
118
119/// Lê uma hora (`None`: vazia ou inválida).
120pub fn read_time(ui: &Ui, id: ComponentId, prop: &str) -> Option<crate::Time> {
121    crate::Time::parse_iso(&read_text(ui, id, prop))
122}
123
124/// Lê o dia e a hora (`None`: vazio ou inválido).
125pub fn read_datetime(ui: &Ui, id: ComponentId, prop: &str) -> Option<crate::DateTime> {
126    crate::DateTime::parse_iso(&read_text(ui, id, prop))
127}
128
129/// A data como a tela grava (`None`: vazia).
130pub fn date_value(value: Option<crate::Date>) -> PropValue {
131    PropValue::String(value.map(|d| d.to_string()).unwrap_or_default())
132}
133
134/// A hora como a tela grava: `HH:MM`, com os segundos só quando há (`None`: vazia).
135pub fn time_value(value: Option<crate::Time>) -> PropValue {
136    PropValue::String(value.map(time_text).unwrap_or_default())
137}
138
139/// O dia e a hora como a tela grava (`2026-11-12T14:30`; `None`: vazio).
140pub fn datetime_value(value: Option<crate::DateTime>) -> PropValue {
141    PropValue::String(value.map(|d| format!("{}T{}", d.date, time_text(d.time))).unwrap_or_default())
142}
143
144fn time_text(t: crate::Time) -> String {
145    if t.second() == 0 { format!("{:02}:{:02}", t.hour(), t.minute()) } else { format!("{:02}:{:02}:{:02}", t.hour(), t.minute(), t.second()) }
146}
147
148/// Os itens de uma lista separada por `;` (vazia: nenhum).
149fn items(text: &str) -> impl Iterator<Item = &str> {
150    text.split(';').map(str::trim).filter(|s| !s.is_empty())
151}
152
153/// Lê uma lista de textos (`a;b;c`).
154pub fn read_list(ui: &Ui, id: ComponentId, prop: &str) -> Vec<String> {
155    items(&read_text(ui, id, prop)).map(str::to_string).collect()
156}
157
158/// Lê uma lista de números (`0.4;0.9`; o que não é número fica de fora).
159pub fn read_numbers(ui: &Ui, id: ComponentId, prop: &str) -> Vec<f64> {
160    items(&read_text(ui, id, prop)).filter_map(|s| s.parse().ok()).collect()
161}
162
163/// Lê uma lista de cores (`#FF0000;#00AA00`; o que não é cor fica de fora).
164pub fn read_colors(ui: &Ui, id: ComponentId, prop: &str) -> Vec<crate::Color> {
165    items(&read_text(ui, id, prop)).filter_map(crate::Color::from_hex).collect()
166}
167
168/// Uma lista de textos como a tela grava.
169pub fn list_value<S: AsRef<str>>(values: &[S]) -> PropValue {
170    PropValue::String(values.iter().map(|s| s.as_ref()).collect::<Vec<_>>().join(";"))
171}
172
173/// Uma lista de números como a tela grava.
174pub fn numbers_value(values: &[f64]) -> PropValue {
175    PropValue::String(values.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(";"))
176}
177
178/// Uma lista de cores como a tela grava.
179pub fn colors_value(values: &[crate::Color]) -> PropValue {
180    PropValue::String(values.iter().map(|c| c.to_hex()).collect::<Vec<_>>().join(";"))
181}
182
183/// Lê a sombra (`None`: sem sombra).
184pub fn read_shadow(ui: &Ui, id: ComponentId, prop: &str) -> Option<crate::Shadow> {
185    crate::Shadow::parse(&read_text(ui, id, prop))
186}
187
188/// A sombra como a tela grava (`None`: sem sombra).
189pub fn shadow_value(value: Option<crate::Shadow>) -> PropValue {
190    PropValue::String(value.map(|s| s.to_spec()).unwrap_or_default())
191}
192
193/// Lê a curva (a linear, se o texto não é uma curva).
194pub fn read_easing(ui: &Ui, id: ComponentId, prop: &str) -> crate::Easing {
195    crate::Easing::parse(&read_text(ui, id, prop)).unwrap_or_default()
196}
197
198/// A curva como a tela grava (`out_quad`, `cubic-bezier(...)`).
199pub fn easing_value(value: crate::Easing) -> PropValue {
200    PropValue::String(value.to_spec())
201}
202
203/// Lê os pontos `x,y` separados por espaço (os que não são pontos ficam de fora).
204pub fn read_points(ui: &Ui, id: ComponentId, prop: &str) -> Vec<crate::PointF> {
205    read_text(ui, id, prop)
206        .split_whitespace()
207        .filter_map(|p| {
208            let (x, y) = p.split_once(',')?;
209            Some(crate::PointF::new(x.trim().parse().ok()?, y.trim().parse().ok()?))
210        })
211        .collect()
212}
213
214/// Os pontos como a tela grava (`0.5,0 1,1 0,1`).
215pub fn points_value(values: &[crate::PointF]) -> PropValue {
216    PropValue::String(values.iter().map(|p| format!("{},{}", p.x, p.y)).collect::<Vec<_>>().join(" "))
217}
218
219/// Lê a referência a outro componente (`None`: nenhum).
220pub fn read_ref(ui: &Ui, id: ComponentId, prop: &str) -> Option<ComponentId> {
221    read(ui, id, prop).and_then(|v| v.to_component().ok().flatten())
222}
223
224/// Lê a propriedade; a falha vai para o log em modo dev (a leitura não tem como avisar a
225/// atividade: ela só vê o `Ui`).
226pub fn read(ui: &Ui, id: ComponentId, prop: &str) -> Option<PropValue> {
227    match ui.get_prop(id, prop) {
228        Ok(v) => Some(v),
229        Err(e) => {
230            if cfg!(debug_assertions) {
231                crate::stderr_line!("aylis: ler {}.{prop}: {e}", ui.path_of(id));
232            }
233            None
234        }
235    }
236}
237
238/// Grava a propriedade; a falha vai para o log em modo dev e para a atividade do app.
239pub fn write(ui: &mut Ui, id: ComponentId, prop: &str, value: impl Into<PropValue>) {
240    if let Err(e) = ui.set_prop(id, prop, value) {
241        failed(ui, id, &format!("gravar {prop}"), &e.to_string());
242    }
243}
244
245/// Chama um método; a falha vai para o log em modo dev e para a atividade do app.
246pub fn call(ui: &mut Ui, id: ComponentId, method: &str, args: &[PropValue]) -> Option<PropValue> {
247    match ui.invoke(id, method, args) {
248        Ok(v) => Some(v),
249        Err(e) => {
250            failed(ui, id, &format!("chamar {method}"), &e.to_string());
251            None
252        }
253    }
254}
255
256/// Chama um método e devolve o erro (o que os métodos do acesso tipado usam: `save_to`
257/// volta `Err` com o motivo, não um `false`); a falha também vai para o log em modo dev e
258/// para a atividade do app.
259pub fn try_call(ui: &mut Ui, id: ComponentId, method: &str, args: &[PropValue]) -> std::result::Result<PropValue, String> {
260    ui.invoke(id, method, args).inspect_err(|e| failed(ui, id, &format!("chamar {method}"), e))
261}
262
263fn failed(ui: &mut Ui, id: ComponentId, what: &str, error: &str) {
264    let message = format!("{what} em {}: {error}", ui.path_of(id));
265    if cfg!(debug_assertions) {
266        crate::stderr_line!("aylis: {message}");
267    }
268    ui.report(&Activity::Error { message: &message });
269}
270
271/// O valor como texto (a cor em `#RRGGBB`, a referência pelo caminho).
272pub fn text(ui: &Ui, value: Option<PropValue>) -> String {
273    match value {
274        Some(PropValue::Color(c)) => c.to_hex(),
275        Some(PropValue::Component(Some(id))) => ui.path_of(id),
276        // `margins`/`padding` e `anchors` como o `set_` aceita: "12, 4, 12, 0" e "left,top".
277        Some(PropValue::Bounds(b)) => format!("{}, {}, {}, {}", b.left, b.top, b.right, b.bottom),
278        Some(PropValue::Set(names)) => names.join(","),
279        Some(v) => v.to_str().map(str::to_string).unwrap_or_default(),
280        None => String::new(),
281    }
282}
283
284/// Resolve o componente `name` de classe `class` no form `root` para a struct do form
285/// gerada; o que não bate vai para `problems` (e o form não abre).
286pub fn resolve(ui: &Ui, root: ComponentId, name: &str, class: &str, problems: &mut Vec<String>) -> ComponentId {
287    match ui.find_in(root, name) {
288        Some(id) => {
289            let actual = ui.class_name(id).unwrap_or_default();
290            if actual != class {
291                problems.push(format!("{name} é {actual} no form e {class} no código"));
292            }
293            id
294        }
295        None => {
296            problems.push(format!("falta o componente {name} ({class})"));
297            root
298        }
299    }
300}