Skip to main content

aylis_core/
event.rs

1//! Tipos de eventos de entrada (independentes de plataforma) e o contexto de evento.
2//!
3//! A plataforma traduz os eventos nativos para estes tipos; o core nunca vê um evento
4//! do Windows, X11, Android etc.
5
6use crate::component::ComponentId;
7use crate::geometry::PointF;
8use crate::prop::PropValue;
9use crate::ui::Ui;
10
11/// Teclas modificadoras pressionadas.
12#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
13pub struct Modifiers {
14    pub shift: bool,
15    pub ctrl: bool,
16    pub alt: bool,
17    /// Tecla Windows / Command.
18    pub meta: bool,
19}
20
21#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
22pub enum PointerButton {
23    #[default]
24    Primary,
25    Secondary,
26    Middle,
27    Back,
28    Forward,
29}
30
31/// Origem do ponteiro: mouse, toque ou caneta.
32#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
33pub enum PointerKind {
34    #[default]
35    Mouse,
36    Touch,
37    Pen,
38}
39
40/// Evento de ponteiro (mouse e toque unificados).
41#[derive(Clone, Copy, Debug, Default, PartialEq)]
42pub struct PointerEvent {
43    /// Posição relativa ao controle que recebe o evento.
44    pub position: PointF,
45    pub button: PointerButton,
46    pub kind: PointerKind,
47    pub modifiers: Modifiers,
48    /// 1 = clique simples, 2 = duplo...
49    pub click_count: u8,
50    /// Distingue dedos em multitoque.
51    pub pointer_id: u64,
52}
53
54/// O ponteiro do clique que está sendo entregue ([`Ui::click_pointer`](crate::Ui::click_pointer)):
55/// o `on_click` não muda de argumento (os handlers das outras linguagens dependem dele), e
56/// quem quer saber onde, com que botão e com que teclas foi o clique pergunta ao `Ui`.
57#[derive(Clone, Copy, Debug, Default, PartialEq)]
58pub struct ClickPointer {
59    /// Onde, nas coordenadas do controle que disparou o `on_click`.
60    pub position: PointF,
61    /// Onde, nas coordenadas do form.
62    pub form_position: PointF,
63    pub button: PointerButton,
64    pub modifiers: Modifiers,
65    /// Mouse, toque ou caneta (o clique do teclado ou do código não tem ponteiro).
66    pub kind: PointerKind,
67    /// 1 = clique simples, 2 = duplo...
68    pub click_count: u8,
69}
70
71/// Roda do mouse ou rolagem do touchpad.
72#[derive(Clone, Copy, Debug, Default, PartialEq)]
73pub struct WheelEvent {
74    pub position: PointF,
75    /// Deslocamento em unidades lógicas.
76    pub delta: PointF,
77    pub modifiers: Modifiers,
78    /// Veio de um dedo arrastando (ou da inércia depois dele): o conteúdo deve acompanhar
79    /// o dedo 1:1, sem a aceleração da roda do mouse.
80    pub touch: bool,
81    /// Veio de uma roda com dentes: cada dente já vem com o passo do app
82    /// ([`ScrollOptions::wheel_step`](crate::ScrollOptions)) em `delta`.
83    pub lines: bool,
84}
85
86/// O passo padrão de um dente da roda (pontos lógicos).
87pub const WHEEL_LINE: f32 = 100.0;
88
89/// Como a roda rola as listas e caixas de rolagem do app ([`Ui::set_scroll_options`](crate::Ui::set_scroll_options)).
90#[derive(Clone, Copy, Debug, PartialEq)]
91pub struct ScrollOptions {
92    /// Pontos por dente da roda (100 = o padrão, como nos navegadores).
93    pub wheel_step: f32,
94    /// Desliza até a posição nova em vez de saltar.
95    pub smooth: bool,
96    /// Duração do deslize, em ms.
97    pub smooth_ms: f32,
98}
99
100impl Default for ScrollOptions {
101    fn default() -> Self {
102        Self { wheel_step: WHEEL_LINE, smooth: true, smooth_ms: 180.0 }
103    }
104}
105
106/// Para onde o dedo deslizou (o `on_swipe`).
107#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
108pub enum SwipeDirection {
109    #[default]
110    Left,
111    Right,
112    Up,
113    Down,
114}
115
116impl SwipeDirection {
117    /// O nome no protocolo e nos eventos (`left`, `right`, `up`, `down`).
118    pub fn name(self) -> &'static str {
119        match self {
120            SwipeDirection::Left => "left",
121            SwipeDirection::Right => "right",
122            SwipeDirection::Up => "up",
123            SwipeDirection::Down => "down",
124        }
125    }
126}
127
128/// Um deslizar do dedo (decidido em 14/11): um arrasto rápido que não rolou nada no mesmo
129/// eixo, ao soltar. O controle tocado recebe `on_swipe`; se não tratar, sobe para os pais.
130#[derive(Clone, Copy, Debug, Default, PartialEq)]
131pub struct SwipeEvent {
132    pub direction: SwipeDirection,
133    /// Onde o dedo encostou (coordenadas do controle que recebe).
134    pub start: PointF,
135    /// Quanto o dedo andou do começo ao fim.
136    pub distance: PointF,
137    /// A velocidade ao soltar, em pontos por segundo.
138    pub velocity: PointF,
139}
140
141/// Gesto de dois dedos: pinça (escala), giro e arrasto do centro.
142/// O controle sob o primeiro dedo recebe; se não
143/// tratar, sobe para os pais.
144#[derive(Clone, Copy, Debug, Default, PartialEq)]
145pub struct GestureEvent {
146    pub phase: GesturePhase,
147    /// O ponto entre os dois dedos (coordenadas do controle).
148    pub center: PointF,
149    /// Escala desde o começo do gesto (1 = igual, 2 = dedos o dobro mais afastados).
150    pub scale: f32,
151    /// Escala desde o evento anterior (multiplique o zoom por ela).
152    pub delta_scale: f32,
153    /// Giro desde o começo, em radianos (positivo no sentido horário da tela).
154    pub rotation: f32,
155    /// Giro desde o evento anterior.
156    pub delta_rotation: f32,
157    /// Quanto o centro andou desde o evento anterior.
158    pub pan: PointF,
159}
160
161#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
162pub enum GesturePhase {
163    #[default]
164    Begin,
165    Update,
166    End,
167}
168
169/// Tecla (códigos do aylis, não do sistema).
170#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
171pub enum Key {
172    #[default]
173    Unknown,
174    Enter,
175    Tab,
176    Escape,
177    Backspace,
178    Delete,
179    Insert,
180    Home,
181    End,
182    PageUp,
183    PageDown,
184    Left,
185    Right,
186    Up,
187    Down,
188    Space,
189    /// F1 = `F(1)`...
190    F(u8),
191    /// Tecla de caractere (letra, número, símbolo), já em minúscula.
192    Char(char),
193    Shift,
194    Control,
195    Alt,
196    Meta,
197}
198
199#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
200pub struct KeyEvent {
201    pub key: Key,
202    pub modifiers: Modifiers,
203    /// Repetição automática por tecla mantida pressionada.
204    pub repeat: bool,
205}
206
207/// Argumentos entregues aos handlers de evento.
208///
209/// Um tipo só para todos os eventos simplifica o encaminhamento por nome, pela C ABI e
210/// pelo protocolo remoto.
211#[derive(Clone, Debug, Default, PartialEq)]
212pub enum EventArgs {
213    #[default]
214    None,
215    Pointer(PointerEvent),
216    Wheel(WheelEvent),
217    Gesture(GestureEvent),
218    Swipe(SwipeEvent),
219    Key(KeyEvent),
220    Text(String),
221    Value(PropValue),
222    /// O `on_intercept`/`after_intercept` de um `EventInterceptor`: o evento interceptado.
223    Intercept(Box<Intercepted>),
224}
225
226/// Um evento que passa por um `EventInterceptor` (veja `intercept.rs`).
227#[derive(Clone, Debug, Default, PartialEq)]
228pub struct Intercepted {
229    /// O form do componente que disparou.
230    pub form: Option<crate::component::ComponentId>,
231    /// O componente que disparou.
232    pub sender: Option<crate::component::ComponentId>,
233    /// O nome do evento (`on_click`, `before_post`...).
234    pub event: String,
235    /// O handler ligado ao evento (vazio: nenhum, ou uma closure em Rust).
236    pub handler: String,
237    /// Os argumentos do evento.
238    pub args: EventArgs,
239}
240
241impl EventArgs {
242    /// O texto do evento, venha como `Text` (ComboBox, ListBox) ou como valor texto
243    /// (`Edit`, que manda o `text` novo como `Value`). Quem trata um `on_change` de texto
244    /// usa isto e não depende de qual dos dois o controle manda.
245    pub fn text(&self) -> Option<&str> {
246        match self {
247            EventArgs::Text(t) => Some(t),
248            EventArgs::Value(PropValue::String(t)) => Some(t),
249            _ => None,
250        }
251    }
252}
253
254/// Mensagem ([`Ui::send_message`](crate::Ui::send_message)) que o `Ui` manda ao menu de
255/// contexto de um controle (a propriedade `popup_menu`) no clique direito: o menu se abre
256/// em `at` (coordenadas do form). `source` é o controle clicado.
257#[derive(Clone, Copy, Debug, PartialEq)]
258pub struct PopupRequest {
259    pub at: crate::geometry::PointF,
260    pub source: crate::component::ComponentId,
261}
262
263/// Contexto entregue aos métodos de evento de um componente.
264///
265/// Enquanto o método roda, o componente está "fora" do `Ui` (por isso `ui.get(ctx.id)`
266/// devolve `None` ali dentro). Os eventos disparados com [`fire`](Self::fire) são
267/// entregues aos handlers depois que o método termina, quando o componente já voltou —
268/// assim um handler pode alterar o próprio componente que disparou o evento.
269pub struct EventCtx<'a> {
270    pub ui: &'a mut Ui,
271    pub id: ComponentId,
272    pub(crate) handled: bool,
273}
274
275impl<'a> EventCtx<'a> {
276    pub fn new(ui: &'a mut Ui, id: ComponentId) -> Self {
277        Self { ui, id, handled: false }
278    }
279
280    /// Agenda o evento `event` (por exemplo `"on_click"`) deste componente.
281    pub fn fire(&mut self, event: &str, args: EventArgs) {
282        self.ui.queue_event(self.id, event, args);
283    }
284
285    /// Pede uma nova pintura. Chame quando o método mudar algo visual do próprio
286    /// componente (alterações feitas por `ctx.ui` já pedem sozinhas). Só a área dele é
287    /// repintada ([`Ui::damage`](crate::Ui::damage)); se o desenho mudou fora dela, use
288    /// `ctx.ui.request_repaint()`.
289    pub fn repaint(&mut self) {
290        self.ui.damage(self.id);
291    }
292
293    /// Só a parte `rect` do componente mudou (nas coordenadas dele): a barra de rolagem, o
294    /// cursor. Veja [`Ui::damage_part`](crate::Ui::damage_part).
295    pub fn repaint_part(&mut self, rect: crate::RectF) {
296        self.ui.damage_part(self.id, rect);
297    }
298
299    /// O conteúdo de `rect` (nas coordenadas do componente) andou `delta` (a rolagem): a
300    /// plataforma copia os pixels já pintados e só a faixa que apareceu é pintada. Veja
301    /// [`Ui::scroll_damage`](crate::Ui::scroll_damage).
302    pub fn scrolled(&mut self, rect: crate::RectF, delta: crate::PointF) {
303        self.ui.scroll_damage(self.id, rect, delta);
304    }
305
306    /// Pede novo layout e nova pintura (quando o método mudou tamanho, posição,
307    /// alinhamento... do próprio componente).
308    pub fn invalidate(&mut self) {
309        self.ui.invalidate_form(self.id);
310    }
311
312    /// Muda o foco para `id` assim que este método terminar. Use dentro de métodos de
313    /// evento: enquanto o método roda, o próprio componente está fora do `Ui` e não pode
314    /// ganhar nem perder o foco na hora.
315    pub fn request_focus(&mut self, id: ComponentId) {
316        self.ui.pending_focus = Some(id);
317    }
318
319    /// Marca o evento como tratado (não propaga para o pai).
320    pub fn set_handled(&mut self) {
321        self.handled = true;
322    }
323
324    pub fn handled(&self) -> bool {
325        self.handled
326    }
327}