Skip to main content

aylis_core/
input.rs

1//! Despacho de entrada: ponteiro (mouse/toque), roda, teclado e foco.
2//!
3//! A plataforma traduz os eventos nativos e chama os métodos `pointer_*`, `wheel`,
4//! `key_*` e `text_input` do [`Ui`], sempre informando o form (raiz) e posições em
5//! coordenadas do form. O `Ui` encontra o controle certo, atualiza os estados (hover,
6//! pressed, focused), chama os métodos do componente e dispara os eventos públicos
7//! (`on_click`, `on_pointer_down`...).
8//!
9//! Regras:
10//! - o controle sob o ponteiro é o mais de cima com `hit_test = true`; controles com
11//!   `hit_test = false` deixam o ponteiro passar para os filhos e para o que está atrás;
12//! - controles desabilitados (ou com algum ancestral desabilitado) não recebem eventos;
13//! - ao pressionar o botão principal, o controle "captura" o ponteiro: recebe os
14//!   movimentos e o soltar mesmo fora dele;
15//! - o clique só acontece se o botão for solto sobre o mesmo controle;
16//! - a roda vai para o controle sob o ponteiro e sobe para os pais até alguém tratar;
17//! - o teclado vai para o controle com foco e sobe para os pais até alguém tratar;
18//!   Tab / Shift+Tab, se ninguém tratar, movem o foco;
19//! - no toque, arrastar o dedo além de alguns pontos vira rolagem: o controle tocado
20//!   perde o toque (não há clique) e o deslocamento vai como roda (`touch = true`) para
21//!   o ScrollBox/DataGrid de baixo; ao soltar com o dedo em movimento, a rolagem continua
22//!   por inércia. Controles com `pan_on_touch` desligado recebem o arrasto normalmente;
23//! - no toque, o foco muda ao soltar (um toque), não ao encostar: começar a rolar em
24//!   cima de um campo de texto não abre o teclado.
25//! - arrastar e soltar entre controles:
26//!   num controle `draggable` (ou dentro dele), passar de [`DRAG_START`] pontos com o
27//!   botão principal pressionado dispara `on_drag_start`; se o handler chamar
28//!   [`Ui::begin_drag`], o arrasto começa (sem clique ao soltar). O destino é o controle
29//!   `accepts_drops` sob o mouse (ou o pai mais próximo que aceite): `on_drag_over` ao
30//!   entrar (recusar com [`Ui::reject_drop`]), `on_drag_drop` ao soltar nele; a origem
31//!   recebe `on_drag_end` (`true` se foi solto num destino). Esc cancela.
32
33use crate::anim::Trigger;
34use crate::component::{Component, ComponentId};
35use crate::event::{EventArgs, EventCtx, Key, KeyEvent, PointerButton, PointerEvent, PointerKind, WheelEvent};
36use crate::geometry::{PointF, RectF, SizeF};
37use crate::platform::CursorShape;
38use crate::ui::Ui;
39
40/// Intervalo máximo entre cliques para contar como duplo clique, em segundos.
41const DOUBLE_CLICK_TIME: f64 = 0.5;
42/// Distância máxima entre cliques para contar como duplo clique.
43const DOUBLE_CLICK_DISTANCE: f32 = 4.0;
44/// Quanto o mouse anda, com o botão pressionado num controle `draggable`, até o arrasto começar.
45pub const DRAG_START: f32 = 5.0;
46
47/// O começo dos dados do arrasto de uma janela inteira (`Ui::window_drag_over`): depois dele,
48/// o id do form.
49pub const FORM_DRAG: &str = "aylis-form:";
50/// Quanto o dedo anda antes de o toque virar rolagem.
51const TOUCH_SLOP: f32 = 8.0;
52/// O deslizar (`on_swipe`): o dedo anda pelo menos isto, saindo a pelo menos esta velocidade
53/// (pontos por segundo), sem ter rolado mais que isto no mesmo eixo.
54const SWIPE_DISTANCE: f32 = 32.0;
55const SWIPE_SPEED: f32 = 250.0;
56const SWIPE_SCROLLED: f32 = 4.0;
57/// A faixa da borda do form em que um deslizar abre a gaveta (fora dela, o gesto de voltar do
58/// Android, que pega a borda de fora, não briga com o app).
59const EDGE_SWIPE: f32 = 32.0;
60/// Inércia: abaixo desta velocidade (unidades por segundo) a rolagem para...
61const FLING_MIN_SPEED: f32 = 40.0;
62/// ...e a velocidade cai por este fator exponencial por segundo.
63const FLING_DECAY: f32 = 3.5;
64
65/// O dedo que comanda o toque (rolagem, clique). Dois dedos viram pinça ([`Pinch`]).
66#[derive(Clone, Copy, Debug)]
67struct Touch {
68    id: u64,
69    /// Controle tocado: a rolagem começa nele e sobe para os pais, mesmo que o conteúdo
70    /// passe por baixo do dedo.
71    target: Option<ComponentId>,
72    start: PointF,
73    last: PointF,
74    time: f64,
75    panning: bool,
76    velocity: PointF,
77    /// Quanto o arrasto rolou alguma coisa em cada eixo: o deslizar só vale no eixo em que
78    /// nada rolou (senão era rolagem).
79    scrolled: PointF,
80}
81
82/// Botão (ou dedo) segurado: vira toque longo se ficar parado.
83#[derive(Clone, Copy, Debug)]
84struct Press {
85    target: ComponentId,
86    /// Posição no form.
87    position: PointF,
88    time: f64,
89    touch: bool,
90    /// Já disparou: o soltar não gera clique.
91    fired: bool,
92    /// O toque longo abriu um menu: o soltar do dedo é dele (não dá o foco ao controle, que
93    /// fecharia o menu, nem escolhe o item que ficou embaixo do dedo).
94    menu: bool,
95}
96
97/// Rolagem por inércia depois de soltar o dedo.
98#[derive(Clone, Copy, Debug)]
99struct Fling {
100    target: Option<ComponentId>,
101    position: PointF,
102    velocity: PointF,
103    time: f64,
104}
105
106fn speed(v: PointF) -> f32 {
107    (v.x * v.x + v.y * v.y).sqrt()
108}
109
110/// Estado de entrada de um form.
111#[derive(Clone, Debug, Default)]
112pub(crate) struct InputState {
113    /// O controle com arquivos do sistema passando por cima ([`Ui::files_hover`]).
114    pub(crate) file_hover: Option<ComponentId>,
115    /// Onde caíram os últimos arquivos soltos no form ([`Ui::files_drop_position`]).
116    drop_at: Option<PointF>,
117    hovered: Option<ComponentId>,
118    captured: Option<ComponentId>,
119    focused: Option<ComponentId>,
120    /// O foco veio de um clique ou toque (não do teclado): o anel de foco só aparece nos
121    /// campos de texto, como o `:focus-visible` dos navegadores.
122    pointer_focus: bool,
123    /// Último clique: controle, tempo, posição, contagem.
124    last_click: Option<(ComponentId, f64, PointF, u8)>,
125    touch: Option<Touch>,
126    fling: Option<Fling>,
127    press: Option<Press>,
128    pub(crate) hint: Option<HintState>,
129    /// Os dedos na tela agora (id, posição no form).
130    fingers: Vec<(u64, PointF)>,
131    pinch: Option<Pinch>,
132    /// Um gesto de dois dedos acabou e ainda há dedo na tela: ele não vira toque.
133    after_pinch: bool,
134    /// Arrasto entre controles em andamento.
135    pub(crate) drag: Option<Drag>,
136    /// Onde o mouse está no form (`None`: fora dele, ou o toque): a luz do Reveal Highlight.
137    pub(crate) pointer: Option<PointF>,
138    /// Uma tecla espera a resposta do backend (`on_key_down`/`on_key_press` remotos): as que
139    /// chegam ficam em `held`, em ordem (veja `keyflow.rs`).
140    pub(crate) holding: bool,
141    pub(crate) held: std::collections::VecDeque<crate::keyflow::Held>,
142    /// Entregando a fila agora (o que ela entrega não volta para ela).
143    pub(crate) draining: bool,
144    /// O último pressionar foi recusado (o backend ocupado): o soltar dele não vira clique.
145    pub(crate) refused_press: bool,
146}
147
148/// Um arrasto entre controles: a origem, o que vai (texto livre do app), o rótulo que
149/// acompanha o mouse e o destino sob ele.
150#[derive(Clone, Debug)]
151pub(crate) struct Drag {
152    pub(crate) source: ComponentId,
153    pub(crate) data: String,
154    pub(crate) label: String,
155    /// Posição do mouse no form.
156    pub(crate) position: PointF,
157    pub(crate) target: Option<ComponentId>,
158    pub(crate) accepted: bool,
159    /// O `on_drag_start` remoto ainda não deu os dados (o número da pergunta).
160    pub(crate) starting: Option<u64>,
161    /// O `on_drag_over` remoto do destino de agora ainda não respondeu.
162    pub(crate) over: Option<(ComponentId, u64)>,
163    /// Soltou antes da resposta: solta quando ela chegar.
164    pub(crate) dropped: bool,
165    /// O que acompanha o cursor (a miniatura do item), além do rótulo.
166    pub(crate) visual: Option<DragVisual>,
167    /// O mouse no form do destino (que pode ser outra janela): para os ganchos `drop_*`.
168    pub(crate) target_position: PointF,
169}
170
171/// Como acabou um arrasto (para o [`Component::drag_ended`](crate::Component::drag_ended) da
172/// origem).
173#[derive(Clone, Copy, Debug, PartialEq, Eq)]
174pub enum DragEnd {
175    /// Soltou num destino que aceitou.
176    Dropped,
177    /// Soltou onde ninguém aceita (fora das janelas do app, inclusive).
178    Nowhere,
179    /// Esc ou a janela perdeu o arrasto.
180    Cancelled,
181}
182
183/// O mouse na tela durante um arrasto: pixels físicos e a escala (pixels por ponto) da
184/// janela onde o arrasto começou.
185#[derive(Clone, Copy, Debug, Default, PartialEq)]
186pub struct ScreenPointer {
187    pub x: i32,
188    pub y: i32,
189    pub scale: f32,
190}
191
192/// O que acompanha o cursor num arrasto: uma imagem (a miniatura de um vídeo, o ícone de um
193/// arquivo), do tamanho pedido, meio transparente, presa ao cursor pelo ponto `hotspot`. No
194/// Windows ela vai numa janela própria e segue o mouse por cima de tudo, fora da janela
195/// também; nos outros sistemas, o form a pinta junto do mouse.
196#[derive(Clone, Debug, PartialEq)]
197pub struct DragVisual {
198    pub image: crate::Image,
199    /// Tamanho na tela, em pontos.
200    pub size: SizeF,
201    /// O ponto da imagem (em pontos, a partir do canto) que fica no cursor.
202    pub hotspot: PointF,
203    /// 0..1.
204    pub opacity: f32,
205}
206
207impl DragVisual {
208    /// A imagem do tamanho `size`, com o cursor um pouco à esquerda e acima do centro (como o
209    /// Explorer) e 80% de opacidade.
210    pub fn new(image: crate::Image, size: SizeF) -> Self {
211        Self { image, size, hotspot: PointF::new(size.width / 2.0, size.height * 0.6), opacity: 0.8 }
212    }
213}
214
215/// Pinça em andamento: o controle que recebe e a medida inicial e anterior dos dedos.
216#[derive(Clone, Copy, Debug)]
217struct Pinch {
218    target: ComponentId,
219    ids: (u64, u64),
220    start_distance: f32,
221    start_angle: f32,
222    last_distance: f32,
223    last_angle: f32,
224    last_center: PointF,
225}
226
227/// Distância, ângulo e centro entre dois pontos.
228fn finger_geometry(a: PointF, b: PointF) -> (f32, f32, PointF) {
229    let d = b - a;
230    ((d.x * d.x + d.y * d.y).sqrt().max(1.0), d.y.atan2(d.x), PointF::new((a.x + b.x) / 2.0, (a.y + b.y) / 2.0))
231}
232
233/// A dica (balão) do controle sob o mouse.
234#[derive(Clone, Copy, Debug, PartialEq)]
235pub(crate) struct HintState {
236    pub(crate) target: ComponentId,
237    pub(crate) since: f64,
238    /// Onde o mouse estava (coordenadas do form).
239    pub(crate) position: PointF,
240    pub(crate) shown: bool,
241}
242
243/// Tempo com o mouse parado em cima até a dica aparecer, em segundos: o padrão, quando nem o
244/// tema (`durations.hint`, em ms) nem o app (`Ui::set_hint_delay`) dizem outro.
245pub const HINT_DELAY: f64 = 1.0;
246
247/// Quanto o mouse pode tremer (em pixels) e ainda contar como parado para a dica.
248const HINT_STILL: f32 = 3.0;
249
250impl InputState {
251    /// Quando a dica pendente deve aparecer.
252    pub(crate) fn hint_due(&self, delay: f64) -> Option<f64> {
253        self.hint.filter(|h| !h.shown).map(|h| h.since + delay)
254    }
255
256    /// Quando o toque longo em andamento vence (se houver).
257    /// Só com o dedo ou a caneta (J18 do Tabernáculo): o mouse não conta, e nem acorda o laço.
258    pub(crate) fn long_press_due(&self) -> Option<f64> {
259        self.press.filter(|p| !p.fired && p.touch).map(|p| p.time + crate::timers::LONG_PRESS_TIME)
260    }
261
262    /// O toque longo venceu: marca como disparado e devolve (alvo, posição, é toque).
263    pub(crate) fn take_long_press(&mut self, now: f64) -> Option<(ComponentId, PointF, bool)> {
264        let p = self.press.as_mut()?;
265        if p.fired || !p.touch || now < p.time + crate::timers::LONG_PRESS_TIME {
266            return None;
267        }
268        p.fired = true;
269        // O botão segurado não fica "pressionado" visualmente depois do toque longo.
270        Some((p.target, p.position, p.touch))
271    }
272
273    /// Esquece componentes liberados.
274    pub(crate) fn forget(&mut self, freed: &[ComponentId]) {
275        let gone = |id: &mut Option<ComponentId>| {
276            if id.is_some_and(|i| freed.contains(&i)) {
277                *id = None;
278            }
279        };
280        gone(&mut self.hovered);
281        gone(&mut self.captured);
282        gone(&mut self.focused);
283        if let Some(t) = &mut self.touch {
284            gone(&mut t.target);
285        }
286        if let Some(f) = &mut self.fling {
287            gone(&mut f.target);
288        }
289        if self.press.is_some_and(|p| freed.contains(&p.target)) {
290            self.press = None;
291        }
292        if self.last_click.is_some_and(|(i, ..)| freed.contains(&i)) {
293            self.last_click = None;
294        }
295    }
296}
297
298impl Ui {
299    fn input_state(&mut self, root: ComponentId) -> &mut InputState {
300        self.input.entry(root).or_default()
301    }
302
303    /// O foco do form veio de um clique ou toque (o anel de foco fica só nos campos de texto).
304    pub(crate) fn focus_from_pointer(&self, root: ComponentId) -> bool {
305        self.input.get(&root).is_some_and(|s| s.pointer_focus)
306    }
307
308    /// O foco do form veio do teclado (Tab, atalho): o anel de foco aparece, como o
309    /// `:focus-visible` do CSS (o relatório do Tabernáculo, J08).
310    pub fn focus_visible(&self, form: ComponentId) -> bool {
311        !self.focus_from_pointer(self.root_of(form))
312    }
313
314    /// Os menus, listas e camadas abertos por cima do form (a lista de um ComboBox, um menu de
315    /// contexto, um calendário): os que fecham com o clique fora (o relatório do Tabernáculo,
316    /// J09).
317    pub fn open_popups(&self, form: ComponentId) -> Vec<ComponentId> {
318        let root = self.root_of(form);
319        self.children(root).iter().copied().filter(|&c| self.component(c).and_then(|c| c.popup()).is_some_and(|p| p.closes_on_outside_press() || p.dies_with().is_some())).collect()
320    }
321
322    // =====================================================================
323    // Consultas
324    // =====================================================================
325
326    /// Arquivos soltos na janela do form `root` no ponto `pos`: vão para o controle sob o
327    /// ponto e sobem pelos pais até um aceitar ([`Component::files_dropped`]). Se nenhum
328    /// aceitar (o sistema nem sempre informa a posição), o primeiro controle à vista do form
329    /// que aceita arquivos recebe (um escondido ou desabilitado, nem ele nem os filhos: o
330    /// relatório do Tabernáculo, F01). Antes da reserva, o form com handler no
331    /// `on_files_drop` recebe os caminhos (separados por `;`), com o ponto em
332    /// [`Ui::files_drop_position`] (decidido em 21/11: soltar sobre a lista sem uma zona
333    /// visível). Devolve `true` se alguém aceitou.
334    pub fn drop_files(&mut self, root: ComponentId, pos: PointF, paths: Vec<String>) -> bool {
335        let mut target = self.hit_test(root, pos);
336        // Os que já receberam (e recusaram) não recebem de novo na procura de reserva.
337        let mut tried = Vec::new();
338        while let Some(id) = target {
339            if self.with_component(id, |c, ctx| c.platform_hooks_mut().is_some_and(|h| h.files_dropped(ctx, &paths))).unwrap_or(false) {
340                self.process_events();
341                return true;
342            }
343            tried.push(id);
344            target = self.parent(id);
345        }
346        if !paths.is_empty() && self.listens(root, "on_files_drop") {
347            self.input_state(root).drop_at = Some(pos);
348            self.fire(root, "on_files_drop", &EventArgs::Text(paths.join(";")));
349            self.process_events();
350            return true;
351        }
352        let mut stack = vec![root];
353        while let Some(id) = stack.pop() {
354            if self.cb(id).is_some_and(|cb| !cb.visible() || !cb.enabled()) {
355                continue;
356            }
357            if tried.contains(&id) {
358                stack.extend(self.children(id).iter().rev().copied());
359                continue;
360            }
361            if self.with_component(id, |c, ctx| c.platform_hooks_mut().is_some_and(|h| h.files_dropped(ctx, &paths))).unwrap_or(false) {
362                self.process_events();
363                return true;
364            }
365            stack.extend(self.children(id).iter().rev().copied());
366        }
367        // O `on_reject` de quem recusou.
368        self.process_events();
369        false
370    }
371
372    /// Arquivos do sistema passando por cima da janela do form (`Some`) ou saindo dela, soltos
373    /// ou cancelados (`None`): o controle à vista que os receberia fica sabendo, para se
374    /// destacar (o relatório do Tabernáculo, F03).
375    pub fn files_hover(&mut self, root: ComponentId, pos: PointF, paths: Option<Vec<String>>) {
376        let previous = self.input_state(root).file_hover.take();
377        let Some(paths) = paths else {
378            if let Some(old) = previous.filter(|&o| self.contains(o)) {
379                self.with_component(old, |c, ctx| c.platform_hooks_mut().map(|h| h.files_hovering(ctx, None)));
380                self.process_events();
381            }
382            return;
383        };
384        let mut found = None;
385        let mut target = self.hit_test(root, pos);
386        while let Some(id) = target {
387            if self.with_component(id, |c, ctx| c.platform_hooks_mut().is_some_and(|h| h.files_hovering(ctx, Some(&paths)))).unwrap_or(false) {
388                found = Some(id);
389                break;
390            }
391            target = self.parent(id);
392        }
393        if let Some(old) = previous.filter(|&o| Some(o) != found && self.contains(o)) {
394            self.with_component(old, |c, ctx| c.platform_hooks_mut().map(|h| h.files_hovering(ctx, None)));
395        }
396        self.input_state(root).file_hover = found;
397        self.process_events();
398    }
399
400    /// Controle sob o ponto `pos` (coordenadas do form).
401    pub fn hit_test(&self, root: ComponentId, pos: PointF) -> Option<ComponentId> {
402        self.hit_node(root, pos)
403    }
404
405    fn hit_node(&self, id: ComponentId, pos_in_parent: PointF) -> Option<ComponentId> {
406        let cb = self.cb(id)?;
407        if !cb.visible() || (cb.design_only && !self.design_mode) {
408            return None;
409        }
410        let b = cb.bounds();
411        // No espaço de dentro (desfeitos o lugar, o deslocamento, o giro e a escala): o mouse
412        // acerta onde o controle está desenhado (o `translate` de uma animação, da linha
413        // deslizada da lista, da página em transição), como a pintura.
414        let local = unscale(cb, unrotate(cb, pos_in_parent - b.origin() - cb.translate()));
415        let b = RectF::from_size(cb.inner_size());
416        let inside = local.x >= 0.0 && local.y >= 0.0 && local.x < b.width && local.y < b.height;
417        if cb.clip_children() && !inside {
418            return None;
419        }
420        if let Some(hit) = self.children(id).iter().rev().find_map(|&c| self.hit_node(c, local)) {
421            return Some(hit);
422        }
423        let shape = || self.component(id).is_none_or(|c| c.contains_point(local, SizeF::new(b.width, b.height)));
424        // Um pouco além da borda, para quem desenha alças do lado de fora (`hit_slop`).
425        let near = || {
426            let m = self.component(id).map_or(0.0, |c| c.hit_slop());
427            m > 0.0 && local.x >= -m && local.y >= -m && local.x < b.width + m && local.y < b.height + m
428        };
429        // Quem arrasta ou recebe o soltar recebe o mouse mesmo com o `hit_test` desligado (o
430        // padrão do Label): ligar o `draggable` num Label não fazia nada, e nada avisava
431        // (testado em 20/11).
432        let hit = cb.hit_test() || cb.draggable() || cb.accepts_drops();
433        ((inside || near()) && hit && shape()).then_some(id)
434    }
435
436    /// O controle e todos os ancestrais estão visíveis e habilitados.
437    pub fn is_effectively_enabled(&self, id: ComponentId) -> bool {
438        let mut current = Some(id);
439        while let Some(c) = current {
440            if let Some(cb) = self.cb(c) {
441                if !cb.enabled() || !cb.visible() {
442                    return false;
443                }
444            }
445            current = self.parent(c);
446        }
447        self.contains(id)
448    }
449
450    /// Controle sob o ponteiro no form.
451    pub fn hovered(&self, root: ComponentId) -> Option<ComponentId> {
452        self.input.get(&root)?.hovered
453    }
454
455    /// Onde caíram (nas coordenadas do form) os últimos arquivos do `on_files_drop` do form.
456    pub fn files_drop_position(&self, root: ComponentId) -> Option<PointF> {
457        self.input.get(&root)?.drop_at
458    }
459
460    /// O mouse está em `id` ou num dos de dentro dele, e se o de baixo do mouse está apertado
461    /// (o `:hover` e o `:active` do CSS). Veja [`ControlBase::set_hover_within`].
462    pub fn hover_within(&self, id: ComponentId) -> (bool, bool) {
463        let Some(mut cur) = self.hovered(self.root_of(id)) else { return (false, false) };
464        let pressed = self.cb(cur).is_some_and(|cb| cb.state().pressed);
465        loop {
466            if cur == id {
467                return (true, pressed);
468            }
469            match self.parent(cur) {
470                Some(p) => cur = p,
471                None => return (false, false),
472            }
473        }
474    }
475
476    /// Controle com o foco do teclado no form.
477    pub fn focused(&self, root: ComponentId) -> Option<ComponentId> {
478        self.input.get(&root)?.focused
479    }
480
481    /// Cursor a mostrar: o do controle sob o ponteiro ou, se for `Default`, o do pai mais
482    /// próximo que defina um.
483    pub fn cursor(&self, root: ComponentId) -> CursorShape {
484        // O backend ocupado passou do `delay`: o cursor de espera (veja `busy.rs`).
485        if self.busy_cursor() {
486            return CursorShape::Wait;
487        }
488        let mut current = self.hovered(root);
489        while let Some(c) = current {
490            if let Some(cb) = self.cb(c) {
491                if cb.cursor() != CursorShape::Default {
492                    return cb.cursor();
493                }
494            }
495            current = self.parent(c);
496        }
497        CursorShape::Default
498    }
499
500    /// Onde o mouse está no form `root` (`None`: fora dele, ou o toque).
501    pub fn pointer_position(&self, root: ComponentId) -> Option<PointF> {
502        self.input.get(&root).and_then(|s| s.pointer)
503    }
504
505    /// O mouse andou de `before` para `after` (coordenadas do form): os controles com o Reveal
506    /// Highlight perto de um dos dois pontos repintam só a parte que a luz alcança (a de antes
507    /// apaga, a de agora acende). O custo é o dos controles com Reveal pintados, não o do form.
508    pub(crate) fn reveal_moved(&mut self, root: ComponentId, before: Option<PointF>, after: Option<PointF>) {
509        if before == after || self.reveal_ids.borrow().is_empty() {
510            return;
511        }
512        let ids: Vec<(ComponentId, f32)> = self.reveal_ids.borrow().iter().map(|(id, r)| (*id, *r)).collect();
513        for (id, radius) in ids {
514            let Some(cb) = self.cb(id) else {
515                self.reveal_ids.borrow_mut().remove(&id);
516                continue;
517            };
518            let size = cb.inner_size();
519            if self.root_of(id) != root {
520                continue;
521            }
522            let rect = RectF::new(0.0, 0.0, size.width, size.height);
523            for p in [before, after].into_iter().flatten() {
524                let local = self.local_point(id, p);
525                let light = RectF::new(local.x - radius, local.y - radius, radius * 2.0, radius * 2.0);
526                let part = rect.inflate(2.0).intersect(light);
527                if let Some(part) = part.filter(|r| r.width > 0.0 && r.height > 0.0) {
528                    self.damage_part(id, part);
529                }
530            }
531        }
532    }
533
534    /// O ponto `pos` (coordenadas do form) nas coordenadas do controle, desfazendo a
535    /// posição e o giro de cada ancestral e do próprio controle.
536    pub fn local_point(&self, id: ComponentId, pos: PointF) -> PointF {
537        let mut chain = vec![id];
538        let mut parent = self.parent(id);
539        while let Some(p) = parent {
540            chain.push(p);
541            parent = self.parent(p);
542        }
543        let local = chain.iter().rev().fold(pos, |pt, &c| match self.cb(c) {
544            Some(cb) => unscale(cb, unrotate(cb, pt - cb.bounds().origin() - cb.translate())),
545            None => pt,
546        });
547        // Interface espelhada: o controle se desenha virado, então o mouse também vira.
548        match self.cb(id).filter(|_| self.flips_content(id)) {
549            Some(cb) => PointF::new(cb.inner_size().width - local.x, local.y),
550            None => local,
551        }
552    }
553
554    fn enabled_hit(&self, root: ComponentId, pos: PointF) -> Option<ComponentId> {
555        self.hit_test(root, pos).filter(|&id| self.is_effectively_enabled(id))
556    }
557
558    /// Chama um método do componente e devolve se ele marcou o evento como tratado.
559    /// Marca (ou desmarca) `id` no estado `checked` do tema, o mesmo do botão marcado: a linha
560    /// selecionada de uma lista, desenhada pelo estilo dela (os filhos com `inherit_state`
561    /// acompanham).
562    pub fn set_checked_state(&mut self, id: ComponentId, checked: bool) {
563        self.set_state_flag(id, Trigger::Checked, checked);
564    }
565
566    /// Como [`set_checked_state`](Self::set_checked_state), sem animar: as animações `checked`
567    /// vão direto para o fim (ou para o valor original). O item escolhido que volta à tela numa
568    /// linha reciclada chega marcado, sem parecer que acabou de ser escolhido.
569    pub fn set_checked_state_instant(&mut self, id: ComponentId, checked: bool) {
570        self.set_state_flag_with(id, Trigger::Checked, checked, false);
571    }
572
573    pub(crate) fn deliver(&mut self, id: ComponentId, f: impl FnOnce(&mut dyn Component, &mut EventCtx<'_>)) -> bool {
574        self.with_component(id, |c, ctx| {
575            f(c, ctx);
576            ctx.handled()
577        })
578        .unwrap_or(false)
579    }
580
581    fn set_state_flag(&mut self, id: ComponentId, trigger: Trigger, value: bool) {
582        self.set_state_flag_with(id, trigger, value, true);
583    }
584
585    fn set_state_flag_with(&mut self, id: ComponentId, trigger: Trigger, value: bool, animate: bool) {
586        let Some(cb) = self.cb_mut(id) else { return };
587        let state = cb.state_mut();
588        let flag = match trigger {
589            Trigger::Hover => &mut state.hover,
590            Trigger::Pressed => &mut state.pressed,
591            Trigger::Focused => &mut state.focused,
592            Trigger::Checked => &mut state.checked,
593            Trigger::None | Trigger::Appear | Trigger::HoverWithin => return,
594        };
595        if *flag != value {
596            *flag = value;
597            // O desenho dele não depende desse estado (o fundo do form quando o mouse sai de
598            // um botão para ele): nada a repintar.
599            // Um filho que herda o estado muda junto (C25): a área toda dele.
600            let heirs = self.children(id).iter().any(|&c| self.cb(c).is_some_and(|cb| cb.inherit_state()));
601            if heirs || !self.drawing_unchanged(id) {
602                self.damage(id);
603            }
604            if animate {
605                self.run_triggers(id, trigger, value);
606            } else {
607                self.settle_triggers(id, trigger, value);
608            }
609        }
610    }
611
612    // =====================================================================
613    // Ponteiro
614    // =====================================================================
615
616    fn set_hover(&mut self, root: ComponentId, new: Option<ComponentId>) {
617        let old = self.input_state(root).hovered;
618        if old == new {
619            return;
620        }
621        self.input_state(root).hovered = new;
622        // Quem pinta conforme o mouse dentro dele (`hover_within`): repinta quando o mouse
623        // entra ou sai de um dos de dentro (só os que mudaram, não os em comum).
624        let chain = |ui: &Self, from: Option<ComponentId>| {
625            let mut out = Vec::new();
626            let mut cur = from.filter(|&c| ui.contains(c));
627            while let Some(c) = cur {
628                if ui.cb(c).is_some_and(|cb| cb.hover_within()) {
629                    out.push(c);
630                }
631                cur = ui.parent(c);
632            }
633            out
634        };
635        let (left, entered) = (chain(self, old), chain(self, new));
636        for c in left.iter().filter(|c| !entered.contains(c)).chain(entered.iter().filter(|c| !left.contains(c))) {
637            self.damage(*c);
638        }
639        // As animações `hover_within`: dos controles que o mouse deixou (ele e os de dentro) e
640        // dos em que entrou. Sem nenhuma na tela, não custa nada.
641        if !self.hover_within_hosts().is_empty() {
642            let hosts = self.hover_within_hosts().to_vec();
643            let ancestors = |ui: &Self, from: Option<ComponentId>| {
644                let mut out = Vec::new();
645                let mut cur = from.filter(|&c| ui.contains(c));
646                while let Some(c) = cur {
647                    if hosts.contains(&c) {
648                        out.push(c);
649                    }
650                    cur = ui.parent(c);
651                }
652                out
653            };
654            let (left, entered) = (ancestors(self, old), ancestors(self, new));
655            for &c in left.iter().filter(|c| !entered.contains(c)) {
656                self.run_triggers(c, Trigger::HoverWithin, false);
657            }
658            for &c in entered.iter().filter(|c| !left.contains(c)) {
659                self.run_triggers(c, Trigger::HoverWithin, true);
660            }
661        }
662        if let Some(old) = old.filter(|&o| self.contains(o)) {
663            self.set_state_flag(old, Trigger::Hover, false);
664            self.fire(old, "on_pointer_leave", &EventArgs::None);
665            self.deliver(old, |c, ctx| c.pointer_leave(ctx));
666        }
667        if let Some(new) = new {
668            self.set_state_flag(new, Trigger::Hover, true);
669            self.fire(new, "on_pointer_enter", &EventArgs::None);
670            self.deliver(new, |c, ctx| c.pointer_enter(ctx));
671        }
672    }
673
674    /// O ponteiro se moveu. `event.position` em coordenadas do form.
675    pub fn pointer_move(&mut self, root: ComponentId, event: PointerEvent) {
676        self.report(&crate::activity::Activity::PointerMove { form: root, event });
677        if self.input_blocked(root) {
678            return; // há um form modal aberto por cima
679        }
680        self.update_layout();
681        if event.kind == PointerKind::Touch && (self.finger_move(root, event) || self.touch_pan(root, event)) {
682            return;
683        }
684        if self.drag_move(root, event) {
685            return;
686        }
687        let state = self.input_state(root);
688        if state.press.is_some_and(|p| !p.fired && ((p.position.x - event.position.x).abs() > TOUCH_SLOP || (p.position.y - event.position.y).abs() > TOUCH_SLOP)) {
689            state.press = None;
690        }
691        let hit = self.enabled_hit(root, event.position);
692        self.set_hover(root, hit);
693        self.update_hint(root, hit, event.position, event.kind == PointerKind::Touch);
694        let at = (event.kind != PointerKind::Touch).then_some(event.position);
695        let before = std::mem::replace(&mut self.input_state(root).pointer, at);
696        self.reveal_moved(root, before, at);
697        let target = self.input_state(root).captured.or(hit);
698        if let Some(target) = target {
699            let e = PointerEvent { position: self.local_point(target, event.position), ..event };
700            self.fire(target, "on_pointer_move", &EventArgs::Pointer(e));
701            self.deliver(target, |c, ctx| c.pointer_move(ctx, &e));
702        }
703    }
704
705    /// A dica a mostrar: a do controle sob o mouse ou do pai mais próximo que tenha uma.
706    fn update_hint(&mut self, root: ComponentId, hit: Option<ComponentId>, position: PointF, touch: bool) {
707        let mut target = None;
708        let mut cur = hit;
709        while let Some(c) = cur.filter(|_| !touch) {
710            if self.cb(c).is_some_and(|cb| !cb.hint().is_empty()) {
711                target = Some(c);
712                break;
713            }
714            if c == root {
715                break;
716            }
717            cur = self.parent(c);
718        }
719        let now = self.time;
720        let state = self.input_state(root);
721        let old = state.hint;
722        match (old, target) {
723            (Some(h), Some(t)) if h.target == t => {
724                // Ainda escondida: acompanha o mouse, e o tempo conta de novo enquanto ele anda
725                // (a dica é para o mouse parado em cima, não para quem só passa); um tremido de
726                // poucos pixels não conta. Já aberta, fica parada.
727                if !h.shown {
728                    let d = position - h.position;
729                    let moved = d.x.abs() > HINT_STILL || d.y.abs() > HINT_STILL;
730                    state.hint = Some(if moved { HintState { position, since: now, ..h } } else { h });
731                }
732                return;
733            }
734            (_, Some(t)) => state.hint = Some(HintState { target: t, since: now, position, shown: false }),
735            (_, None) => state.hint = None,
736        }
737        if old.is_some_and(|h| h.shown) {
738            self.request_repaint();
739        }
740    }
741
742    /// Esconde a dica (clique, roda, saída da janela).
743    pub(crate) fn hide_hint(&mut self, root: ComponentId) {
744        if let Some(h) = self.input_state(root).hint.take() {
745            if h.shown {
746                self.request_repaint();
747            }
748        }
749    }
750
751    /// A dica aberta agora no form: (texto, posição do mouse no form).
752    pub fn visible_hint(&self, root: ComponentId) -> Option<(String, PointF)> {
753        let h = self.input.get(&root)?.hint.filter(|h| h.shown)?;
754        let text = self.cb(h.target)?.hint().to_string();
755        Some((text, h.position))
756    }
757
758    /// Um botão foi pressionado (ou um dedo tocou a tela).
759    pub fn pointer_down(&mut self, root: ComponentId, event: PointerEvent) {
760        self.report(&crate::activity::Activity::PointerDown { form: root, event });
761        // Há um form modal aberto por cima: o clique traz o modal para a frente e o faz piscar,
762        // como no Windows. Sem isso, o modal atrás de outra janela (no Wayland, onde a janela não
763        // fica presa à dona) travava o app sem nada à vista (testado no Fedora em 20/11).
764        if let Some(modal) = self.blocking_modal(root) {
765            self.window_command(modal, crate::WindowCommand::Show);
766            self.window_command(modal, crate::WindowCommand::RequestAttention(false));
767            return;
768        }
769        // O backend ainda roda um handler: o clique novo é recusado (o form continua pintando).
770        if self.busy_blocks_input() {
771            self.input_state(root).refused_press = true;
772            return;
773        }
774        // Os botões extras do mouse (voltar e avançar): a navegação do form, como num
775        // navegador. Sem `on_navigate` tratando, seguem como um botão qualquer.
776        if matches!(event.button, PointerButton::Back | PointerButton::Forward) && self.navigate(root, event.button == PointerButton::Forward) {
777            return;
778        }
779        self.hide_hint(root);
780        self.update_layout();
781        let hit = self.enabled_hit(root, event.position);
782        self.dismiss_popups(root, hit);
783        let touch = event.kind == PointerKind::Touch;
784        if touch {
785            if self.finger_down(root, event) {
786                return;
787            }
788            let now = self.time;
789            let state = self.input_state(root);
790            if state.touch.is_some_and(|t| t.id != event.pointer_id) {
791                return;
792            }
793            // Tocar na tela para a inércia (como em qualquer celular).
794            state.fling = None;
795            let p = event.position;
796            state.touch = Some(Touch { id: event.pointer_id, target: hit, start: p, last: p, time: now, panning: false, velocity: PointF::ZERO, scrolled: PointF::ZERO });
797        }
798        self.set_hover(root, hit);
799        let Some(target) = hit else { return };
800
801        let now = self.time;
802        let state = self.input_state(root);
803        let click_count = match state.last_click {
804            Some((id, time, pos, count))
805                if id == target
806                    && now - time <= DOUBLE_CLICK_TIME
807                    && (pos.x - event.position.x).abs() <= DOUBLE_CLICK_DISTANCE
808                    && (pos.y - event.position.y).abs() <= DOUBLE_CLICK_DISTANCE =>
809            {
810                count.saturating_add(1)
811            }
812            _ => 1,
813        };
814        state.last_click = Some((target, now, event.position, click_count));
815        if event.button == PointerButton::Primary {
816            state.captured = Some(target);
817            state.press = Some(Press { target, position: event.position, time: now, touch, fired: false, menu: false });
818        }
819
820        if event.button == PointerButton::Primary {
821            self.set_state_flag(target, Trigger::Pressed, true);
822        }
823        if !touch {
824            if let Some(focusable) = self.focusable_ancestor(target) {
825                self.input_state(root).pointer_focus = true;
826                self.set_focus(focusable);
827            }
828        }
829
830        let e = PointerEvent { position: self.local_point(target, event.position), click_count, ..event };
831        self.fire(target, "on_pointer_down", &EventArgs::Pointer(e));
832        if click_count == 2 && event.button == PointerButton::Primary {
833            self.fire(target, "on_dbl_click", &EventArgs::Pointer(e));
834        }
835        self.deliver(target, |c, ctx| c.pointer_down(ctx, &e));
836        if event.button == PointerButton::Primary {
837            self.tell_ancestors(target, |c, ctx| c.child_pressed(ctx, target, &e));
838        }
839    }
840
841    /// Avisa os ancestrais de `target` que pedem ([`crate::ChildPointer`]), de dentro para fora.
842    fn tell_ancestors(&mut self, target: ComponentId, f: impl Fn(&mut dyn crate::ChildPointer, &mut EventCtx<'_>)) {
843        let mut current = self.parent(target);
844        while let Some(id) = current {
845            self.with_component(id, |c, ctx| {
846                if let Some(watch) = c.child_pointer_mut() {
847                    f(watch, ctx);
848                }
849            });
850            current = self.parent(id);
851        }
852    }
853
854    /// As camadas do form que fecham com o mouse apertado fora
855    /// ([`Component::closes_on_outside_press`]): sai a que não contém o ponto e cujo dono
856    /// também não. O dono repinta (a seta do ComboBox volta). O clique segue para quem está
857    /// embaixo (outro ComboBox abre a lista dele). A camada com o foco o perde antes de sair:
858    /// quem grava ao sair (o campo de renomear do MediaCard) grava.
859    fn dismiss_popups(&mut self, root: ComponentId, hit: Option<ComponentId>) {
860        // O ponto caiu em `area` ou num descendente dela.
861        let inside = |ui: &Ui, area: ComponentId| {
862            let mut current = hit;
863            while let Some(c) = current {
864                if c == area {
865                    return true;
866                }
867                current = ui.parent(c);
868            }
869            false
870        };
871        let doomed: Vec<(ComponentId, Option<ComponentId>)> = self
872            .children(root)
873            .iter()
874            .filter(|&&c| self.cb(c).is_none_or(|cb| cb.visible()))
875            .filter_map(|&c| self.component(c).and_then(|c| c.popup()).filter(|p| p.closes_on_outside_press()).map(|p| (c, p.dies_with())))
876            .filter(|&(popup, owner)| !inside(self, popup) && !owner.is_some_and(|o| inside(self, o)))
877            .collect();
878        for (popup, owner) in doomed {
879            let mut focused = self.input_state(root).focused;
880            while let Some(f) = focused.filter(|&f| f != popup) {
881                focused = self.parent(f);
882            }
883            if focused.is_some() {
884                self.clear_focus(root);
885            }
886            let kept = self.with_component(popup, |c, ctx| c.popup_mut().is_some_and(|p| p.dismissed(ctx))).unwrap_or(false);
887            if !kept {
888                self.free(popup);
889            }
890            if let Some(owner) = owner.filter(|&o| self.contains(o)) {
891                self.damage(owner);
892            }
893        }
894    }
895
896    /// Um botão foi solto. Se for o principal e for solto sobre o mesmo controle em que
897    /// foi pressionado, gera o clique.
898    pub fn pointer_up(&mut self, root: ComponentId, event: PointerEvent) {
899        self.report(&crate::activity::Activity::PointerUp { form: root, event });
900        if self.input_blocked(root) {
901            return; // há um form modal aberto por cima
902        }
903        // O pressionar foi recusado (o backend estava ocupado): o soltar também, sem clique. Um
904        // gesto que começou antes (um arrasto) termina normalmente.
905        if std::mem::take(&mut self.input_state(root).refused_press) {
906            return;
907        }
908        self.update_layout();
909        if event.kind == PointerKind::Touch && self.finger_up(root, event) {
910            return;
911        }
912        if event.kind == PointerKind::Touch {
913            // O último trecho do arrasto, entre o último movimento e o soltar.
914            if self.input_state(root).touch.is_some_and(|t| t.id == event.pointer_id && t.panning && t.last != event.position) {
915                self.touch_pan(root, event);
916            }
917            let now = self.time;
918            // O puxão de fim da rolagem volta sozinho.
919            if self.overscroll_active() {
920                self.overscroll_release();
921            }
922            let state = self.input_state(root);
923            match state.touch {
924                Some(t) if t.id != event.pointer_id => return,
925                Some(t) => {
926                    state.touch = None;
927                    if t.panning {
928                        // Só continua se o dedo ainda estava andando ao soltar.
929                        let moving = now - t.time < 0.1;
930                        if moving && speed(t.velocity) >= FLING_MIN_SPEED {
931                            state.fling = Some(Fling { target: t.target, position: t.start, velocity: t.velocity, time: now });
932                            self.request_repaint();
933                        }
934                        if moving {
935                            self.swipe_check(root, t);
936                        }
937                        // O fim do arrasto, ao tocado e aos pais (a linha deslizada da lista).
938                        let mut current = t.target.filter(|&c| self.contains(c));
939                        while let Some(id) = current {
940                            self.with_component(id, |c, ctx| c.touch_end(ctx));
941                            current = self.parent(id);
942                        }
943                        return;
944                    }
945                }
946                None => {}
947            }
948        }
949        if event.button == PointerButton::Primary && self.drag_drop(root) {
950            return;
951        }
952        let press = if event.button == PointerButton::Primary { self.input_state(root).press.take() } else { None };
953        let long_pressed = press.is_some_and(|p| p.fired);
954        // O toque longo abriu um menu: o dedo que sai é só o fim do toque.
955        if press.is_some_and(|p| p.menu) {
956            let state = self.input_state(root);
957            state.captured = None;
958            state.touch = None;
959            return;
960        }
961        let captured = if event.button == PointerButton::Primary {
962            self.input_state(root).captured.take()
963        } else {
964            None
965        };
966        let hit = self.enabled_hit(root, event.position);
967        let Some(target) = captured.or(hit).filter(|&t| self.contains(t)) else { return };
968
969        if event.button == PointerButton::Primary {
970            self.set_state_flag(target, Trigger::Pressed, false);
971        }
972        // Toque (sem arrasto): o foco vem agora.
973        if event.kind == PointerKind::Touch && captured.is_some() {
974            if let Some(focusable) = self.focusable_ancestor(target) {
975                self.input_state(root).pointer_focus = true;
976                self.set_focus(focusable);
977            }
978        }
979        let e = PointerEvent { position: self.local_point(target, event.position), ..event };
980        self.fire(target, "on_pointer_up", &EventArgs::Pointer(e));
981        // O `on_click` que sair daqui (do `click` ou do próprio `pointer_up` do controle, como
982        // o do item de uma lista) leva o ponteiro: o handler pergunta com `Ui::click_pointer`.
983        let pointer = crate::ClickPointer {
984            position: e.position,
985            form_position: event.position,
986            button: event.button,
987            modifiers: event.modifiers,
988            kind: event.kind,
989            click_count: event.click_count,
990        };
991        let outer = self.click_source.replace((target, pointer));
992        self.deliver(target, |c, ctx| c.pointer_up(ctx, &e));
993
994        if event.button == PointerButton::Primary && hit == Some(target) && self.is_effectively_enabled(target) && !long_pressed {
995            self.with_component(target, |c, ctx| c.click(ctx));
996            if self.contains(target) {
997                self.tell_ancestors(target, |c, ctx| c.child_clicked(ctx, target));
998            }
999        }
1000        self.click_source = outer;
1001        if event.button == PointerButton::Secondary && hit == Some(target) {
1002            self.open_popup_menu(target, event.position);
1003        }
1004        // O controle pode ter mudado de lugar durante o clique.
1005        self.set_hover(root, self.enabled_hit(root, event.position));
1006    }
1007
1008    /// Começa o arrasto pedido em `on_drag_start`: `data` vai para os destinos
1009    /// (`on_drag_over`, `on_drag_drop`) e `label` acompanha o mouse. Fora de um
1010    /// `on_drag_start` não faz nada.
1011    pub fn begin_drag(&mut self, data: impl Into<String>, label: impl Into<String>) {
1012        self.drag_request = Some((data.into(), label.into()));
1013    }
1014
1015    /// A imagem que acompanha o cursor neste arrasto (no lugar da do `drag_image` do
1016    /// controle). Dentro de `on_drag_start` vale para o arrasto que começa; durante um
1017    /// arrasto, troca a dele (`None` tira).
1018    pub fn set_drag_image(&mut self, visual: Option<DragVisual>) {
1019        let mut applied = false;
1020        for state in self.input.values_mut() {
1021            if let Some(d) = state.drag.as_mut() {
1022                d.visual = visual.clone();
1023                applied = true;
1024            }
1025        }
1026        if applied {
1027            self.request_repaint();
1028        } else {
1029            self.drag_visual_request = visual;
1030        }
1031    }
1032
1033    /// O arrasto em andamento com imagem: o que acompanha o cursor e a posição do mouse no form.
1034    pub fn drag_visual(&self, root: ComponentId) -> Option<(DragVisual, PointF)> {
1035        let d = self.input.get(&root)?.drag.as_ref()?;
1036        Some((d.visual.clone()?, d.position))
1037    }
1038
1039    /// A plataforma mostra a imagem do arrasto numa janela própria (o Windows): o form não a
1040    /// pinta.
1041    pub fn set_native_drag_image(&mut self, on: bool) {
1042        self.native_drag_image = on;
1043    }
1044
1045    pub fn native_drag_image(&self) -> bool {
1046        self.native_drag_image
1047    }
1048
1049    /// Dentro de `on_drag_over`: este destino não aceita o que vem (sem destaque; soltar
1050    /// ali não dispara `on_drag_drop`).
1051    pub fn reject_drop(&mut self) {
1052        self.drop_rejected = true;
1053    }
1054
1055    /// O que está sendo arrastado no form agora.
1056    pub fn drag_data(&self, root: ComponentId) -> Option<&str> {
1057        self.input.get(&root)?.drag.as_ref().map(|d| d.data.as_str())
1058    }
1059
1060    /// O arrasto em andamento: (rótulo, posição do mouse no form, destino aceito).
1061    pub fn drag_view(&self, root: ComponentId) -> Option<(String, PointF, Option<ComponentId>)> {
1062        let d = self.input.get(&root)?.drag.as_ref()?;
1063        Some((d.label.clone(), d.position, d.target.filter(|_| d.accepted)))
1064    }
1065
1066    /// Começa um arrasto agora, pelo próprio componente `source` no meio de um gesto dele (a
1067    /// aba puxada para fora da faixa): `position` é o mouse no form. O botão continua
1068    /// apertado; dali em diante o mouse é do arrasto (destinos, imagem, soltar). `false` se
1069    /// já havia um.
1070    /// `label` vazio: nada de texto junto do mouse (a imagem basta).
1071    pub fn begin_drag_now(&mut self, source: ComponentId, data: impl Into<String>, label: impl Into<String>, visual: Option<DragVisual>, position: PointF) -> bool {
1072        let root = self.root_of(source);
1073        if self.input_state(root).drag.is_some() {
1074            return false;
1075        }
1076        let state = self.input_state(root);
1077        state.press = None;
1078        if let Some(c) = state.captured.take() {
1079            self.set_state_flag(c, Trigger::Pressed, false);
1080        }
1081        self.hide_hint(root);
1082        let data = data.into();
1083        self.input_state(root).drag = Some(Drag {
1084            source,
1085            label: label.into(),
1086            data,
1087            position,
1088            target: None,
1089            accepted: false,
1090            starting: None,
1091            over: None,
1092            dropped: false,
1093            visual,
1094            target_position: position,
1095        });
1096        let target = self.drop_target_at(root, position, source);
1097        self.drag_retarget(root, target, position, position);
1098        true
1099    }
1100
1101    /// A plataforma informa onde o mouse está na tela durante um arrasto (pixels físicos) e
1102    /// a escala da janela de origem: quem solta fora das janelas (a aba que vira janela) sabe
1103    /// onde.
1104    pub fn set_screen_pointer(&mut self, pointer: Option<ScreenPointer>) {
1105        self.screen_pointer = pointer;
1106    }
1107
1108    /// O último ponto da tela informado pela plataforma (`None` sem plataforma de janelas).
1109    pub fn screen_pointer(&self) -> Option<ScreenPointer> {
1110        self.screen_pointer
1111    }
1112
1113    /// A janela inteira do form `form` arrastada pela barra de título (o sistema move a janela)
1114    /// passou por cima do form `over`, no ponto dele (`None`: fora das janelas do app). O
1115    /// destino é quem aceita, pelos ganchos `drop_*`, os dados [`FORM_DRAG`] + o id do form
1116    /// (a faixa de abas com `accept_forms`, que o recebe como aba); ele acende ao passar e
1117    /// recebe no [`Ui::window_drag_end`]. A plataforma chama durante o movimento da janela.
1118    pub fn window_drag_over(&mut self, form: ComponentId, over: Option<(ComponentId, PointF)>) {
1119        let data = format!("{FORM_DRAG}{}", form.to_u64());
1120        let target = over.filter(|&(f, _)| f != form && self.contains(f)).and_then(|(f, pos)| {
1121            let mut cur = self.enabled_hit(f, pos);
1122            while let Some(c) = cur {
1123                if self.hook_target(c, &data) {
1124                    return Some((c, pos));
1125                }
1126                cur = self.parent(c);
1127            }
1128            None
1129        });
1130        let old = self.window_drag.and_then(|(f, t, _)| t.filter(|_| f == form));
1131        if let Some(old) = old.filter(|&o| Some(o) != target.map(|(t, _)| t) && self.contains(o)) {
1132            self.deliver(old, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_leave(ctx) });
1133        }
1134        if let Some((t, pos)) = target {
1135            let local = self.local_point(t, pos);
1136            self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_hover(ctx, &data, local) });
1137        }
1138        self.window_drag = Some((form, target.map(|(t, _)| t), target.map_or(PointF::default(), |(_, p)| p)));
1139        self.request_repaint();
1140    }
1141
1142    /// A janela do form foi solta (o sistema terminou de movê-la): o destino de agora recebe o
1143    /// form (`drop_receive` com os dados [`FORM_DRAG`]). `true` se algum recebeu.
1144    pub fn window_drag_end(&mut self, form: ComponentId) -> bool {
1145        let Some((f, target, pos)) = self.window_drag.take() else { return false };
1146        let Some(t) = target.filter(|&t| f == form && self.contains(t)) else { return false };
1147        let data = format!("{FORM_DRAG}{}", form.to_u64());
1148        let local = self.local_point(t, pos);
1149        self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_receive(ctx, &data, local) });
1150        self.request_repaint();
1151        true
1152    }
1153
1154    /// O componente recebe o arrasto pelos ganchos `drop_*` (e não por eventos)?
1155    fn hook_target(&self, id: ComponentId, data: &str) -> bool {
1156        self.component(id).and_then(|c| c.drag_drop()).is_some_and(|d| d.drop_accepts(self, id, data))
1157    }
1158
1159    /// O controle arrastável que contém `id` (ele mesmo ou um pai).
1160    fn draggable_ancestor(&self, root: ComponentId, id: ComponentId) -> Option<ComponentId> {
1161        let mut cur = Some(id);
1162        while let Some(c) = cur {
1163            if self.cb(c).is_some_and(|cb| cb.draggable()) {
1164                return Some(c);
1165            }
1166            if c == root {
1167                return None;
1168            }
1169            cur = self.parent(c);
1170        }
1171        None
1172    }
1173
1174    /// O destino sob `pos`: o controle que aceita soltar (`accepts_drops` ou `drop_types`; ou
1175    /// o pai mais próximo que aceite), nunca a própria origem nem algo dentro dela.
1176    /// Quem recebe pelos ganchos ([`Component::drop_accepts`](crate::Component::drop_accepts))
1177    /// vale mesmo sendo a origem.
1178    fn drop_target_at(&self, root: ComponentId, pos: PointF, source: ComponentId) -> Option<ComponentId> {
1179        let data = self.input.values().find_map(|s| s.drag.as_ref().filter(|d| d.source == source).map(|d| d.data.clone())).unwrap_or_default();
1180        let mut cur = self.enabled_hit(root, pos);
1181        while let Some(c) = cur {
1182            if !data.is_empty() && self.hook_target(c, &data) {
1183                return Some(c);
1184            }
1185            if c == source {
1186                return None;
1187            }
1188            if self.cb(c).is_some_and(|cb| cb.accepts_drops() || !cb.drop_types().is_empty()) {
1189                // Dentro da origem não vale.
1190                let mut up = self.parent(c);
1191                while let Some(p) = up {
1192                    if p == source {
1193                        return None;
1194                    }
1195                    up = self.parent(p);
1196                }
1197                return Some(c);
1198            }
1199            if c == root {
1200                return None;
1201            }
1202            cur = self.parent(c);
1203        }
1204        None
1205    }
1206
1207    /// O mouse andou: começa o arrasto (passou do limite num controle arrastável) ou
1208    /// acompanha o que já está em andamento. `true` = o movimento foi do arrasto.
1209    fn drag_move(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1210        if self.input_state(root).drag.is_none() && !self.start_drag(root, event) {
1211            return false;
1212        }
1213        let Some(drag) = self.input_state(root).drag.clone() else { return false };
1214        let target = self.drop_target_at(root, event.position, drag.source);
1215        self.drag_retarget(root, target, event.position, event.position);
1216        true
1217    }
1218
1219    /// Durante um arrasto, o mouse está sobre outra janela do app (a plataforma diz qual e
1220    /// onde, no form dela): o destino pode ser um controle daquele form. `form` `None`: fora de
1221    /// todas as janelas.
1222    pub fn drag_over_form(&mut self, root: ComponentId, form: Option<ComponentId>, pos: PointF) {
1223        let Some(drag) = self.input.get(&root).and_then(|s| s.drag.clone()) else { return };
1224        let target = form.filter(|&f| f != root).and_then(|f| self.drop_target_at(f, pos, drag.source));
1225        let position = drag.position;
1226        self.drag_retarget(root, target, position, pos);
1227    }
1228
1229    /// Há um arrasto em andamento que começou neste form?
1230    pub fn dragging(&self, root: ComponentId) -> bool {
1231        self.input.get(&root).is_some_and(|s| s.drag.is_some())
1232    }
1233
1234    /// Começa o arrasto: o `drag_data` declarado, o item da lista ou da grade, ou o
1235    /// `on_drag_start` (pergunta: o handler dá os dados com `begin_drag`, ou responde `data` e
1236    /// `label`; recusar cancela). `false` se não começou.
1237    fn start_drag(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1238        let state = self.input_state(root);
1239        let Some(press) = state.press.filter(|p| !p.fired && !p.touch) else { return false };
1240        if (press.position.x - event.position.x).abs() <= DRAG_START && (press.position.y - event.position.y).abs() <= DRAG_START {
1241            return false;
1242        }
1243        let Some(source) = self.draggable_ancestor(root, press.target) else { return false };
1244        // O declarado (sem handler) e o item que a lista ou a grade mandam sozinhas.
1245        let declared = self.cb(source).map(|cb| (cb.drag_data().to_string(), cb.drag_label().to_string())).filter(|(d, _)| !d.is_empty());
1246        let declared = declared.or_else(|| self.component(source).and_then(|c| c.drag_drop()).and_then(|d| d.drag_item(self)));
1247        self.drag_request = None;
1248        self.drag_visual_request = None;
1249        let mut pending = None;
1250        let (data, label) = match self.ask(source, "on_drag_start", &EventArgs::None) {
1251            crate::question::Asked::Answered(crate::question::Answer::Refused(_)) => return false,
1252            crate::question::Asked::Answered(answer) => {
1253                let answered = answer.value("data").and_then(|v| v.to_str().ok()).filter(|d| !d.is_empty()).map(|d| {
1254                    let label = answer.value("label").and_then(|v| v.to_str().ok()).unwrap_or(d).to_string();
1255                    (d.to_string(), label)
1256                });
1257                match self.drag_request.take().or(answered).or(declared) {
1258                    Some(d) => d,
1259                    None => return false,
1260                }
1261            }
1262            crate::question::Asked::Deferred(token) => {
1263                // O backend dá os dados: o arrasto começa já, com o declarado (ou vazio), e muda
1264                // (ou é cancelado) com a resposta.
1265                pending = Some(token);
1266                let (root2, declared2) = (root, declared.clone());
1267                self.on_answer(token, move |ui, answer| ui.drag_start_answered(root2, answer, declared2));
1268                declared.unwrap_or_default()
1269            }
1270        };
1271        let state = self.input_state(root);
1272        state.press = None;
1273        if let Some(c) = state.captured.take() {
1274            self.set_state_flag(c, Trigger::Pressed, false);
1275        }
1276        self.hide_hint(root);
1277        let label = if label.is_empty() { data.clone() } else { label };
1278        // A imagem: a que o handler pediu ou a do `drag_image` do controle.
1279        let visual = self.drag_visual_request.take().or_else(|| {
1280            let image = self.cb(source).and_then(|cb| cb.drag_image())?;
1281            self.component(image)?.drag_drop()?.drag_visual(self, source)
1282        });
1283        self.input_state(root).drag = Some(Drag { source, data, label, position: event.position, target: None, accepted: false, starting: pending, over: None, dropped: false, visual, target_position: event.position });
1284        true
1285    }
1286
1287    /// A resposta do `on_drag_start` remoto: os dados (ou o cancelamento).
1288    fn drag_start_answered(&mut self, root: ComponentId, answer: crate::question::Answer, declared: Option<(String, String)>) {
1289        let Some(drag) = self.input.get_mut(&root).and_then(|s| s.drag.as_mut()) else { return };
1290        drag.starting = None;
1291        let data = answer.value("data").and_then(|v| v.to_str().ok()).map(str::to_string).filter(|d| !d.is_empty());
1292        let label = answer.value("label").and_then(|v| v.to_str().ok()).map(str::to_string);
1293        match (answer.is_refused(), data.or_else(|| declared.as_ref().map(|d| d.0.clone()))) {
1294            (false, Some(data)) => {
1295                drag.label = label.filter(|l| !l.is_empty()).or_else(|| declared.map(|d| d.1).filter(|l| !l.is_empty())).unwrap_or_else(|| data.clone());
1296                drag.data = data;
1297                // O destino de agora pergunta de novo, com os dados de verdade.
1298                let (target, position, dropped, target_position) = (drag.target.take(), drag.position, drag.dropped, drag.target_position);
1299                drag.accepted = false;
1300                self.drag_retarget(root, target, position, target_position);
1301                if dropped {
1302                    self.drag_drop(root);
1303                }
1304            }
1305            _ => {
1306                self.cancel_drag(root);
1307            }
1308        }
1309    }
1310
1311    /// O destino sob o mouse mudou (ou não): `drop_types` decide sem perguntar; senão, o
1312    /// `on_drag_over` (pergunta: recusar, `reject_drop` ou `accept` falso não aceitam; um
1313    /// destino remoto fica neutro até a resposta).
1314    /// `target_position`: o mouse no form do destino (outra janela, às vezes).
1315    fn drag_retarget(&mut self, root: ComponentId, target: Option<ComponentId>, position: PointF, target_position: PointF) {
1316        let Some(drag) = self.input_state(root).drag.clone() else { return };
1317        let mut accepted = drag.accepted;
1318        let mut over = drag.over;
1319        // Quem recebe pelos ganchos: avisa que saiu e acompanha o mouse em cima.
1320        if let Some(old) = drag.target.filter(|&t| Some(t) != target && self.hook_target(t, &drag.data)) {
1321            self.deliver(old, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_leave(ctx) });
1322        }
1323        if let Some(t) = target.filter(|&t| drag.starting.is_none() && self.hook_target(t, &drag.data)) {
1324            let local = self.local_point(t, target_position);
1325            let data = drag.data.clone();
1326            self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_hover(ctx, &data, local) });
1327            if let Some(d) = self.input_state(root).drag.as_mut() {
1328                d.position = position;
1329                d.target = Some(t);
1330                d.accepted = true;
1331                d.over = None;
1332                d.target_position = target_position;
1333            }
1334            self.request_repaint();
1335            return;
1336        }
1337        // Passando por cima do mesmo destino (que aceitou): `on_drag_move`, com o ponto (o
1338        // `dragover` do HTML; o relatório do Tabernáculo, J16).
1339        if target == drag.target && drag.accepted && drag.starting.is_none()
1340            && let Some(t) = target
1341        {
1342            let local = self.local_point(t, target_position);
1343            self.fire(t, "on_drag_move", &EventArgs::Pointer(crate::PointerEvent { position: local, ..Default::default() }));
1344        }
1345        if target != drag.target && drag.starting.is_none() {
1346            // Saiu do destino de antes.
1347            if let Some(old) = drag.target.filter(|&o| self.contains(o)) {
1348                self.fire(old, "on_drag_leave", &EventArgs::Text(drag.data.clone()));
1349            }
1350            accepted = false;
1351            over = None;
1352            if let Some(t) = target {
1353                let types = self.cb(t).map(|cb| cb.drop_types().to_string()).unwrap_or_default();
1354                if !types.is_empty() {
1355                    let kind = drag.data.split(':').next().unwrap_or_default().trim();
1356                    accepted = types.split([';', ',']).map(str::trim).any(|k| k.eq_ignore_ascii_case(kind));
1357                } else {
1358                    self.drop_rejected = false;
1359                    match self.ask(t, "on_drag_over", &EventArgs::Text(drag.data.clone())) {
1360                        crate::question::Asked::Answered(answer) => accepted = drag_accepted(&answer) && !std::mem::take(&mut self.drop_rejected),
1361                        crate::question::Asked::Deferred(token) => {
1362                            over = Some((t, token));
1363                            self.on_answer(token, move |ui, answer| ui.drag_over_answered(root, t, token, answer));
1364                        }
1365                    }
1366                }
1367            }
1368        }
1369        if let Some(d) = self.input_state(root).drag.as_mut() {
1370            d.position = position;
1371            d.target = target;
1372            d.accepted = accepted;
1373            d.over = over;
1374            d.target_position = target_position;
1375        }
1376        self.request_repaint();
1377    }
1378
1379    /// A resposta do `on_drag_over` remoto: vale se o mouse ainda está no mesmo destino.
1380    fn drag_over_answered(&mut self, root: ComponentId, target: ComponentId, token: u64, answer: crate::question::Answer) {
1381        let Some(drag) = self.input.get_mut(&root).and_then(|s| s.drag.as_mut()) else { return };
1382        if drag.over != Some((target, token)) {
1383            return;
1384        }
1385        drag.over = None;
1386        drag.accepted = drag_accepted(&answer);
1387        let dropped = drag.dropped;
1388        self.request_repaint();
1389        if dropped {
1390            self.drag_drop(root);
1391        }
1392    }
1393
1394    /// Soltou durante um arrasto: entrega ao destino aceito e avisa a origem. Com a resposta
1395    /// do `on_drag_start` ou do `on_drag_over` ainda pendente, solta quando ela chegar.
1396    fn drag_drop(&mut self, root: ComponentId) -> bool {
1397        let Some(drag) = self.input_state(root).drag.as_mut() else { return false };
1398        if drag.starting.is_some() || drag.over.is_some() {
1399            drag.dropped = true;
1400            return true;
1401        }
1402        let Some(drag) = self.input_state(root).drag.take() else { return false };
1403        let dropped = drag.accepted && drag.target.is_some_and(|t| self.contains(t));
1404        if let Some(t) = drag.target.filter(|_| dropped) {
1405            if self.hook_target(t, &drag.data) {
1406                let local = self.local_point(t, drag.target_position);
1407                self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_receive(ctx, &drag.data, local) });
1408            } else {
1409                // O ponto onde soltou, no destino: `drop_point` durante o `on_drag_drop` (J15).
1410                self.drop_point = Some(self.local_point(t, drag.target_position));
1411                self.fire(t, "on_drag_drop", &EventArgs::Text(drag.data.clone()));
1412            }
1413        }
1414        if self.contains(drag.source) {
1415            let end = if dropped { crate::DragEnd::Dropped } else { crate::DragEnd::Nowhere };
1416            self.deliver(drag.source, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drag_ended(ctx, &drag.data, end) });
1417        }
1418        if self.contains(drag.source) {
1419            self.fire(drag.source, "on_drag_end", &EventArgs::Value(dropped.into()));
1420        }
1421        self.request_repaint();
1422        true
1423    }
1424
1425    /// Onde o último arrasto foi solto, nas coordenadas do destino (vale no `on_drag_drop`).
1426    pub fn drop_point(&self) -> Option<PointF> {
1427        self.drop_point
1428    }
1429
1430    /// Cancela o arrasto em andamento (Esc). `true` se havia um.
1431    pub fn cancel_drag(&mut self, root: ComponentId) -> bool {
1432        let Some(drag) = self.input_state(root).drag.take() else { return false };
1433        let state = self.input_state(root);
1434        state.press = None;
1435        state.captured = None;
1436        if let Some(t) = drag.target.filter(|&t| self.hook_target(t, &drag.data)) {
1437            self.deliver(t, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drop_leave(ctx) });
1438        }
1439        if self.contains(drag.source) {
1440            self.deliver(drag.source, |c, ctx| if let Some(d) = c.drag_drop_mut() { d.drag_ended(ctx, &drag.data, crate::DragEnd::Cancelled) });
1441        }
1442        if self.contains(drag.source) {
1443            self.fire(drag.source, "on_drag_end", &EventArgs::Value(false.into()));
1444        }
1445        self.request_repaint();
1446        true
1447    }
1448
1449    /// Abre o menu de contexto do controle (ou do pai mais próximo que tenha um).
1450    pub fn open_popup_menu(&mut self, target: ComponentId, at: PointF) -> bool {
1451        self.open_context_menu(target, at, false)
1452    }
1453
1454    /// O toque longo em `target` abriu um menu (veja `Press::menu`): ele não fica pressionado.
1455    pub(crate) fn mark_press_menu(&mut self, root: ComponentId, target: ComponentId) {
1456        if let Some(p) = self.input_state(root).press.as_mut() {
1457            p.menu = true;
1458        }
1459        self.set_state_flag(target, Trigger::Pressed, false);
1460    }
1461
1462    /// O menu de contexto em `at` (no form): o `popup_menu` do controle ou do pai mais próximo
1463    /// que tenha um e, sem nenhum, o menu próprio do controle ou de um pai
1464    /// ([`Component::context_menu`], o de texto do `Edit`). `touch`: veio do toque longo.
1465    pub(crate) fn open_context_menu(&mut self, target: ComponentId, at: PointF, touch: bool) -> bool {
1466        let mut current = Some(target);
1467        while let Some(c) = current {
1468            if let Some(menu) = self.cb(c).and_then(|cb| cb.popup_menu()).filter(|&m| self.contains(m)) {
1469                return self.send_message(menu, &crate::event::PopupRequest { at, source: target });
1470            }
1471            current = self.parent(c);
1472        }
1473        let mut current = Some(target);
1474        while let Some(c) = current {
1475            let local = self.local_point(c, at);
1476            if self.is_effectively_enabled(c) && self.with_component(c, |comp, ctx| comp.context_menu(ctx, local, touch)).unwrap_or(false) {
1477                return true;
1478            }
1479            current = self.parent(c);
1480        }
1481        false
1482    }
1483
1484    /// O ponteiro saiu da janela.
1485    pub fn pointer_leave(&mut self, root: ComponentId) {
1486        self.hide_hint(root);
1487        let before = self.input_state(root).pointer.take();
1488        self.reveal_moved(root, before, None);
1489        if self.input_state(root).captured.is_none() {
1490            self.set_hover(root, None);
1491        }
1492    }
1493
1494    /// Cancela a interação em andamento (a janela perdeu o foco, o toque foi cancelado...).
1495    pub fn pointer_cancel(&mut self, root: ComponentId) {
1496        if let Some(p) = self.input_state(root).pinch.take() {
1497            let e = crate::event::GestureEvent { phase: crate::event::GesturePhase::End, scale: 1.0, delta_scale: 1.0, center: p.last_center, ..Default::default() };
1498            self.gesture_from(p.target, e);
1499        }
1500        let state = self.input_state(root);
1501        state.fingers.clear();
1502        state.after_pinch = false;
1503        state.touch = None;
1504        if let Some(captured) = self.input_state(root).captured.take() {
1505            self.set_state_flag(captured, Trigger::Pressed, false);
1506        }
1507        self.set_hover(root, None);
1508    }
1509
1510    /// Roda do mouse / rolagem. Sobe do controle sob o ponteiro para os pais até algum
1511    /// componente marcar como tratado.
1512    pub fn wheel(&mut self, root: ComponentId, event: WheelEvent) {
1513        self.report(&crate::activity::Activity::Wheel { form: root, event });
1514        if self.input_blocked(root) {
1515            return; // há um form modal aberto por cima
1516        }
1517        if self.busy_blocks_input() {
1518            return;
1519        }
1520        self.hide_hint(root);
1521        if !self.wheel_handled(root, event) {
1522            // Ninguém rolou: o form rola, se o conteúdo não cabe (o teclado aberto, a tela
1523            // pequena).
1524            self.scroll_form(root, event.delta.y);
1525        }
1526    }
1527
1528    /// A roda só para os controles sob o ponteiro (subindo pelos pais), sem o form rolar
1529    /// quando ninguém trata: o designer da IDE rola o `ScrollBox` do form desenhado e, sem
1530    /// ninguém para rolar, move a própria vista. `true` se algum controle tratou.
1531    pub fn wheel_controls(&mut self, root: ComponentId, event: WheelEvent) -> bool {
1532        self.wheel_handled(root, event)
1533    }
1534
1535    fn wheel_handled(&mut self, root: ComponentId, event: WheelEvent) -> bool {
1536        self.update_layout();
1537        let hit = self.enabled_hit(root, event.position);
1538        self.wheel_from(hit, event)
1539    }
1540
1541    /// Entrega a roda a `start` e sobe para os pais até alguém tratar.
1542    fn wheel_from(&mut self, start: Option<ComponentId>, event: WheelEvent) -> bool {
1543        let mut current = start;
1544        while let Some(id) = current {
1545            let e = WheelEvent { position: self.local_point(id, event.position), ..event };
1546            self.fire(id, "on_wheel", &EventArgs::Wheel(e));
1547            if self.deliver(id, |c, ctx| c.wheel(ctx, &e)) {
1548                // A roda pode ter ligado um timer (o deslize da rolagem).
1549                self.sync_timer(id);
1550                return true;
1551            }
1552            // `captures_wheel`: a roda fica com ele (o `on_wheel` dele fez o que queria, um
1553            // zoom), e os contêineres de fora não rolam junto.
1554            if self.cb(id).is_some_and(|cb| cb.captures_wheel()) {
1555                return true;
1556            }
1557            current = self.parent(id);
1558        }
1559        false
1560    }
1561
1562    // =====================================================================
1563    // Pinça e giro (dois dedos)
1564    // =====================================================================
1565
1566    /// Um dedo tocou. Com o segundo dedo começa a pinça: o toque do primeiro (rolagem,
1567    /// clique, toque longo) é cancelado. Devolve `true` se o dedo não segue como toque.
1568    fn finger_down(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1569        let state = self.input_state(root);
1570        state.fingers.retain(|(id, _)| *id != event.pointer_id);
1571        state.fingers.push((event.pointer_id, event.position));
1572        if state.pinch.is_some() || state.after_pinch || state.fingers.len() > 2 {
1573            return true;
1574        }
1575        if state.fingers.len() < 2 {
1576            return false;
1577        }
1578        let ((a_id, a), (b_id, b)) = (state.fingers[0], state.fingers[1]);
1579        let first_target = state.touch.and_then(|t| t.target);
1580        state.touch = None;
1581        state.fling = None;
1582        state.press = None;
1583        if let Some(c) = self.input_state(root).captured.take() {
1584            self.set_state_flag(c, Trigger::Pressed, false);
1585        }
1586        let (distance, angle, center) = finger_geometry(a, b);
1587        let Some(target) = first_target.or_else(|| self.enabled_hit(root, center)) else { return true };
1588        self.input_state(root).pinch =
1589            Some(Pinch { target, ids: (a_id, b_id), start_distance: distance, start_angle: angle, last_distance: distance, last_angle: angle, last_center: center });
1590        let e = crate::event::GestureEvent { phase: crate::event::GesturePhase::Begin, center, scale: 1.0, delta_scale: 1.0, ..Default::default() };
1591        self.gesture_from(target, e);
1592        true
1593    }
1594
1595    /// Um dedo andou. Durante a pinça, gera o gesto; devolve `true` se o movimento não
1596    /// segue como toque.
1597    fn finger_move(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1598        let state = self.input_state(root);
1599        if let Some(f) = state.fingers.iter_mut().find(|(id, _)| *id == event.pointer_id) {
1600            f.1 = event.position;
1601        }
1602        if state.after_pinch {
1603            return true;
1604        }
1605        let Some(mut p) = state.pinch else { return false };
1606        let pos = |id: u64| state.fingers.iter().find(|(i, _)| *i == id).map(|(_, p)| *p);
1607        let (Some(a), Some(b)) = (pos(p.ids.0), pos(p.ids.1)) else { return true };
1608        let (distance, angle, center) = finger_geometry(a, b);
1609        let wrap = |r: f32| (r + std::f32::consts::PI).rem_euclid(std::f32::consts::TAU) - std::f32::consts::PI;
1610        let e = crate::event::GestureEvent {
1611            phase: crate::event::GesturePhase::Update,
1612            center,
1613            scale: distance / p.start_distance,
1614            delta_scale: distance / p.last_distance,
1615            rotation: wrap(angle - p.start_angle),
1616            delta_rotation: wrap(angle - p.last_angle),
1617            pan: center - p.last_center,
1618        };
1619        p.last_distance = distance;
1620        p.last_angle = angle;
1621        p.last_center = center;
1622        state.pinch = Some(p);
1623        self.gesture_from(p.target, e);
1624        true
1625    }
1626
1627    /// Um dedo saiu. Acaba a pinça; o dedo que sobrar não vira toque até sair também.
1628    fn finger_up(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1629        let state = self.input_state(root);
1630        state.fingers.retain(|(id, _)| *id != event.pointer_id);
1631        if let Some(p) = state.pinch.take() {
1632            state.after_pinch = !state.fingers.is_empty();
1633            let scale = p.last_distance / p.start_distance;
1634            let e = crate::event::GestureEvent { phase: crate::event::GesturePhase::End, center: p.last_center, scale, delta_scale: 1.0, ..Default::default() };
1635            self.gesture_from(p.target, e);
1636            return true;
1637        }
1638        if state.after_pinch {
1639            state.after_pinch = !state.fingers.is_empty();
1640            return true;
1641        }
1642        false
1643    }
1644
1645    /// Gesto já reconhecido pelo sistema (pinça e giro do touchpad no macOS): vai ao
1646    /// controle sob `event.center` (coordenadas do form) e sobe para os pais.
1647    pub fn gesture(&mut self, root: ComponentId, event: crate::event::GestureEvent) {
1648        if self.input_blocked(root) {
1649            return;
1650        }
1651        self.update_layout();
1652        if let Some(target) = self.enabled_hit(root, event.center) {
1653            self.gesture_from(target, event);
1654        }
1655    }
1656
1657    /// Entrega o gesto ao controle e sobe para os pais até alguém tratar.
1658    fn gesture_from(&mut self, start: ComponentId, event: crate::event::GestureEvent) -> bool {
1659        self.request_repaint();
1660        let mut current = Some(start);
1661        while let Some(id) = current {
1662            let e = crate::event::GestureEvent { center: self.local_point(id, event.center), ..event };
1663            self.fire(id, "on_gesture", &EventArgs::Gesture(e));
1664            if self.deliver(id, |c, ctx| c.gesture(ctx, &e)) {
1665                return true;
1666            }
1667            // `captures_gesture`: o gesto fica com ele (o `on_gesture` dele fez o que queria), e
1668            // os pais não recebem (relatório do RTSPlayer, 15/11: a pinça na linha do tempo
1669            // ampliava também o palco em volta).
1670            if self.cb(id).is_some_and(|cb| cb.captures_gesture()) {
1671                return true;
1672            }
1673            current = self.parent(id);
1674        }
1675        false
1676    }
1677
1678    // =====================================================================
1679    // Deslizar (`on_swipe`)
1680    // =====================================================================
1681
1682    /// O dedo saiu de um arrasto ainda andando: rápido e longo o bastante, sem ter rolado nada
1683    /// no eixo em que mais andou, é um deslizar. Começando na borda do form, vai primeiro ao
1684    /// `edge_swipe` dos componentes do form; senão, ao controle tocado, subindo.
1685    fn swipe_check(&mut self, root: ComponentId, t: Touch) {
1686        let distance = t.last - t.start;
1687        let horizontal = distance.x.abs() >= distance.y.abs();
1688        let (along, scrolled, velocity) = if horizontal { (distance.x, t.scrolled.x, t.velocity.x) } else { (distance.y, t.scrolled.y, t.velocity.y) };
1689        if along.abs() < SWIPE_DISTANCE || velocity.abs() < SWIPE_SPEED || scrolled > SWIPE_SCROLLED || along.signum() != velocity.signum() {
1690            return;
1691        }
1692        let direction = match (horizontal, along > 0.0) {
1693            (true, true) => crate::event::SwipeDirection::Right,
1694            (true, false) => crate::event::SwipeDirection::Left,
1695            (false, true) => crate::event::SwipeDirection::Down,
1696            (false, false) => crate::event::SwipeDirection::Up,
1697        };
1698        let event = crate::event::SwipeEvent { direction, start: t.start, distance, velocity: t.velocity };
1699        // Da borda do form, primeiro a gaveta (como no Android: puxar da borda abre, mesmo com
1700        // um carrossel embaixo); ninguém tratando, segue como um deslizar comum.
1701        let form = self.cb(root).map(|cb| cb.bounds().size()).unwrap_or_default();
1702        let at_edge = t.start.x <= EDGE_SWIPE || t.start.x >= form.width - EDGE_SWIPE || t.start.y <= EDGE_SWIPE || t.start.y >= form.height - EDGE_SWIPE;
1703        if at_edge && self.edge_swipe(root, event) {
1704            return;
1705        }
1706        let target = t.target.filter(|&c| self.is_effectively_enabled(c));
1707        self.swipe_from(target, event);
1708    }
1709
1710    /// O deslizar da borda vai ao `edge_swipe` dos componentes do form (só um trata).
1711    fn edge_swipe(&mut self, root: ComponentId, event: crate::event::SwipeEvent) -> bool {
1712        // De cima para baixo na árvore (raro: só no deslizar da borda). Um escondido também
1713        // ouve (a gaveta fechada fica escondida), mas não os filhos dele.
1714        let mut stack = vec![root];
1715        while let Some(id) = stack.pop() {
1716            // Só habilitado (o escondido conta: quem esconde é ele mesmo, e os pais são visíveis,
1717            // senão o percurso nem chegava aqui).
1718            if !self.cb(id).is_some_and(|cb| cb.enabled()) {
1719                continue;
1720            }
1721            if id != root && self.with_component(id, |c, ctx| c.edge_swipe(ctx, &event)).unwrap_or(false) {
1722                self.request_repaint();
1723                return true;
1724            }
1725            if self.cb(id).is_some_and(|cb| cb.visible()) {
1726                stack.extend(self.children(id).iter().rev().copied());
1727            }
1728        }
1729        false
1730    }
1731
1732    /// Entrega o deslizar ao controle e sobe para os pais até alguém tratar.
1733    fn swipe_from(&mut self, start: Option<ComponentId>, event: crate::event::SwipeEvent) -> bool {
1734        let mut current = start;
1735        while let Some(id) = current {
1736            let e = crate::event::SwipeEvent { start: self.local_point(id, event.start), ..event };
1737            self.fire(id, "on_swipe", &EventArgs::Swipe(e));
1738            if self.deliver(id, |c, ctx| c.swipe(ctx, &e)) {
1739                self.request_repaint();
1740                return true;
1741            }
1742            // `captures_gesture` vale também para o deslizar.
1743            if self.cb(id).is_some_and(|cb| cb.captures_gesture()) {
1744                return true;
1745            }
1746            current = self.parent(id);
1747        }
1748        false
1749    }
1750
1751    // =====================================================================
1752    // Rolagem pelo toque
1753    // =====================================================================
1754
1755    /// O controle (e os pais) aceitam que o arrasto do dedo vire rolagem.
1756    fn pans_on_touch(&self, id: ComponentId) -> bool {
1757        let mut current = Some(id);
1758        while let Some(c) = current {
1759            if self.cb(c).is_some_and(|cb| !cb.pan_on_touch()) {
1760                return false;
1761            }
1762            current = self.parent(c);
1763        }
1764        true
1765    }
1766
1767    /// Movimento de um dedo. Devolve `true` se virou rolagem (o movimento não vai para o
1768    /// controle).
1769    fn touch_pan(&mut self, root: ComponentId, event: PointerEvent) -> bool {
1770        let now = self.time;
1771        let Some(mut t) = self.input_state(root).touch else { return false };
1772        if t.id != event.pointer_id {
1773            return true;
1774        }
1775        if !t.panning {
1776            let moved = event.position - t.start;
1777            if moved.x.abs() < TOUCH_SLOP && moved.y.abs() < TOUCH_SLOP {
1778                return false;
1779            }
1780            let captured = self.input_state(root).captured;
1781            if captured.is_some_and(|c| !self.pans_on_touch(c)) {
1782                // Este controle quer o arrasto (Splitter...): o toque segue normal.
1783                self.input_state(root).touch = None;
1784                return false;
1785            }
1786            // Vira rolagem: o controle tocado solta o toque e não recebe clique.
1787            if let Some(c) = self.input_state(root).captured.take() {
1788                self.set_state_flag(c, Trigger::Pressed, false);
1789            }
1790            self.set_hover(root, None);
1791            self.input_state(root).press = None;
1792            t.panning = true;
1793        }
1794        let delta = event.position - t.last;
1795        let dt = (now - t.time).max(0.004) as f32;
1796        let v = PointF::new(delta.x / dt, delta.y / dt);
1797        t.velocity = PointF::new(t.velocity.x * 0.5 + v.x * 0.5, t.velocity.y * 0.5 + v.y * 0.5);
1798        t.last = event.position;
1799        t.time = now;
1800        self.input_state(root).touch = Some(t);
1801        self.update_layout();
1802        let target = t.target.filter(|&c| self.is_effectively_enabled(c));
1803        // O fim da rolagem (`overscroll.rs`): o puxão aberto fecha antes de rolar de novo; o
1804        // que ninguém rola (o conteúdo na ponta) abre o puxão do contêiner.
1805        let host = self.overscroll_host(target);
1806        let delta = match host {
1807            Some(h) => self.overscroll_take_back(h, delta),
1808            None => delta,
1809        };
1810        let mut scrolled = false;
1811        if delta != PointF::ZERO {
1812            scrolled = self.wheel_from(target, WheelEvent { position: t.start, delta, touch: true, ..Default::default() });
1813            if !scrolled {
1814                match host {
1815                    Some(h) => self.overscroll_drag(h, delta),
1816                    None => scrolled = self.scroll_form(root, delta.y),
1817                }
1818            }
1819        }
1820        if scrolled {
1821            if let Some(t) = self.input_state(root).touch.as_mut() {
1822                t.scrolled = PointF::new(t.scrolled.x + delta.x.abs(), t.scrolled.y + delta.y.abs());
1823            }
1824        }
1825        true
1826    }
1827
1828    /// Há rolagem por inércia em andamento.
1829    pub(crate) fn is_flinging(&self) -> bool {
1830        self.input.values().any(|s| s.fling.is_some())
1831    }
1832
1833    /// Avança a inércia (chamado por [`Ui::tick`]). Para quando a velocidade cai ou quando
1834    /// o conteúdo chega ao fim (ninguém trata a roda).
1835    pub(crate) fn tick_flings(&mut self) {
1836        let now = self.time;
1837        let roots: Vec<ComponentId> = self.input.iter().filter(|(_, s)| s.fling.is_some()).map(|(&r, _)| r).collect();
1838        for root in roots {
1839            let Some(mut f) = self.input_state(root).fling else { continue };
1840            // Limita o passo: depois de uma pausa longa a inércia não dá um salto.
1841            let dt = (now - f.time).clamp(0.0, 0.05) as f32;
1842            if dt <= 0.0 {
1843                continue;
1844            }
1845            let delta = PointF::new(f.velocity.x * dt, f.velocity.y * dt);
1846            let keep = (-FLING_DECAY * dt).exp();
1847            f.velocity = PointF::new(f.velocity.x * keep, f.velocity.y * keep);
1848            f.time = now;
1849            self.input_state(root).fling = Some(f);
1850            self.update_layout();
1851            let target = f.target.filter(|&c| self.is_effectively_enabled(c));
1852            let moved = self.wheel_from(target, WheelEvent { position: f.position, delta, touch: true, ..Default::default() })
1853                || self.scroll_form(root, delta.y);
1854            // "Ninguém rolou" só conta como fim se o passo era de pelo menos um ponto.
1855            if (!moved && speed(delta) >= 1.0) || speed(f.velocity) < FLING_MIN_SPEED {
1856                self.input_state(root).fling = None;
1857                // Bateu na ponta com velocidade: o efeito de fim da rolagem recebe o impulso.
1858                if !moved && speed(f.velocity) >= FLING_MIN_SPEED {
1859                    if let Some(host) = self.overscroll_host(target) {
1860                        self.overscroll_absorb(host, f.velocity);
1861                    }
1862                }
1863            }
1864        }
1865    }
1866
1867    // =====================================================================
1868    // Foco e teclado
1869    // =====================================================================
1870
1871    fn can_take_focus(&self, id: ComponentId) -> bool {
1872        self.cb(id).is_some_and(|cb| cb.can_focus()) && self.is_effectively_enabled(id)
1873    }
1874
1875    fn focusable_ancestor(&self, id: ComponentId) -> Option<ComponentId> {
1876        let mut current = Some(id);
1877        while let Some(c) = current {
1878            if self.can_take_focus(c) {
1879                return Some(c);
1880            }
1881            current = self.parent(c);
1882        }
1883        None
1884    }
1885
1886    /// Dá o foco ao controle (como `SetFocus`). Devolve `false` se ele não pode receber
1887    /// foco (`can_focus` desligado, invisível ou desabilitado).
1888    pub fn set_focus(&mut self, id: ComponentId) -> bool {
1889        if !self.can_take_focus(id) {
1890            return false;
1891        }
1892        let root = self.root_of(id);
1893        let old = self.input_state(root).focused;
1894        if old == Some(id) {
1895            return true;
1896        }
1897        self.input_state(root).focused = Some(id);
1898        if let Some(old) = old.filter(|&o| self.contains(o)) {
1899            self.set_state_flag(old, Trigger::Focused, false);
1900            self.fire(old, "on_exit", &EventArgs::None);
1901            self.deliver(old, |c, ctx| c.focus_exit(ctx));
1902        }
1903        self.set_state_flag(id, Trigger::Focused, true);
1904        self.fire(id, "on_enter", &EventArgs::None);
1905        self.deliver(id, |c, ctx| c.focus_enter(ctx));
1906        true
1907    }
1908
1909    /// Tira o foco de qualquer controle do form.
1910    pub fn clear_focus(&mut self, root: ComponentId) {
1911        if let Some(old) = self.input_state(root).focused.take() {
1912            self.set_state_flag(old, Trigger::Focused, false);
1913            self.fire(old, "on_exit", &EventArgs::None);
1914            self.deliver(old, |c, ctx| c.focus_exit(ctx));
1915        }
1916    }
1917
1918    /// Move o foco para o próximo (ou anterior) controle na ordem da árvore, como o Tab.
1919    pub fn focus_next(&mut self, root: ComponentId, forward: bool) -> bool {
1920        let order = self.tab_order(root);
1921        if order.is_empty() {
1922            return false;
1923        }
1924        let current = self.focused(root).and_then(|f| order.iter().position(|&c| c == f));
1925        let next = match (current, forward) {
1926            (None, true) => 0,
1927            (None, false) => order.len() - 1,
1928            (Some(i), true) => (i + 1) % order.len(),
1929            (Some(i), false) => (i + order.len() - 1) % order.len(),
1930        };
1931        self.set_focus(order[next])
1932    }
1933
1934    /// A ordem do Tab no form: a lista `tab_order` do form (nomes separados por `;`, de
1935    /// qualquer nível) e depois os que não estão nela, na ordem da árvore. Só entra quem
1936    /// pode receber o foco agora (visível, habilitado, `tab_stop`).
1937    pub fn tab_order(&self, root: ComponentId) -> Vec<ComponentId> {
1938        let mut natural = Vec::new();
1939        self.collect_tab_order(root, &mut natural);
1940        let custom = match self.get_prop(root, "tab_order") {
1941            Ok(crate::prop::PropValue::String(s)) if !s.trim().is_empty() => s,
1942            _ => return natural,
1943        };
1944        let mut order: Vec<ComponentId> = custom
1945            .split(';')
1946            .map(str::trim)
1947            .filter(|n| !n.is_empty())
1948            .filter_map(|n| self.find_in(root, n))
1949            .filter(|id| natural.contains(id))
1950            .collect();
1951        order.dedup();
1952        let rest: Vec<ComponentId> = natural.into_iter().filter(|id| !order.contains(id)).collect();
1953        order.extend(rest);
1954        order
1955    }
1956
1957    fn collect_tab_order(&self, id: ComponentId, out: &mut Vec<ComponentId>) {
1958        let Some(cb) = self.cb(id) else { return };
1959        if !cb.visible() || !cb.enabled() {
1960            return;
1961        }
1962        if cb.can_focus() && cb.tab_stop() {
1963            out.push(id);
1964        }
1965        for &c in self.children(id) {
1966            self.collect_tab_order(c, out);
1967        }
1968    }
1969
1970    /// Tecla pressionada: vai para o controle com foco (ou o form) e sobe para os pais
1971    /// até alguém tratar. Tab / Shift+Tab sem tratamento movem o foco.
1972    pub fn key_down(&mut self, root: ComponentId, event: KeyEvent) {
1973        self.report(&crate::activity::Activity::KeyDown { form: root, event });
1974        if self.input_blocked(root) {
1975            return; // há um form modal aberto por cima
1976        }
1977        // Uma tecla anterior espera a resposta do backend: esta vai para a fila, em ordem.
1978        if self.hold_input(root, crate::keyflow::Held::Down(event)) {
1979            return;
1980        }
1981        if event.key == Key::Escape && self.cancel_drag(root) {
1982            return;
1983        }
1984        // Mexeu no teclado: o anel de foco volta a aparecer (fora as teclas de modificador).
1985        if !matches!(event.key, Key::Shift | Key::Control | Key::Alt | Key::Meta) {
1986            self.input_state(root).pointer_focus = false;
1987        }
1988        // As teclas que o form põe no lugar do Tab (`tab_keys`, `back_tab_keys`): o Enter que
1989        // pula de campo, como nos sistemas de cadastro. O controle que usa a tecla (o Enter de
1990        // um Memo) fica com ela.
1991        if let Some(forward) = self.tab_key(root, &event) {
1992            self.focus_next(root, forward);
1993            return;
1994        }
1995        // Alt+← e Alt+→: o mesmo que os botões extras do mouse, antes do controle com foco (o
1996        // editor de texto andaria com o cursor), como nos navegadores e no VS Code. Sem
1997        // `on_navigate` tratando, a tecla segue o caminho normal.
1998        if event.modifiers.alt
1999            && !event.modifiers.ctrl
2000            && !event.modifiers.shift
2001            && matches!(event.key, Key::Left | Key::Right)
2002            && self.navigate(root, event.key == Key::Right)
2003        {
2004            return;
2005        }
2006        self.key_down_flow(root, event);
2007    }
2008
2009    /// Voltar (`forward` falso) ou avançar na navegação da janela `root`: o `on_navigate`,
2010    /// com o texto `"back"` ou `"forward"`, do controle com foco ou do primeiro pai dele que
2011    /// trata (um form embutido, como o editor de código dentro da IDE, antes da janela). É o
2012    /// que os botões extras do mouse, Alt+← e Alt+→ fazem; o app guarda o próprio histórico
2013    /// (as páginas de uma documentação, os lugares por onde o editor passou). Devolve se
2014    /// alguém tratou.
2015    pub fn navigate(&mut self, root: ComponentId, forward: bool) -> bool {
2016        let args = EventArgs::Text(if forward { "forward" } else { "back" }.into());
2017        let mut at = self.focused(root).or(Some(root));
2018        while let Some(id) = at {
2019            if self.fire(id, "on_navigate", &args) {
2020                return true;
2021            }
2022            if id == root {
2023                break;
2024            }
2025            at = self.parent(id);
2026        }
2027        false
2028    }
2029
2030    /// O componente trata a tecla (o `key_down` dele)?
2031    pub(crate) fn deliver_key_down(&mut self, id: ComponentId, event: KeyEvent) -> bool {
2032        self.deliver(id, |c, ctx| c.key_down(ctx, &event))
2033    }
2034
2035    /// Ninguém tratou a tecla: o Tab, os atalhos e as letras com `&`.
2036    pub(crate) fn key_down_unhandled(&mut self, root: ComponentId, event: KeyEvent) {
2037        // O Enter e o Esc que ninguém usou: o botão padrão e o de cancelar do form (o relatório
2038        // do Tabernáculo, J23).
2039        let plain = !event.modifiers.ctrl && !event.modifiers.alt && !event.modifiers.shift && !event.modifiers.meta;
2040        if plain && !event.repeat && matches!(event.key, Key::Enter | Key::Escape) {
2041            let prop = if event.key == Key::Enter { "default_button" } else { "cancel_button" };
2042            if let Some(button) = self.flagged_button(root, prop) {
2043                self.click(button);
2044                return;
2045            }
2046        }
2047        if event.key == Key::Tab && !event.modifiers.ctrl && !event.modifiers.alt {
2048            self.focus_next(root, !event.modifiers.shift);
2049        } else if !event.repeat && !self.dispatch_shortcut(root, event) {
2050            // Alt+letra: o controle com essa letra marcada com "&" na legenda.
2051            if let (true, false, Key::Char(c)) = (event.modifiers.alt, event.modifiers.ctrl, event.key) {
2052                if let Some(id) = self.mnemonic_target(root, c) {
2053                    self.activate_mnemonic(id);
2054                }
2055            }
2056        }
2057    }
2058
2059    /// O primeiro controle à vista e habilitado do form com a propriedade `prop` ligada (o
2060    /// botão padrão ou o de cancelar).
2061    fn flagged_button(&self, root: ComponentId, prop: &str) -> Option<ComponentId> {
2062        let mut stack = vec![root];
2063        while let Some(id) = stack.pop() {
2064            if id != root && self.cb(id).is_some_and(|cb| !cb.visible() || !cb.enabled()) {
2065                continue;
2066            }
2067            if id != root && matches!(self.get_prop(id, prop), Ok(crate::prop::PropValue::Bool(true))) {
2068                return Some(id);
2069            }
2070            stack.extend(self.children(id).iter().rev().copied());
2071        }
2072        None
2073    }
2074
2075    /// A tecla é uma das que o form usa como Tab (`Some(true)`) ou Shift+Tab (`Some(false)`)?
2076    fn tab_key(&self, root: ComponentId, event: &KeyEvent) -> Option<bool> {
2077        let list = |prop: &str| match self.get_prop(root, prop) {
2078            Ok(crate::prop::PropValue::String(s)) => crate::keys::parse_shortcut_list(&s),
2079            _ => Vec::new(),
2080        };
2081        let forward = if list("tab_keys").into_iter().any(|s| crate::keys::shortcut_matches(s, event)) {
2082            true
2083        } else if list("back_tab_keys").into_iter().any(|s| crate::keys::shortcut_matches(s, event)) {
2084            false
2085        } else {
2086            return None;
2087        };
2088        let captured = self.focused(root).and_then(|f| self.component(f)).is_some_and(|c| c.captures_key(event));
2089        (!captured).then_some(forward)
2090    }
2091
2092    /// O controle do form com a letra `c` marcada com `&` na legenda (visível e habilitado,
2093    /// ele e os pais).
2094    pub fn mnemonic_target(&self, root: ComponentId, c: char) -> Option<ComponentId> {
2095        let c = c.to_lowercase().next()?;
2096        let mut stack = vec![root];
2097        while let Some(id) = stack.pop() {
2098            if self.cb(id).is_some_and(|cb| !cb.visible() || !cb.enabled()) && id != root {
2099                continue;
2100            }
2101            if id != root && self.component(id).and_then(|comp| comp.mnemonic_text()).and_then(crate::keys::mnemonic) == Some(c) {
2102                return Some(id);
2103            }
2104            stack.extend(self.children(id).iter().rev());
2105        }
2106        None
2107    }
2108
2109    /// As letras de `&` repetidas no form: cada letra com os controles que a usam (para a
2110    /// IDE avisar).
2111    pub fn mnemonic_conflicts(&self, root: ComponentId) -> Vec<(char, Vec<ComponentId>)> {
2112        let mut seen: Vec<(char, Vec<ComponentId>)> = Vec::new();
2113        let mut stack = vec![root];
2114        while let Some(id) = stack.pop() {
2115            if let Some(m) = self.component(id).and_then(|c| c.mnemonic_text()).and_then(crate::keys::mnemonic) {
2116                match seen.iter_mut().find(|(c, _)| *c == m) {
2117                    Some((_, ids)) => ids.push(id),
2118                    None => seen.push((m, vec![id])),
2119                }
2120            }
2121            stack.extend(self.children(id).iter().rev());
2122        }
2123        seen.retain(|(_, ids)| ids.len() > 1);
2124        seen
2125    }
2126
2127    /// Alt+letra num controle: o rótulo leva o foco ao `focus_control` dele;
2128    /// o que recebe foco e não é clicável (um grupo) passa ao
2129    /// primeiro filho; o resto é clicado.
2130    fn activate_mnemonic(&mut self, id: ComponentId) {
2131        if let Ok(crate::prop::PropValue::Component(Some(target))) = self.get_prop(id, "focus_control") {
2132            self.set_focus(target);
2133            return;
2134        }
2135        if self.component(id).is_some_and(|c| c.mnemonic_focuses_child()) {
2136            let root = self.root_of(id);
2137            let order = self.tab_order(root);
2138            if let Some(&first) = order.iter().find(|&&c| self.is_ancestor(id, c)) {
2139                self.set_focus(first);
2140            }
2141            return;
2142        }
2143        if self.cb(id).is_some_and(|cb| cb.can_focus()) {
2144            self.set_focus(id);
2145        }
2146        self.click(id);
2147    }
2148
2149    /// `ancestor` está acima de `id` na árvore?
2150    fn is_ancestor(&self, ancestor: ComponentId, id: ComponentId) -> bool {
2151        let mut current = self.parent(id);
2152        while let Some(p) = current {
2153            if p == ancestor {
2154                return true;
2155            }
2156            current = self.parent(p);
2157        }
2158        false
2159    }
2160
2161    /// Os caracteres que o componente diz aceitar ou bloquear (`allowed_chars`,
2162    /// `blocked_chars`, `only_allowed`, `chars_override`). `None` se ele não diz nada.
2163    pub fn char_filter_of(&self, id: ComponentId) -> Option<crate::keys::CharFilter> {
2164        use crate::prop::PropValue;
2165        let text = |p: &str| match self.get_prop(id, p) {
2166            Ok(PropValue::String(s)) => s,
2167            _ => String::new(),
2168        };
2169        let flag = |p: &str| matches!(self.get_prop(id, p), Ok(PropValue::Bool(true)));
2170        let filter = crate::keys::CharFilter {
2171            allowed: text("allowed_chars"),
2172            blocked: text("blocked_chars"),
2173            only_allowed: flag("only_allowed"),
2174            overrides: flag("chars_override"),
2175            map: text("char_map"),
2176            case: match self.get_prop(id, "char_case") {
2177                Ok(PropValue::Enum(e)) => <crate::keys::CharCase as crate::prop::PropEnum>::from_name(&e).unwrap_or_default(),
2178                _ => Default::default(),
2179            },
2180        };
2181        (!filter.is_empty()).then_some(filter)
2182    }
2183
2184    /// O caractere pode ser digitado em `id`? Decide o campo e, acima dele, os contêineres
2185    /// até o form: o filho primeiro, a não ser que um pai tenha `chars_override`. `own` é
2186    /// o filtro do próprio campo quando quem pergunta é ele (o componente está ocupado e
2187    /// não responde às propriedades).
2188    pub fn accepts_char(&self, id: ComponentId, own: Option<&crate::keys::CharFilter>, ch: char) -> bool {
2189        let mut chain = Vec::new();
2190        match own {
2191            Some(f) => chain.push(f.clone()),
2192            None => chain.extend(self.char_filter_of(id)),
2193        }
2194        let mut current = self.parent(id);
2195        while let Some(p) = current {
2196            chain.extend(self.char_filter_of(p));
2197            current = self.parent(p);
2198        }
2199        crate::keys::char_allowed(&chain, ch)
2200    }
2201
2202    /// O texto como o campo `id` recebe (o digitado e o colado): o `char_map` (do campo ou dos
2203    /// contêineres), o `char_case` do campo e só os caracteres que ele aceita.
2204    pub fn filter_text(&self, id: ComponentId, own: Option<&crate::keys::CharFilter>, text: &str) -> String {
2205        let mut chain = Vec::new();
2206        match own {
2207            Some(f) => chain.push(f.clone()),
2208            None => chain.extend(self.char_filter_of(id)),
2209        }
2210        let case = chain.first().map(|f| f.case).unwrap_or_default();
2211        let mut current = self.parent(id);
2212        while let Some(p) = current {
2213            chain.extend(self.char_filter_of(p));
2214            current = self.parent(p);
2215        }
2216        let mapped: String = text.chars().map(|c| crate::keys::map_char(&chain, c)).collect();
2217        case.apply(&mapped).chars().filter(|&c| crate::keys::char_allowed(&chain, c)).collect()
2218    }
2219
2220    /// Oferece a tecla aos componentes do form (itens de menu com atalho), até um tratar. Um
2221    /// form embutido (outro form dentro deste, como o editor de código dentro da IDE) onde
2222    /// está o foco tem a vez primeiro: o Ctrl+S dele vale mais que o do form de fora.
2223    fn dispatch_shortcut(&mut self, root: ComponentId, event: KeyEvent) -> bool {
2224        let menus = self.active_popup_menus(root);
2225        let mut current = self.focused(root).and_then(|f| self.parent(f));
2226        while let Some(p) = current.filter(|&p| p != root) {
2227            if self.class_name(p) == Some("Form") && self.dispatch_in(p, event, &menus) {
2228                return true;
2229            }
2230            current = self.parent(p);
2231        }
2232        self.dispatch_in(root, event, &menus)
2233    }
2234
2235    /// Os menus de contexto cujos atalhos valem agora: os do `popup_menu` do controle com o
2236    /// foco e dos pais dele, até o form (antes valiam todos, até
2237    /// com o menu de outro controle; o relatório do Tabernáculo, J01).
2238    fn active_popup_menus(&self, root: ComponentId) -> Vec<ComponentId> {
2239        let mut out = Vec::new();
2240        let mut current = self.focused(root).or(Some(root));
2241        while let Some(id) = current {
2242            if let Ok(crate::PropValue::Component(Some(menu))) = self.get_prop(id, "popup_menu") {
2243                out.push(menu);
2244            }
2245            current = self.parent(id);
2246        }
2247        out
2248    }
2249
2250    fn dispatch_in(&mut self, root: ComponentId, event: KeyEvent, menus: &[ComponentId]) -> bool {
2251        let mut stack = vec![root];
2252        while let Some(id) = stack.pop() {
2253            if self.cb(id).is_some_and(|cb| !cb.visible() || !cb.enabled()) && id != root {
2254                continue;
2255            }
2256            if self.class_name(id) == Some("PopupMenu") && !menus.contains(&id) {
2257                continue;
2258            }
2259            if self.deliver(id, |c, ctx| c.shortcut(ctx, &event)) {
2260                return true;
2261            }
2262            stack.extend(self.children(id).iter().rev());
2263        }
2264        false
2265    }
2266
2267    pub fn key_up(&mut self, root: ComponentId, event: KeyEvent) {
2268        self.report(&crate::activity::Activity::KeyUp { form: root, event });
2269        if self.input_blocked(root) {
2270            return; // há um form modal aberto por cima
2271        }
2272        if self.hold_input(root, crate::keyflow::Held::Up(event)) {
2273            return;
2274        }
2275        self.bubble_key(root, |c, ctx| c.key_up(ctx, &event), "on_key_up", event);
2276    }
2277
2278    fn bubble_key(
2279        &mut self,
2280        root: ComponentId,
2281        f: impl Fn(&mut dyn Component, &mut EventCtx<'_>),
2282        event_name: &str,
2283        event: KeyEvent,
2284    ) -> bool {
2285        let mut current = self.focused(root).or(Some(root));
2286        while let Some(id) = current {
2287            self.fire(id, event_name, &EventArgs::Key(event));
2288            let handled = self.deliver(id, &f);
2289            if handled {
2290                return true;
2291            }
2292            current = self.parent(id);
2293        }
2294        false
2295    }
2296
2297    /// O controle com foco edita texto: no celular a plataforma mostra o teclado virtual
2298    /// enquanto isto for verdade.
2299    pub fn wants_text_input(&self, root: ComponentId) -> bool {
2300        self.focused(root).and_then(|f| self.component(f)).is_some_and(|c| c.accepts_text())
2301    }
2302
2303    /// Texto digitado (já com acentos/IME resolvidos), entregue ao controle com foco.
2304    pub fn text_input(&mut self, root: ComponentId, text: &str) {
2305        self.report(&crate::activity::Activity::Text { form: root, text });
2306        if self.input_blocked(root) {
2307            return; // há um form modal aberto por cima
2308        }
2309        if self.hold_input(root, crate::keyflow::Held::Text(text.to_string())) {
2310            return;
2311        }
2312        if let Some(id) = self.focused(root) {
2313            // `char_map`, `char_case` e os caracteres que o campo (ou um pai dele) não aceita.
2314            let text = self.filter_text(id, None, text);
2315            if text.is_empty() {
2316                return;
2317            }
2318            self.press_chars(root, id, text.chars().collect());
2319        }
2320    }
2321}
2322
2323/// Desfaz o giro do controle (em volta do centro) num ponto já relativo a ele: a pintura
2324/// gira com `rotation`, e o clique tem de cair no mesmo lugar.
2325/// Do retângulo do controle (já sem o lugar e o giro) para o espaço de dentro dele (`scale`).
2326fn unscale(cb: &crate::component::ControlBase, local: PointF) -> PointF {
2327    let s = cb.scale();
2328    if s == 1.0 { local } else { PointF::new(local.x / s, local.y / s) }
2329}
2330
2331fn unrotate(cb: &crate::component::ControlBase, local: PointF) -> PointF {
2332    let degrees = cb.rotation();
2333    if degrees == 0.0 {
2334        return local;
2335    }
2336    let b = cb.bounds();
2337    let (cx, cy) = (b.width / 2.0, b.height / 2.0);
2338    let (s, c) = (-degrees.to_radians()).sin_cos();
2339    let (dx, dy) = (local.x - cx, local.y - cy);
2340    PointF::new(cx + dx * c - dy * s, cy + dx * s + dy * c)
2341}
2342
2343/// O `on_drag_over` aceitou? (não recusou e não respondeu `accept` falso).
2344fn drag_accepted(answer: &crate::question::Answer) -> bool {
2345    !answer.is_refused() && answer.flag("accept", true)
2346}