1use crate::types::vecmap::VecMap;
164use std::collections::HashMap;
165use std::fmt;
166
167use smallvec::SmallVec;
168use uzor::input::core::cook::CookState;
169use uzor::input::driver::CoordinatorDriver;
170use uzor::input::text::selection::{char_at_point, SelectionLine, TextSelection};
171use uzor::input::{
172 InputCoordinator, InputState, KeyCode, KeyPress, ModifierKeys, MouseButton, TextAction,
173 TextFieldStore, WidgetKind,
174};
175use uzor::{Rect, WidgetId};
176
177use crate::types::bus::{
178 ClipboardResult, ImeInput, KeyInput, KeyState, PointerInput, WheelDelta, WheelInput,
179};
180use crate::types::ids::{Revision, ScopeId, Seconds, Ticket, WindowId};
181use crate::types::intent::TextIntent;
182use crate::types::ops::{
183 Capture, CookedPointer, FocusOp, InputEffect, InputOp, PointerTarget, ScopeOwner,
184};
185use crate::types::snapshot::InputView;
186
187pub type InputEffects = SmallVec<[InputEffect; 2]>;
189
190pub const INPUT_TICKET_BASE: u64 = 1 << 63;
193
194#[allow(dead_code)]
197pub const CARET_BLINK_INTERVAL: Seconds = Seconds(0.5);
198
199const CARET_BLINK_MS: u64 = 500;
200
201const WHEEL_PIXELS_PER_LINE: f64 = 20.0;
204
205#[derive(Clone, Debug, Default)]
212struct PointerAccum {
213 pos: Option<(f64, f64)>,
214 prev_pos: Option<(f64, f64)>,
215 button_down: Option<MouseButton>,
216 clicked: Option<MouseButton>,
217 context: Option<(f64, f64)>,
219 mods: ModifierKeys,
220 scroll: (f64, f64),
221 scroll_precise: bool,
223}
224
225#[derive(Clone, Debug, PartialEq, Eq)]
227struct SavedFocus {
228 id: WidgetId,
229 engaged: bool,
231}
232
233#[derive(Clone, Debug)]
234struct FocusScope {
235 owner: ScopeOwner,
236 members: Vec<WidgetId>,
237 saved: Option<SavedFocus>,
238}
239
240#[derive(Clone, Debug)]
243struct SelectableText {
244 text: String,
245 lines: Vec<SelectionLine>,
246}
247
248#[derive(Clone, Debug, Default)]
252pub struct Selectables(HashMap<WidgetId, SelectableText>, HashMap<WidgetId, WidgetId>);
253
254impl Selectables {
255 pub fn report(&mut self, widget: impl Into<WidgetId>, text: impl Into<String>, lines: Vec<SelectionLine>) {
258 self.0.insert(widget.into(), SelectableText { text: text.into(), lines });
259 }
260 pub fn alias(&mut self, member: impl Into<WidgetId>, owner: impl Into<WidgetId>) {
264 self.1.insert(member.into(), owner.into());
265 }
266 fn contains_key(&self, w: &WidgetId) -> bool {
267 self.0.contains_key(w)
268 }
269}
270
271#[derive(Clone, Debug)]
273struct PressSel {
274 widget: WidgetId,
275 anchor: usize,
276}
277
278#[derive(Clone, Copy, Debug, PartialEq, Eq)]
280enum EscLevel {
281 Widget,
283 Panel,
285 Window,
287}
288
289#[derive(Clone, Debug, PartialEq, Eq)]
292struct CaretKey {
293 field: WidgetId,
294 engaged: bool,
295 text: String,
296 cursor: usize,
297 selection: Option<usize>,
298 preedit: String,
299 preedit_cursor: usize,
300}
301
302#[derive(Clone, Debug, PartialEq, Eq)]
304struct Focused {
305 id: WidgetId,
306 field: bool,
308}
309
310struct PerWindowInput {
311 coord: InputCoordinator,
312 states: uzor::app_context::StateRegistry,
316 cook: CookState,
317 pointer: PointerAccum,
318 capture: Option<Capture>,
319 scopes: Vec<FocusScope>,
320 focus: Option<Focused>,
321 hover: Option<WidgetId>,
322 pressed: Option<WidgetId>,
323 clicked: SmallVec<[(WidgetId, u8); 2]>,
324 os_focused: bool,
325 caret: Option<CaretKey>,
326 blink_anchor_ms: u64,
327 caret_visible: bool,
328 armed: Option<Seconds>,
329 ime_area: Option<Rect>,
330 ime_allowed: bool,
331 pending_paste: Option<(Ticket, Option<WidgetId>)>,
334 offer: Option<String>,
336 selectables: HashMap<WidgetId, SelectableText>,
340 sel_alias: HashMap<WidgetId, WidgetId>,
342 reported: Selectables,
343 selections: Vec<(WidgetId, TextSelection)>,
344 press_sel: Option<PressSel>,
345 drag_ended: bool,
346 escalation: Option<(WidgetId, EscLevel)>,
347 focus_visible: bool,
350 key_clicks: Vec<WidgetId>,
353 space_armed: Option<WidgetId>,
355}
356
357fn activation(kind: Option<WidgetKind>) -> (bool, bool) {
361 use WidgetKind as K;
362 match kind {
363 Some(K::Link) => (true, false),
364 Some(K::Checkbox | K::Radio | K::Toggle) => (false, true),
365 Some(K::Button | K::CloseButton | K::ChromeTab | K::DropdownTrigger | K::Item | K::ColorSwatch | K::Custom) | None => (true, true),
366 Some(_) => (false, false),
367 }
368}
369
370impl PerWindowInput {
371 fn new() -> Self {
372 Self {
373 coord: InputCoordinator::new(),
374 states: uzor::app_context::StateRegistry::new(),
375 cook: CookState::default(),
376 pointer: PointerAccum::default(),
377 capture: None,
378 scopes: Vec::new(),
379 focus: None,
380 hover: None,
381 pressed: None,
382 clicked: SmallVec::new(),
383 os_focused: true,
386 caret: None,
387 blink_anchor_ms: 0,
388 caret_visible: false,
389 armed: None,
390 ime_area: None,
391 ime_allowed: false,
392 pending_paste: None,
393 offer: None,
394 selectables: HashMap::new(),
395 sel_alias: HashMap::new(),
396 reported: Selectables::default(),
397 selections: Vec::new(),
398 press_sel: None,
399 drag_ended: false,
400 escalation: None,
401 focus_visible: false,
402 key_clicks: Vec::new(),
403 space_armed: None,
404 }
405 }
406
407 fn allowed(&self, id: &WidgetId) -> bool {
412 self.scopes.last().is_none_or(|s| s.members.contains(id))
413 }
414
415 fn focus_raw(&mut self, id: WidgetId) {
418 let field = self.coord.text_fields().has_field(&id);
419 if field && self.coord.text_fields().is_focused(&id) {
420 self.coord.set_focus(id.clone());
424 } else if field {
425 self.coord.focus_text_field(&id);
426 } else {
427 self.coord.set_focus(id.clone());
428 }
429 self.focus = Some(Focused { id, field });
430 }
431
432 fn clear_raw(&mut self) -> bool {
433 let had = self.focus.is_some() || self.coord.text_fields().focused().is_some();
434 self.coord.clear_focus();
435 self.focus = None;
436 had
437 }
438
439 fn focused_id(&self) -> Option<&WidgetId> {
440 self.focus.as_ref().map(|f| &f.id)
441 }
442
443 fn scoped_candidates(&self) -> Option<Vec<WidgetId>> {
446 let scope = self.scopes.last()?;
447 Some(
448 scope
449 .members
450 .iter()
451 .filter(|m| self.coord.widget_rect(m).is_some() && self.coord.tab_index(m) >= 0)
452 .cloned()
453 .collect(),
454 )
455 }
456
457 fn cycle(&mut self, forward: bool) -> Option<bool> {
459 let before = self.focus.clone();
460 match self.scoped_candidates() {
461 Some(list) => {
462 if list.is_empty() {
463 return None;
464 }
465 let n = list.len();
466 let at = self
467 .focused_id()
468 .and_then(|f| list.iter().position(|m| m == f));
469 let next = match (at, forward) {
470 (Some(i), true) => (i + 1) % n,
471 (None, true) => 0,
472 (Some(i), false) => (i + n - 1) % n,
473 (None, false) => n - 1,
474 };
475 if self.focused_id() != Some(&list[next]) {
476 self.focus_raw(list[next].clone());
477 }
478 }
479 None => {
480 if forward {
481 self.coord.focus_next();
482 } else {
483 self.coord.focus_prev();
484 }
485 let target = self.coord.focused_widget().cloned()?;
486 if self.focused_id() != Some(&target) || !self.store_matches_focus() {
487 self.focus_raw(target);
488 }
489 }
490 }
491 Some(self.focus != before)
492 }
493
494 fn store_matches_focus(&self) -> bool {
496 let store = self.coord.text_fields().focused();
497 match &self.focus {
498 Some(f) if f.field => store == Some(&f.id),
499 _ => store.is_none(),
500 }
501 }
502
503 fn focus_op(
504 &mut self,
505 win: WindowId,
506 op: FocusOp,
507 next_scope: &mut u64,
508 fx: &mut InputEffects,
509 ) -> bool {
510 match op {
511 FocusOp::Set(id) => {
512 if !self.allowed(&id) || self.focused_id() == Some(&id) {
513 return false;
514 }
515 self.focus_raw(id);
516 true
517 }
518 FocusOp::Clear => self.clear_raw(),
519 FocusOp::Next => self.cycle(true).unwrap_or(false),
520 FocusOp::Prev => self.cycle(false).unwrap_or(false),
521 FocusOp::PushScope { owner, members } => {
522 if self.scopes.iter().any(|s| s.owner == owner) {
523 return self.set_members(&owner, members);
524 }
525 let saved = self.focus.as_ref().map(|f| SavedFocus {
526 engaged: f.field && self.coord.text_fields().is_engaged(&f.id),
527 id: f.id.clone(),
528 });
529 self.clear_raw();
530 self.scopes.push(FocusScope {
531 owner: owner.clone(),
532 members,
533 saved,
534 });
535 *next_scope += 1;
536 fx.push(InputEffect::ScopePushed {
537 win,
538 owner,
539 scope: ScopeId(*next_scope),
540 });
541 true
542 }
543 FocusOp::SetMembers { owner, members } => self.set_members(&owner, members),
544 FocusOp::PopScope { owner, restore } => self.pop_scope(&owner, restore),
545 }
546 }
547
548 fn set_members(&mut self, owner: &ScopeOwner, members: Vec<WidgetId>) -> bool {
549 let Some(i) = self.scopes.iter().position(|s| &s.owner == owner) else {
550 return false;
551 };
552 if self.scopes[i].members == members {
553 return false;
554 }
555 self.scopes[i].members = members;
556 let active = i + 1 == self.scopes.len();
557 if active {
558 if let Some(f) = self.focused_id().cloned() {
559 if !self.allowed(&f) {
560 self.clear_raw();
561 }
562 }
563 }
564 true
565 }
566
567 fn pop_scope(&mut self, owner: &ScopeOwner, restore: bool) -> bool {
568 let Some(i) = self.scopes.iter().position(|s| &s.owner == owner) else {
569 return false;
570 };
571 let scope = self.scopes.remove(i);
572 if i < self.scopes.len() {
573 self.scopes[i].saved = scope.saved;
576 return true;
577 }
578 self.clear_raw();
579 if let (true, Some(saved)) = (restore, scope.saved) {
580 if self.allowed(&saved.id) {
581 self.focus_raw(saved.id.clone());
582 if saved.engaged {
583 self.coord.text_fields_mut().engage(&saved.id);
584 }
585 }
586 }
587 true
588 }
589
590 fn reconcile_focus(&mut self) -> bool {
593 let store = self.coord.text_fields().focused().cloned();
594 match (store, self.focus.clone()) {
595 (Some(s), Some(f)) if f.field && s == f.id => false,
596 (Some(s), _) if self.allowed(&s) => {
597 self.coord.set_focus(s.clone());
598 self.focus = Some(Focused { id: s, field: true });
599 true
600 }
601 (Some(_), prev) => {
602 self.coord.text_fields_mut().blur();
604 if let Some(f) = prev.filter(|f| f.field) {
605 let engaged = self.coord.text_fields().is_engaged(&f.id);
606 self.coord.focus_text_field(&f.id);
607 if engaged {
608 self.coord.text_fields_mut().engage(&f.id);
609 }
610 }
611 false
612 }
613 (None, Some(f)) if f.field => {
614 self.coord.clear_focus();
616 self.focus = None;
617 true
618 }
619 (None, _) => false,
620 }
621 }
622
623 fn set_capture(&mut self, capture: Option<Capture>) -> bool {
626 if self.capture == capture {
627 return false;
628 }
629 if let Some(Capture::Widget(_)) = &self.capture {
630 self.coord.release_pointer();
631 }
632 if let Some(Capture::Widget(id)) = &capture {
633 self.coord.grab_pointer(id.clone());
634 }
635 self.capture = capture;
636 true
637 }
638
639 fn cook(&mut self, win: WindowId, now: Seconds, input: PointerInput) -> (bool, CookedPointer) {
640 let t = now.get();
641 let target = match &self.capture {
642 Some(c) => PointerTarget::Captured(c.clone()),
643 None => PointerTarget::HitTest,
644 };
645 let mut drag_started = false;
646 let mut ended_drag = false;
647 let mut changed = false;
648 if matches!(input, PointerInput::Down { .. }) && self.focus_visible {
651 self.focus_visible = false;
652 changed = true;
653 }
654 match input {
655 PointerInput::Moved { pos, mods } => {
656 self.pointer.pos = Some((pos.x, pos.y));
657 self.pointer.mods = mods;
658 drag_started = self.cook.motion(pos.x, pos.y).drag_started;
659 }
660 PointerInput::Down { pos, button, mods } => {
661 self.pointer.pos = Some((pos.x, pos.y));
662 self.pointer.mods = mods;
663 if self.cook.press_origin.is_none() {
665 self.cook.press(pos.x, pos.y, button, t);
666 }
667 }
668 PointerInput::Up { pos, button, mods } => {
669 self.pointer.pos = Some((pos.x, pos.y));
670 self.pointer.mods = mods;
671 if self.cook.press_origin.map(|o| o.button) == Some(button) {
672 ended_drag = self.cook.release(pos.x, pos.y, button, t);
673 self.drag_ended |= ended_drag;
674 changed = self.set_capture(None);
675 }
676 }
677 PointerInput::Entered | PointerInput::RawDelta { .. } => {}
678 PointerInput::Left => self.pointer.pos = None,
679 PointerInput::Cancelled => {
680 self.cook.press_origin = None;
681 self.cook.drag_armed = false;
682 self.pointer.button_down = None;
683 changed = self.set_capture(None);
684 changed |= self.pressed.take().is_some();
685 self.press_sel = None;
686 self.drag_ended = false;
687 }
688 }
689 if drag_started {
693 let grab = self
694 .pressed
695 .clone()
696 .filter(|id| self.coord.widget_sense(id).is_some_and(|s| s.drag));
697 if let Some(id) = grab {
698 changed = self.set_capture(Some(Capture::Widget(id)));
699 }
700 }
701 let cooked = CookedPointer {
702 win,
703 input,
704 click_count: self.cook.click_count,
705 drag_armed: self.cook.drag_armed,
706 drag_started,
707 ended_drag,
708 target,
709 };
710 (changed, cooked)
711 }
712
713 fn content_target(&self, pos: Option<(f64, f64)>) -> Option<WidgetId> {
716 if let Some(Capture::Widget(id)) = &self.capture {
717 return Some(id.clone());
718 }
719 let (x, y) = pos?;
720 self.coord.hit_test_now(x, y)
721 }
722
723 fn deliver(
724 &mut self,
725 win: WindowId,
726 input: PointerInput,
727 fx: &mut InputEffects,
728 ) -> (bool, Option<WidgetId>) {
729 match input {
730 PointerInput::Moved { pos, .. } => {
731 self.pointer.pos = Some((pos.x, pos.y));
732 let target = self.content_target(self.pointer.pos);
736 let mut changed = self.pointer.button_down.is_some() || target != self.hover;
737 if self.pointer.button_down == Some(MouseButton::Left)
740 && self.cook.drag_armed
741 && self.coord.text_fields().drag_active()
742 {
743 self.coord.text_fields_mut().on_drag_move_xy(pos.x, pos.y);
744 changed = true;
745 }
746 (changed, target)
747 }
748 PointerInput::Down { pos, button, .. } => {
749 self.pointer.pos = Some((pos.x, pos.y));
750 self.pointer.button_down = Some(button);
751 self.pointer.clicked = None;
755 let target = self.content_target(self.pointer.pos);
756 let changed = self.pressed != target;
757 self.pressed.clone_from(&target);
758 let t = target.as_ref().map(|t| self.sel_owner(t));
759 let sel_changed = self.press_down(win, t.as_ref(), pos.x, pos.y, fx);
760 if button == MouseButton::Left {
761 self.arm_text_drag(target.as_ref(), pos.x, pos.y);
762 } else if self.coord.text_fields().drag_active() {
763 self.coord.text_fields_mut().on_drag_end();
764 }
765 let blurred = self.blur_text_on_outside_press(target.as_ref());
766 (changed | sel_changed | blurred, target)
767 }
768 PointerInput::Up { pos, button, .. } => {
769 self.pointer.pos = Some((pos.x, pos.y));
770 self.pointer.button_down = None;
771 self.pointer.clicked = Some(button);
772 if button == MouseButton::Right {
773 self.pointer.context = Some((pos.x, pos.y));
774 }
775 let target = self.content_target(self.pointer.pos);
776 let _ = self.pressed.take();
777 let t = target.as_ref().map(|t| self.sel_owner(t));
778 let _ = self.release_select(win, t.as_ref(), fx);
779 if button == MouseButton::Left && self.coord.text_fields().drag_active() {
783 self.coord.text_fields_mut().on_drag_end();
784 }
785 (true, target)
788 }
789 PointerInput::Entered
790 | PointerInput::Left
791 | PointerInput::Cancelled
792 | PointerInput::RawDelta { .. } => (false, None),
793 }
794 }
795
796 fn arm_text_drag(&mut self, target: Option<&WidgetId>, x: f64, y: f64) {
802 let field = match target {
803 Some(id)
804 if self.coord.widget_sense(id).is_some_and(|s| s.text)
805 && self.coord.text_fields().has_field(id) =>
806 {
807 Some(id.clone())
808 }
809 _ => None,
810 };
811 if let Some(id) = field {
812 if self.cook.click_count <= 1 {
813 self.coord.text_fields_mut().begin_drag_at_xy(id, x, y);
814 return;
815 }
816 }
817 if self.coord.text_fields().drag_active() {
818 self.coord.text_fields_mut().on_drag_end();
819 }
820 }
821
822 fn blur_text_on_outside_press(&mut self, target: Option<&WidgetId>) -> bool {
826 let on_field = target.is_some_and(|id| {
827 self.coord.text_fields().has_field(id)
828 && self.coord.widget_sense(id).is_some_and(|s| s.text)
829 });
830 if on_field || self.coord.text_fields().focused().is_none() {
831 return false;
832 }
833 self.coord.clear_focus();
834 if self.focus.as_ref().is_some_and(|f| f.field) {
835 self.focus = None;
836 }
837 true
838 }
839
840 fn release_select(
844 &mut self,
845 win: WindowId,
846 target: Option<&WidgetId>,
847 fx: &mut InputEffects,
848 ) -> bool {
849 if self.drag_ended {
850 return false;
851 }
852 let Some(p) = self.press_sel.clone() else {
853 return false;
854 };
855 if target != Some(&p.widget) {
856 return false;
857 }
858 let Some(st) = self.selectables.get(&p.widget) else {
859 return false;
860 };
861 let sel = TextSelection::for_click_count(&st.text, p.anchor, self.cook.click_count.max(1));
862 let changed = self.set_selection(win, &p.widget, sel, fx);
863 self.escalation = Some((p.widget, EscLevel::Widget));
864 changed
865 }
866
867 fn wheel(&mut self, input: WheelInput) -> Option<WidgetId> {
868 let (dx, dy) = match input.delta {
869 WheelDelta::Lines { x, y } => (x, y),
870 WheelDelta::Pixels { x, y } => {
871 self.pointer.scroll_precise = true;
872 (x / WHEEL_PIXELS_PER_LINE, y / WHEEL_PIXELS_PER_LINE)
873 }
874 };
875 self.pointer.pos = Some((input.pos.x, input.pos.y));
876 self.pointer.mods = input.mods;
877 self.pointer.scroll.0 += dx;
878 self.pointer.scroll.1 += dy;
879 if let Some(Capture::Widget(id)) = &self.capture {
880 return Some(id.clone());
881 }
882 self.coord.process_scroll(input.pos.x, input.pos.y)
883 }
884
885 fn sel_owner(&self, w: &WidgetId) -> WidgetId {
889 self.sel_alias.get(w).unwrap_or(w).clone()
890 }
891
892 fn sel_get(&self, widget: &WidgetId) -> Option<TextSelection> {
893 self.selections
894 .iter()
895 .find(|(w, _)| w == widget)
896 .map(|(_, s)| *s)
897 }
898
899 fn sel_set(&mut self, widget: WidgetId, sel: TextSelection) -> bool {
900 if let Some(slot) = self.selections.iter_mut().find(|(w, _)| *w == widget) {
901 if slot.1 == sel {
902 return false;
903 }
904 slot.1 = sel;
905 return true;
906 }
907 self.selections.push((widget, sel));
908 true
909 }
910
911 fn sel_remove(&mut self, widget: &WidgetId) -> bool {
912 let before = self.selections.len();
913 self.selections.retain(|(w, _)| w != widget);
914 self.selections.len() != before
915 }
916
917 fn set_selection(
919 &mut self,
920 win: WindowId,
921 widget: &WidgetId,
922 sel: TextSelection,
923 fx: &mut InputEffects,
924 ) -> bool {
925 if !self.sel_set(widget.clone(), sel) {
926 return false;
927 }
928 fx.push(InputEffect::InvalidateField {
929 win,
930 rect: self.coord.widget_rect(widget),
931 });
932 true
933 }
934
935 fn clear_selections(&mut self, win: WindowId, fx: &mut InputEffects) -> bool {
937 if self.selections.is_empty() {
938 return false;
939 }
940 for (w, _) in &self.selections {
941 fx.push(InputEffect::InvalidateField {
942 win,
943 rect: self.coord.widget_rect(w),
944 });
945 }
946 self.selections.clear();
947 self.escalation = None;
948 true
949 }
950
951 fn selectable_ids_by_row(&self) -> Vec<WidgetId> {
954 let mut ids: Vec<(f64, f64, WidgetId)> = self
955 .selectables
956 .keys()
957 .map(|w| {
958 let r = self
959 .coord
960 .widget_rect(w)
961 .unwrap_or_else(|| Rect::new(0.0, 0.0, 0.0, 0.0));
962 (r.y, r.x, w.clone())
963 })
964 .collect();
965 uzor::sort::sort_by(&mut ids, |a, b| a.0.total_cmp(&b.0).then_with(|| a.1.total_cmp(&b.1)));
966 ids.into_iter().map(|(_, _, w)| w).collect()
967 }
968
969 fn selected_text_concat(&self) -> Option<String> {
972 if self.selections.is_empty() {
973 return None;
974 }
975 let mut parts: Vec<String> = Vec::new();
976 for w in self.selectable_ids_by_row() {
977 if let (Some(sel), Some(st)) = (self.sel_get(&w), self.selectables.get(&w)) {
978 let s = sel.selected_text(&st.text);
979 if !s.is_empty() {
980 parts.push(s.to_owned());
981 }
982 }
983 }
984 if parts.is_empty() {
985 None
986 } else {
987 Some(parts.join("\n"))
988 }
989 }
990
991 fn nearest_panel_rect(&self, widget: &WidgetId) -> Option<Rect> {
994 let mut cur = self.coord.widget_parent(widget);
995 while let Some(p) = cur {
996 if matches!(
997 self.coord.widget_kind(&p),
998 Some(WidgetKind::Panel | WidgetKind::BlackboxPanel)
999 ) {
1000 return self.coord.widget_rect(&p);
1001 }
1002 cur = self.coord.widget_parent(&p);
1003 }
1004 None
1005 }
1006
1007 fn select_in_rect(&mut self, win: WindowId, rect: &Rect, fx: &mut InputEffects) -> bool {
1009 let mut changed = false;
1010 for w in self.selectable_ids_by_row() {
1011 if let Some(r) = self.coord.widget_rect(&w) {
1012 let inside = r.x >= rect.x
1013 && r.y >= rect.y
1014 && r.x + r.width <= rect.x + rect.width
1015 && r.y + r.height <= rect.y + rect.height;
1016 if inside {
1017 if let Some(st) = self.selectables.get(&w) {
1018 let sel = TextSelection::all(&st.text);
1019 changed |= self.set_selection(win, &w, sel, fx);
1020 }
1021 }
1022 }
1023 }
1024 changed
1025 }
1026
1027 fn select_everything(&mut self, win: WindowId, fx: &mut InputEffects) -> bool {
1029 let mut changed = false;
1030 for w in self.selectable_ids_by_row() {
1031 if let Some(st) = self.selectables.get(&w) {
1032 let sel = TextSelection::all(&st.text);
1033 changed |= self.set_selection(win, &w, sel, fx);
1034 }
1035 }
1036 changed
1037 }
1038
1039 fn press_down(
1042 &mut self,
1043 win: WindowId,
1044 target: Option<&WidgetId>,
1045 x: f64,
1046 y: f64,
1047 fx: &mut InputEffects,
1048 ) -> bool {
1049 let mut changed = false;
1050 if !target.is_some_and(|t| self.sel_get(t).is_some()) {
1051 changed |= self.clear_selections(win, fx);
1052 }
1053 self.press_sel = None;
1054 if let Some(t) = target {
1055 if let Some(st) = self.selectables.get(t) {
1056 let anchor = char_at_point(&st.lines, x, y);
1057 self.press_sel = Some(PressSel {
1058 widget: t.clone(),
1059 anchor,
1060 });
1061 }
1062 }
1063 changed
1064 }
1065
1066 fn selection_frame(&mut self, win: WindowId, fx: &mut InputEffects) -> bool {
1069 let mut changed = false;
1070
1071 if let Some(p) = self.press_sel.clone() {
1075 if self.cook.drag_armed || self.drag_ended {
1076 if let (Some(st), Some((x, y))) =
1077 (self.selectables.get(&p.widget), self.pointer.pos)
1078 {
1079 let sel = TextSelection::new(p.anchor, char_at_point(&st.lines, x, y));
1080 changed |= self.set_selection(win, &p.widget, sel, fx);
1081 }
1082 }
1083 }
1084
1085 if self.pointer.button_down.is_none() {
1091 self.press_sel = None;
1092 self.drag_ended = false;
1093 }
1094
1095 let fresh = std::mem::take(&mut self.reported);
1098 let gone: Vec<WidgetId> = self
1099 .selections
1100 .iter()
1101 .map(|(w, _)| w.clone())
1102 .filter(|w| !fresh.contains_key(w))
1103 .collect();
1104 if !gone.is_empty() {
1105 for w in &gone {
1106 fx.push(InputEffect::InvalidateField {
1107 win,
1108 rect: self.coord.widget_rect(w),
1109 });
1110 self.sel_remove(w);
1111 }
1112 if let Some((w, _)) = &self.escalation {
1113 if gone.contains(w) {
1114 self.escalation = None;
1115 }
1116 }
1117 changed = true;
1118 }
1119 self.selectables = fresh.0;
1120 self.sel_alias = fresh.1;
1121
1122 changed
1123 }
1124
1125 fn ctrl_a(&mut self, win: WindowId, fx: &mut InputEffects) -> Option<bool> {
1129 if let Some((w, level)) = self.escalation.clone() {
1130 let next = match level {
1131 EscLevel::Widget => match self.nearest_panel_rect(&w) {
1132 Some(rect) => {
1133 self.select_in_rect(win, &rect, fx);
1134 EscLevel::Panel
1135 }
1136 None => {
1137 self.select_everything(win, fx);
1138 EscLevel::Window
1139 }
1140 },
1141 EscLevel::Panel => {
1142 self.select_everything(win, fx);
1143 EscLevel::Window
1144 }
1145 EscLevel::Window => return Some(false),
1146 };
1147 self.escalation = Some((w, next));
1148 return Some(true);
1149 }
1150 let start = self
1152 .hover
1153 .clone()
1154 .filter(|h| self.selectables.contains_key(h))
1155 .or_else(|| (self.selections.len() == 1).then(|| self.selections[0].0.clone()));
1156 let w = start?;
1157 let st = self.selectables.get(&w)?;
1158 let sel = TextSelection::all(&st.text);
1159 let changed = self.set_selection(win, &w, sel, fx);
1160 self.escalation = Some((w, EscLevel::Widget));
1161 Some(changed)
1162 }
1163
1164 fn begin_frame(&mut self, now: Seconds) -> bool {
1167 let mut state = InputState::new();
1168 state.pointer.pos = self.pointer.pos;
1169 state.pointer.prev_pos = self.pointer.prev_pos;
1170 state.pointer.button_down = self.pointer.button_down;
1171 state.pointer.clicked = self.pointer.clicked.take();
1172 state.modifiers = self.pointer.mods;
1173 state.scroll_delta = std::mem::take(&mut self.pointer.scroll);
1174 self.pointer.scroll_precise = false;
1175 self.pointer.context = None;
1176 state.time = now.get();
1177 self.pointer.prev_pos = self.pointer.pos;
1178 self.coord.begin_frame(state);
1179 let had_clicks = !self.clicked.is_empty();
1180 self.clicked.clear();
1181 had_clicks
1182 }
1183
1184 fn end_frame(&mut self, win: WindowId, fx: &mut InputEffects) -> bool {
1185 let mut hover = None;
1186 let mut clicked = SmallVec::new();
1187 for (id, r) in self.coord.end_frame() {
1188 if r.hovered {
1189 hover = Some(id.clone());
1190 }
1191 if r.clicked {
1192 let count = if r.triple_clicked {
1193 3
1194 } else if r.double_clicked {
1195 2
1196 } else {
1197 1
1198 };
1199 clicked.push((id, count));
1200 }
1201 }
1202 for w in self.key_clicks.drain(..) {
1203 if !clicked.iter().any(|(c, _)| *c == w) {
1204 clicked.push((w, 1));
1205 }
1206 }
1207 let mut changed = hover != self.hover || clicked != self.clicked;
1208 self.hover = hover;
1209 self.clicked = clicked.clone();
1210 let clicked_focus = clicked
1213 .iter()
1214 .map(|(id, _)| id.clone())
1215 .find(|id| self.allowed(id) && self.coord.widget_sense(id).is_some_and(|s| s.focus));
1216 if let Some(id) = clicked_focus {
1217 if self.focused_id() != Some(&id) {
1218 self.focus_raw(id);
1219 changed = true;
1220 }
1221 }
1222 changed |= self.selection_frame(win, fx);
1223 changed |= self.reconcile_focus();
1224 changed
1225 }
1226
1227 fn text_focus(&self) -> Option<WidgetId> {
1231 let f = self.focus.as_ref().filter(|f| f.field)?;
1232 self.coord
1233 .text_fields()
1234 .is_focused(&f.id)
1235 .then(|| f.id.clone())
1236 }
1237
1238 fn key(
1239 &mut self,
1240 win: WindowId,
1241 input: KeyInput,
1242 next_ticket: &mut u64,
1243 fx: &mut InputEffects,
1244 ) -> bool {
1245 let m = input.mods;
1246 if input.code == KeyCode::Space && input.state == KeyState::Up {
1247 if let Some(w) = self.space_armed.take() {
1248 if self.focused_id() == Some(&w) {
1249 self.key_clicks.push(w);
1250 return true;
1251 }
1252 }
1253 }
1254 if input.state == KeyState::Up {
1255 fx.push(InputEffect::KeyPassed { win, key: input });
1256 return false;
1257 }
1258 if input.code != KeyCode::Unknown {
1259 self.focus_visible = true;
1260 }
1261 if matches!(input.code, KeyCode::Enter | KeyCode::Space) && !(m.ctrl || m.alt || m.meta) {
1263 if let Some(f) = self.focus.as_ref().filter(|f| !f.field).map(|f| f.id.clone()) {
1264 if self.coord.widget_sense(&f).is_some_and(|s| s.click) {
1265 let (enter, space) = activation(self.coord.widget_kind(&f));
1266 if input.code == KeyCode::Enter && enter {
1267 self.key_clicks.push(f);
1268 return true;
1269 }
1270 if input.code == KeyCode::Space && space {
1271 self.space_armed = Some(f);
1272 return false;
1273 }
1274 }
1275 }
1276 }
1277 if input.code == KeyCode::Tab && !(m.ctrl || m.alt || m.meta) {
1278 return match self.cycle(!m.shift) {
1279 Some(changed) => changed,
1280 None => {
1281 fx.push(InputEffect::KeyPassed { win, key: input });
1282 false
1283 }
1284 };
1285 }
1286 let field = self.text_focus();
1287 let mut edit = editing_chord(&input);
1288 if edit.is_none() && matches!(input.code, KeyCode::ArrowUp | KeyCode::ArrowDown) && !(m.ctrl || m.alt || m.meta) {
1290 if field.as_ref().is_some_and(|f| self.coord.text_fields().has_lines(f)) {
1291 edit = Some(Edit::Key(if input.code == KeyCode::ArrowUp { KeyPress::ArrowUp } else { KeyPress::ArrowDown }));
1292 }
1293 }
1294 let (field, edit) = match (field, edit) {
1295 (Some(f), Some(e)) => (f, e),
1296 (None, Some(Edit::Copy)) => {
1299 if let Some(text) = self.selected_text_concat() {
1300 fx.push(InputEffect::CopyText { win, text });
1301 } else {
1302 if let Some(text) = self.offer.clone() {
1305 fx.push(InputEffect::CopyText { win, text });
1306 }
1307 fx.push(InputEffect::KeyPassed { win, key: input });
1308 }
1309 return false;
1310 }
1311 (None, Some(Edit::Cut)) => {
1312 if let Some(text) = self.offer.clone() {
1313 fx.push(InputEffect::CopyText { win, text });
1314 }
1315 fx.push(InputEffect::KeyPassed { win, key: input });
1316 return false;
1317 }
1318 (None, Some(Edit::Paste)) => {
1319 let ticket = Ticket(INPUT_TICKET_BASE.saturating_add(*next_ticket));
1323 *next_ticket = next_ticket.saturating_add(1);
1324 self.pending_paste = Some((ticket, None));
1325 fx.push(InputEffect::NeedPaste { win, ticket });
1326 return false;
1327 }
1328 (None, Some(Edit::Key(KeyPress::SelectAll)))
1329 if self.focus.as_ref().is_some_and(|f| !f.field && self.coord.widget_kind(&f.id).is_some_and(|k| k.is_blackbox())) =>
1330 {
1331 fx.push(InputEffect::KeyPassed { win, key: input });
1333 return false;
1334 }
1335 (None, Some(Edit::Key(KeyPress::SelectAll))) => {
1336 return match self.ctrl_a(win, fx) {
1338 Some(changed) => changed,
1339 None => {
1340 fx.push(InputEffect::KeyPassed { win, key: input });
1341 false
1342 }
1343 };
1344 }
1345 _ => {
1346 fx.push(InputEffect::KeyPassed { win, key: input });
1347 return false;
1348 }
1349 };
1350 let text_before = self.coord.text_fields().text(&field).to_owned();
1351 let changed_text = |action: &TextAction| matches!(action, TextAction::TextChanged(_));
1352 let mut changed = false;
1353 let multiline = self.coord.text_fields().field_state(&field).is_some_and(|s| s.config.multiline);
1354 let edit = match edit {
1355 Edit::Newline if multiline => Edit::Key(KeyPress::Paste("\n".into())),
1356 Edit::Newline => Edit::Submit,
1357 e => e,
1358 };
1359 match edit {
1360 Edit::Newline => {}
1361 Edit::Key(kp) => changed = changed_text(&self.coord.on_key(kp)),
1362 Edit::Char(c) => changed = changed_text(&self.coord.on_char(c)),
1363 Edit::Text(s) => {
1364 for c in s.chars() {
1365 changed |= changed_text(&self.coord.on_char(c));
1366 }
1367 }
1368 Edit::Submit => {
1369 if let TextAction::Commit(_) = self.coord.on_char('\r') {
1370 fx.push(InputEffect::Text(TextIntent::Submitted {
1371 win,
1372 field: field.clone(),
1373 }));
1374 }
1375 }
1376 Edit::Copy => {
1377 let own = if self.masked(&field) { None } else { self.coord.text_fields().copy_selection().filter(|t| !t.is_empty()) };
1380 if let Some(text) = own.or_else(|| self.selected_text_concat()) {
1381 fx.push(InputEffect::CopyText { win, text });
1382 }
1383 }
1384 Edit::Cut => {
1385 if !self.masked(&field) {
1386 if let Some(text) = self.coord.text_fields_mut().cut_selection(&field) {
1387 fx.push(InputEffect::CopyText { win, text });
1388 }
1389 }
1390 }
1391 Edit::Paste => {
1392 let ticket = Ticket(INPUT_TICKET_BASE.saturating_add(*next_ticket));
1393 *next_ticket = next_ticket.saturating_add(1);
1394 self.pending_paste = Some((ticket, Some(field.clone())));
1395 fx.push(InputEffect::NeedPaste { win, ticket });
1396 }
1397 }
1398 if changed || self.coord.text_fields().text(&field) != text_before {
1399 fx.push(InputEffect::Text(TextIntent::Changed { win, field }));
1400 }
1401 false
1403 }
1404
1405 fn masked(&self, field: &WidgetId) -> bool {
1406 self.coord
1407 .text_fields()
1408 .field_state(field)
1409 .is_some_and(|s| s.config.masked)
1410 }
1411
1412 fn ime(&mut self, win: WindowId, input: ImeInput, fx: &mut InputEffects) {
1413 let Some(field) = self.text_focus() else {
1414 return;
1415 };
1416 match input {
1417 ImeInput::Enabled => {}
1418 ImeInput::Preedit { text, cursor } => {
1419 let chars = |b: usize| text.get(..b).map(|s| s.chars().count());
1420 let at = cursor
1421 .and_then(|(b, _)| chars(b))
1422 .unwrap_or_else(|| text.chars().count());
1423 self.coord.text_fields_mut().preedit_set(&field, text, at);
1424 }
1425 ImeInput::Commit(text) => {
1426 let action = self.coord.text_fields_mut().ime_commit(&field, text);
1427 if let TextAction::TextChanged(_) = action {
1428 fx.push(InputEffect::Text(TextIntent::Changed { win, field }));
1429 }
1430 }
1431 ImeInput::Disabled => {
1432 self.coord
1433 .text_fields_mut()
1434 .preedit_set(&field, String::new(), 0);
1435 }
1436 }
1437 }
1438
1439 fn clipboard(&mut self, win: WindowId, result: ClipboardResult, fx: &mut InputEffects) {
1440 let Some((ticket, field)) = self.pending_paste.clone() else {
1441 return;
1442 };
1443 if ticket != result.ticket {
1444 return;
1445 }
1446 self.pending_paste = None;
1447 let Some(text) = result.text.filter(|t| !t.is_empty()) else {
1448 return;
1449 };
1450 let Some(field) = field else {
1451 fx.push(InputEffect::Pasted { win, text });
1452 return;
1453 };
1454 let Some(focused) = self.text_focus() else {
1455 return;
1456 };
1457 if focused != field {
1458 return;
1459 }
1460 if let TextAction::TextChanged(_) = self.coord.on_key(KeyPress::Paste(text)) {
1461 fx.push(InputEffect::Text(TextIntent::Changed { win, field }));
1462 }
1463 }
1464
1465 fn paste(&mut self, win: WindowId, text: String, fx: &mut InputEffects) {
1469 self.pending_paste = None;
1470 if text.is_empty() {
1471 return;
1472 }
1473 match self.text_focus() {
1474 Some(field) => {
1475 if let TextAction::TextChanged(_) = self.coord.on_key(KeyPress::Paste(text)) {
1476 fx.push(InputEffect::Text(TextIntent::Changed { win, field }));
1477 }
1478 }
1479 None => fx.push(InputEffect::Pasted { win, text }),
1480 }
1481 }
1482
1483 fn caret_key(&self) -> Option<CaretKey> {
1486 let store = self.coord.text_fields();
1487 let field = store.focused()?;
1488 let s = store.field_state(field)?;
1489 Some(CaretKey {
1490 field: field.clone(),
1491 engaged: s.engaged,
1492 text: s.text.clone(),
1493 cursor: s.cursor,
1494 selection: s.selection_start,
1495 preedit: s.preedit.clone(),
1496 preedit_cursor: s.preedit_cursor,
1497 })
1498 }
1499
1500 fn field_rect(&self, field: &WidgetId) -> Option<Rect> {
1501 let (x, y, w, h) = self.coord.text_fields().field_state(field)?.last_rect?;
1502 Some(Rect::new(x, y, w, h))
1503 }
1504
1505 fn caret_rect(&self, field: &WidgetId) -> Option<Rect> {
1507 let s = self.coord.text_fields().field_state(field)?;
1508 let (x, y, _, h) = s.last_rect?;
1509 let cx = s.last_char_positions.get(s.cursor).copied().unwrap_or(x);
1510 Some(Rect::new(cx, y, 1.0, h))
1511 }
1512
1513 fn settle(&mut self, win: WindowId, now: Seconds, fx: &mut InputEffects) -> bool {
1516 let now_ms = millis(now);
1517 let key = self.caret_key();
1518 let key_changed = key != self.caret;
1519 if key_changed {
1520 if let Some(old) = &self.caret {
1521 if key.as_ref().map(|k| &k.field) != Some(&old.field) {
1522 fx.push(InputEffect::InvalidateField {
1523 win,
1524 rect: self.field_rect(&old.field),
1525 });
1526 }
1527 }
1528 self.caret = key;
1529 self.blink_anchor_ms = now_ms;
1530 }
1531 self.coord
1532 .text_fields_mut()
1533 .set_blink_time(self.blink_anchor_ms);
1534 let active = self.os_focused && self.caret.as_ref().is_some_and(|k| k.engaged);
1535 let visible = active && self.coord.text_fields().cursor_visible(now_ms);
1536 let visible_changed = visible != self.caret_visible;
1537 self.caret_visible = visible;
1538 if key_changed || visible_changed {
1539 if let Some(k) = &self.caret {
1540 fx.push(InputEffect::InvalidateField {
1541 win,
1542 rect: self.field_rect(&k.field),
1543 });
1544 }
1545 }
1546 let at = active.then(|| next_blink_edge(self.blink_anchor_ms, now_ms));
1547 if at != self.armed {
1548 self.armed = at;
1549 fx.push(InputEffect::CaretDeadline { win, at });
1550 }
1551 let field = self.caret.as_ref().map(|k| k.field.clone());
1552 let allowed = field.is_some();
1553 if allowed != self.ime_allowed {
1554 self.ime_allowed = allowed;
1555 fx.push(InputEffect::ImeAllowed { win, allowed });
1556 }
1557 let area = field.and_then(|f| self.caret_rect(&f));
1558 if area != self.ime_area {
1559 self.ime_area = area;
1560 if let Some(rect) = area {
1561 fx.push(InputEffect::ImeArea { win, rect });
1562 }
1563 }
1564 key_changed || visible_changed
1565 }
1566}
1567
1568fn millis(t: Seconds) -> u64 {
1571 (t.get() * 1000.0).round().max(0.0) as u64
1573}
1574
1575fn next_blink_edge(anchor_ms: u64, now_ms: u64) -> Seconds {
1578 let phases = now_ms.saturating_sub(anchor_ms) / CARET_BLINK_MS + 1;
1579 let edge = anchor_ms.saturating_add(phases.saturating_mul(CARET_BLINK_MS));
1580 Seconds(edge as f64 / 1000.0)
1581}
1582
1583#[derive(Clone, Debug, PartialEq, Eq)]
1585enum Edit {
1586 Key(KeyPress),
1587 Char(char),
1588 Text(String),
1589 Submit,
1590 Newline,
1592 Copy,
1593 Cut,
1594 Paste,
1595}
1596
1597fn editing_chord(input: &KeyInput) -> Option<Edit> {
1600 let m = input.mods;
1601 let cmd = m.ctrl || m.meta;
1602 let edit = match input.code {
1603 KeyCode::A if cmd => Edit::Key(KeyPress::SelectAll),
1604 KeyCode::Z if cmd && m.shift => Edit::Key(KeyPress::Redo),
1605 KeyCode::Z if cmd => Edit::Key(KeyPress::Undo),
1606 KeyCode::Y if m.ctrl && !m.alt => Edit::Key(KeyPress::Redo),
1607 KeyCode::C if cmd => Edit::Copy,
1608 KeyCode::X if cmd => Edit::Cut,
1609 KeyCode::V if cmd => Edit::Paste,
1610 KeyCode::ArrowLeft if cmd => Edit::Key(KeyPress::WordLeft),
1611 KeyCode::ArrowRight if cmd => Edit::Key(KeyPress::WordRight),
1612 KeyCode::Backspace if cmd => Edit::Key(KeyPress::DeleteWordBack),
1613 KeyCode::Delete if cmd => Edit::Key(KeyPress::DeleteWordForward),
1614 KeyCode::ArrowLeft if m.shift => Edit::Key(KeyPress::ShiftLeft),
1615 KeyCode::ArrowRight if m.shift => Edit::Key(KeyPress::ShiftRight),
1616 KeyCode::Home if m.shift => Edit::Key(KeyPress::ShiftHome),
1617 KeyCode::End if m.shift => Edit::Key(KeyPress::ShiftEnd),
1618 KeyCode::ArrowLeft => Edit::Key(KeyPress::ArrowLeft),
1619 KeyCode::ArrowRight => Edit::Key(KeyPress::ArrowRight),
1620 KeyCode::Home => Edit::Key(KeyPress::Home),
1621 KeyCode::End => Edit::Key(KeyPress::End),
1622 KeyCode::Backspace => Edit::Char('\x08'),
1623 KeyCode::Delete => Edit::Key(KeyPress::Delete),
1624 KeyCode::Enter if m.shift => Edit::Newline,
1625 KeyCode::Enter => Edit::Submit,
1626 _ if cmd && !(m.ctrl && m.alt) => return None,
1629 _ => {
1630 let text: String = input
1631 .text
1632 .as_deref()?
1633 .chars()
1634 .filter(|c| !c.is_control())
1635 .collect();
1636 if text.is_empty() {
1637 return None;
1638 }
1639 match text.chars().count() {
1640 1 => Edit::Char(text.chars().next()?),
1641 _ => Edit::Text(text),
1642 }
1643 }
1644 };
1645 Some(edit)
1646}
1647
1648#[derive(Default)]
1654pub struct InputEngine {
1655 windows: VecMap<WindowId, PerWindowInput>,
1656 next_scope: u64,
1657 next_ticket: u64,
1658 rev: Revision,
1659}
1660
1661impl fmt::Debug for InputEngine {
1662 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1663 f.debug_struct("InputEngine")
1664 .field("windows", &self.windows.keys().collect::<Vec<_>>())
1665 .field("rev", &self.rev)
1666 .finish()
1667 }
1668}
1669
1670impl InputEngine {
1671 pub fn new() -> Self {
1673 Self::default()
1674 }
1675
1676 pub fn apply(&mut self, op: InputOp) -> InputEffects {
1679 let mut fx = InputEffects::new();
1680 let Self {
1681 windows,
1682 next_scope,
1683 next_ticket,
1684 rev,
1685 } = self;
1686 let changed = match op {
1687 InputOp::Open(win) => match windows.entry(win) {
1688 crate::types::vecmap::Entry::Occupied(_) => false,
1689 crate::types::vecmap::Entry::Vacant(slot) => {
1690 slot.insert(PerWindowInput::new());
1691 true
1692 }
1693 },
1694 InputOp::Close(win) => windows.remove(&win).is_some(),
1695 InputOp::WindowFocus { win, focused, now } => match windows.get_mut(&win) {
1696 Some(w) => {
1697 w.os_focused = focused;
1698 w.settle(win, now, &mut fx)
1699 }
1700 None => false,
1701 },
1702 InputOp::Pointer { win, now, input } => match windows.get_mut(&win) {
1703 Some(w) => {
1704 let (changed, cooked) = w.cook(win, now, input);
1705 fx.push(InputEffect::Pointer(cooked));
1706 changed
1707 }
1708 None => false,
1709 },
1710 InputOp::Deliver { win, input } => match windows.get_mut(&win) {
1711 Some(w) => {
1712 let (changed, target) = w.deliver(win, input, &mut fx);
1713 fx.push(InputEffect::Content { win, target, changed });
1714 changed
1715 }
1716 None => false,
1717 },
1718 InputOp::Wheel { win, input } => {
1719 if let Some(w) = windows.get_mut(&win) {
1720 let target = w.wheel(input);
1721 let changed = target.is_some();
1722 fx.push(InputEffect::Content { win, target, changed });
1723 }
1724 false
1725 }
1726 InputOp::Key { win, now, input } => match windows.get_mut(&win) {
1727 Some(w) => {
1728 let changed = w.key(win, input, next_ticket, &mut fx);
1729 w.settle(win, now, &mut fx) | changed
1730 }
1731 None => false,
1732 },
1733 InputOp::Ime { win, now, input } => match windows.get_mut(&win) {
1734 Some(w) => {
1735 w.ime(win, input, &mut fx);
1736 w.settle(win, now, &mut fx)
1737 }
1738 None => false,
1739 },
1740 InputOp::Paste { win, now, text } => match windows.get_mut(&win) {
1741 Some(w) => {
1742 w.paste(win, text, &mut fx);
1743 w.settle(win, now, &mut fx)
1744 }
1745 None => false,
1746 },
1747 InputOp::Offer { win, text } => {
1748 if let Some(w) = windows.get_mut(&win) {
1749 w.offer = text;
1750 }
1751 false
1752 }
1753 InputOp::Clipboard { win, now, result } => match windows.get_mut(&win) {
1754 Some(w) => {
1755 w.clipboard(win, result, &mut fx);
1756 w.settle(win, now, &mut fx)
1757 }
1758 None => false,
1759 },
1760 InputOp::Focus { win, now, op } => match windows.get_mut(&win) {
1761 Some(w) => {
1762 let changed = w.focus_op(win, op, next_scope, &mut fx);
1763 w.settle(win, now, &mut fx) | changed
1764 }
1765 None => false,
1766 },
1767 InputOp::SetCapture { win, capture } => windows
1768 .get_mut(&win)
1769 .is_some_and(|w| w.set_capture(capture)),
1770 InputOp::BeginFrame { win, now } => {
1771 windows.get_mut(&win).is_some_and(|w| w.begin_frame(now))
1772 }
1773 InputOp::EndFrame { win, now } => match windows.get_mut(&win) {
1774 Some(w) => {
1775 let changed = w.end_frame(win, &mut fx);
1776 w.settle(win, now, &mut fx) | changed
1777 }
1778 None => false,
1779 },
1780 };
1781 if changed {
1782 rev.bump();
1783 }
1784 fx
1785 }
1786
1787 pub fn tick(&mut self, now: Seconds) -> InputEffects {
1792 let mut fx = InputEffects::new();
1793 let mut changed = false;
1794 for (win, w) in &mut self.windows {
1795 if w.armed.is_some_and(|at| at.get() <= now.get()) {
1796 changed |= w.settle(*win, now, &mut fx);
1797 }
1798 }
1799 if changed {
1800 self.rev.bump();
1801 }
1802 fx
1803 }
1804
1805 #[allow(dead_code)]
1812 pub fn registrar(&mut self, win: WindowId) -> Option<&mut InputCoordinator> {
1813 self.windows.get_mut(&win).map(|w| &mut w.coord)
1814 }
1815
1816 #[allow(dead_code)]
1821 pub fn states_mut(&mut self, win: WindowId) -> Option<&mut uzor::app_context::StateRegistry> {
1822 self.windows.get_mut(&win).map(|w| &mut w.states)
1823 }
1824
1825 pub fn compose_parts(
1829 &mut self,
1830 win: WindowId,
1831 ) -> Option<(&mut InputCoordinator, &mut uzor::app_context::StateRegistry, &mut Selectables)> {
1832 self.windows
1833 .get_mut(&win)
1834 .map(|w| (&mut w.coord, &mut w.states, &mut w.reported))
1835 }
1836
1837 #[allow(dead_code)]
1845 pub fn update_selectable(
1846 &mut self,
1847 win: WindowId,
1848 widget: WidgetId,
1849 text: impl Into<String>,
1850 lines: Vec<SelectionLine>,
1851 ) {
1852 if let Some(w) = self.windows.get_mut(&win) {
1853 w.reported.report(widget, text, lines);
1854 }
1855 }
1856
1857 #[allow(dead_code)]
1860 pub fn alias_selectable(&mut self, win: WindowId, member: WidgetId, owner: WidgetId) {
1861 if let Some(w) = self.windows.get_mut(&win) {
1862 w.reported.alias(member, owner);
1863 }
1864 }
1865
1866 pub fn revision(&self) -> Revision {
1868 self.rev
1869 }
1870
1871 pub fn view(&self) -> InputEngineView<'_> {
1873 InputEngineView { e: self }
1874 }
1875}
1876
1877#[derive(Clone, Copy, Debug)]
1879pub struct InputEngineView<'a> {
1880 e: &'a InputEngine,
1881}
1882
1883#[allow(dead_code)]
1885impl<'a> InputEngineView<'a> {
1886 fn w(&self, win: WindowId) -> Option<&'a PerWindowInput> {
1887 self.e.windows.get(&win)
1888 }
1889
1890 pub fn ids(&self) -> impl Iterator<Item = WindowId> + 'a {
1892 self.e.windows.keys().copied()
1893 }
1894
1895 pub fn window(&self, win: WindowId) -> Option<InputView> {
1897 self.w(win).map(|w| InputView {
1898 hovered: w.hover.clone(),
1899 pressed: w.pressed.clone(),
1900 focused: w.focused_id().cloned(),
1901 focus_visible: w.focus_visible,
1902 captured: w.capture.is_some(),
1903 scope_depth: w.scopes.len(),
1904 })
1905 }
1906
1907 pub fn focused(&self, win: WindowId) -> Option<&'a WidgetId> {
1909 self.w(win)?.focused_id()
1910 }
1911
1912 pub fn active_scope(&self, win: WindowId) -> Option<&'a ScopeOwner> {
1914 self.w(win)?.scopes.last().map(|s| &s.owner)
1915 }
1916
1917 pub fn capture(&self, win: WindowId) -> Option<&'a Capture> {
1919 self.w(win)?.capture.as_ref()
1920 }
1921
1922 pub fn cook(&self, win: WindowId) -> Option<&'a CookState> {
1924 self.w(win).map(|w| &w.cook)
1925 }
1926
1927 pub fn clicked(&self, win: WindowId) -> &'a [(WidgetId, u8)] {
1930 self.w(win).map_or(&[], |w| w.clicked.as_slice())
1931 }
1932
1933 pub fn caret_visible(&self, win: WindowId) -> bool {
1936 self.w(win).is_some_and(|w| w.caret_visible)
1937 }
1938
1939 pub fn caret_deadline(&self, win: WindowId) -> Option<Seconds> {
1941 self.w(win)?.armed
1942 }
1943
1944 pub fn text_fields(&self, win: WindowId) -> Option<&'a TextFieldStore> {
1946 self.w(win).map(|w| w.coord.text_fields())
1947 }
1948
1949 pub fn selections(&self, win: WindowId) -> Option<&'a [(WidgetId, TextSelection)]> {
1953 self.w(win).map(|w| w.selections.as_slice())
1954 }
1955
1956 pub fn coordinator(&self, win: WindowId) -> Option<&'a InputCoordinator> {
1958 self.w(win).map(|w| &w.coord)
1959 }
1960
1961 pub fn pending_scroll(&self, win: WindowId) -> (f64, f64) {
1965 self.w(win).map_or((0.0, 0.0), |w| w.pointer.scroll)
1966 }
1967
1968 pub fn pending_scroll_precise(&self, win: WindowId) -> bool {
1971 self.w(win).is_some_and(|w| w.pointer.scroll_precise)
1972 }
1973
1974 pub fn context_click(&self, win: WindowId) -> Option<(f64, f64)> {
1978 self.w(win).and_then(|w| w.pointer.context)
1979 }
1980
1981 pub fn pointer(&self, win: WindowId) -> (Option<(f64, f64)>, bool) {
1982 self.w(win).map_or((None, false), |w| (w.pointer.pos, w.pointer.button_down.is_some()))
1983 }
1984
1985 pub fn press_origin(&self, win: WindowId) -> Option<(f64, f64)> {
1989 let w = self.w(win)?;
1990 w.pointer.button_down?;
1991 w.cook.press_origin.map(|o| (o.x, o.y))
1992 }
1993}
1994
1995#[cfg(test)]
1996mod tests;