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}