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(pos.x);
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);
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) {
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(id, x);
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 edit = editing_chord(&input);
1288 let (field, edit) = match (field, edit) {
1289 (Some(f), Some(e)) => (f, e),
1290 (None, Some(Edit::Copy)) => {
1293 if let Some(text) = self.selected_text_concat() {
1294 fx.push(InputEffect::CopyText { win, text });
1295 } else {
1296 if let Some(text) = self.offer.clone() {
1299 fx.push(InputEffect::CopyText { win, text });
1300 }
1301 fx.push(InputEffect::KeyPassed { win, key: input });
1302 }
1303 return false;
1304 }
1305 (None, Some(Edit::Cut)) => {
1306 if let Some(text) = self.offer.clone() {
1307 fx.push(InputEffect::CopyText { win, text });
1308 }
1309 fx.push(InputEffect::KeyPassed { win, key: input });
1310 return false;
1311 }
1312 (None, Some(Edit::Paste)) => {
1313 let ticket = Ticket(INPUT_TICKET_BASE.saturating_add(*next_ticket));
1317 *next_ticket = next_ticket.saturating_add(1);
1318 self.pending_paste = Some((ticket, None));
1319 fx.push(InputEffect::NeedPaste { win, ticket });
1320 return false;
1321 }
1322 (None, Some(Edit::Key(KeyPress::SelectAll)))
1323 if self.focus.as_ref().is_some_and(|f| !f.field && self.coord.widget_kind(&f.id).is_some_and(|k| k.is_blackbox())) =>
1324 {
1325 fx.push(InputEffect::KeyPassed { win, key: input });
1327 return false;
1328 }
1329 (None, Some(Edit::Key(KeyPress::SelectAll))) => {
1330 return match self.ctrl_a(win, fx) {
1332 Some(changed) => changed,
1333 None => {
1334 fx.push(InputEffect::KeyPassed { win, key: input });
1335 false
1336 }
1337 };
1338 }
1339 _ => {
1340 fx.push(InputEffect::KeyPassed { win, key: input });
1341 return false;
1342 }
1343 };
1344 let text_before = self.coord.text_fields().text(&field).to_owned();
1345 let changed_text = |action: &TextAction| matches!(action, TextAction::TextChanged(_));
1346 let mut changed = false;
1347 let multiline = self.coord.text_fields().field_state(&field).is_some_and(|s| s.config.multiline);
1348 let edit = match edit {
1349 Edit::Newline if multiline => Edit::Key(KeyPress::Paste("\n".into())),
1350 Edit::Newline => Edit::Submit,
1351 e => e,
1352 };
1353 match edit {
1354 Edit::Newline => {}
1355 Edit::Key(kp) => changed = changed_text(&self.coord.on_key(kp)),
1356 Edit::Char(c) => changed = changed_text(&self.coord.on_char(c)),
1357 Edit::Text(s) => {
1358 for c in s.chars() {
1359 changed |= changed_text(&self.coord.on_char(c));
1360 }
1361 }
1362 Edit::Submit => {
1363 if let TextAction::Commit(_) = self.coord.on_char('\r') {
1364 fx.push(InputEffect::Text(TextIntent::Submitted {
1365 win,
1366 field: field.clone(),
1367 }));
1368 }
1369 }
1370 Edit::Copy => {
1371 let own = if self.masked(&field) { None } else { self.coord.text_fields().copy_selection().filter(|t| !t.is_empty()) };
1374 if let Some(text) = own.or_else(|| self.selected_text_concat()) {
1375 fx.push(InputEffect::CopyText { win, text });
1376 }
1377 }
1378 Edit::Cut => {
1379 if !self.masked(&field) {
1380 if let Some(text) = self.coord.text_fields_mut().cut_selection(&field) {
1381 fx.push(InputEffect::CopyText { win, text });
1382 }
1383 }
1384 }
1385 Edit::Paste => {
1386 let ticket = Ticket(INPUT_TICKET_BASE.saturating_add(*next_ticket));
1387 *next_ticket = next_ticket.saturating_add(1);
1388 self.pending_paste = Some((ticket, Some(field.clone())));
1389 fx.push(InputEffect::NeedPaste { win, ticket });
1390 }
1391 }
1392 if changed || self.coord.text_fields().text(&field) != text_before {
1393 fx.push(InputEffect::Text(TextIntent::Changed { win, field }));
1394 }
1395 false
1397 }
1398
1399 fn masked(&self, field: &WidgetId) -> bool {
1400 self.coord
1401 .text_fields()
1402 .field_state(field)
1403 .is_some_and(|s| s.config.masked)
1404 }
1405
1406 fn ime(&mut self, win: WindowId, input: ImeInput, fx: &mut InputEffects) {
1407 let Some(field) = self.text_focus() else {
1408 return;
1409 };
1410 match input {
1411 ImeInput::Enabled => {}
1412 ImeInput::Preedit { text, cursor } => {
1413 let chars = |b: usize| text.get(..b).map(|s| s.chars().count());
1414 let at = cursor
1415 .and_then(|(b, _)| chars(b))
1416 .unwrap_or_else(|| text.chars().count());
1417 self.coord.text_fields_mut().preedit_set(&field, text, at);
1418 }
1419 ImeInput::Commit(text) => {
1420 let action = self.coord.text_fields_mut().ime_commit(&field, text);
1421 if let TextAction::TextChanged(_) = action {
1422 fx.push(InputEffect::Text(TextIntent::Changed { win, field }));
1423 }
1424 }
1425 ImeInput::Disabled => {
1426 self.coord
1427 .text_fields_mut()
1428 .preedit_set(&field, String::new(), 0);
1429 }
1430 }
1431 }
1432
1433 fn clipboard(&mut self, win: WindowId, result: ClipboardResult, fx: &mut InputEffects) {
1434 let Some((ticket, field)) = self.pending_paste.clone() else {
1435 return;
1436 };
1437 if ticket != result.ticket {
1438 return;
1439 }
1440 self.pending_paste = None;
1441 let Some(text) = result.text.filter(|t| !t.is_empty()) else {
1442 return;
1443 };
1444 let Some(field) = field else {
1445 fx.push(InputEffect::Pasted { win, text });
1446 return;
1447 };
1448 let Some(focused) = self.text_focus() else {
1449 return;
1450 };
1451 if focused != field {
1452 return;
1453 }
1454 if let TextAction::TextChanged(_) = self.coord.on_key(KeyPress::Paste(text)) {
1455 fx.push(InputEffect::Text(TextIntent::Changed { win, field }));
1456 }
1457 }
1458
1459 fn paste(&mut self, win: WindowId, text: String, fx: &mut InputEffects) {
1463 self.pending_paste = None;
1464 if text.is_empty() {
1465 return;
1466 }
1467 match self.text_focus() {
1468 Some(field) => {
1469 if let TextAction::TextChanged(_) = self.coord.on_key(KeyPress::Paste(text)) {
1470 fx.push(InputEffect::Text(TextIntent::Changed { win, field }));
1471 }
1472 }
1473 None => fx.push(InputEffect::Pasted { win, text }),
1474 }
1475 }
1476
1477 fn caret_key(&self) -> Option<CaretKey> {
1480 let store = self.coord.text_fields();
1481 let field = store.focused()?;
1482 let s = store.field_state(field)?;
1483 Some(CaretKey {
1484 field: field.clone(),
1485 engaged: s.engaged,
1486 text: s.text.clone(),
1487 cursor: s.cursor,
1488 selection: s.selection_start,
1489 preedit: s.preedit.clone(),
1490 preedit_cursor: s.preedit_cursor,
1491 })
1492 }
1493
1494 fn field_rect(&self, field: &WidgetId) -> Option<Rect> {
1495 let (x, y, w, h) = self.coord.text_fields().field_state(field)?.last_rect?;
1496 Some(Rect::new(x, y, w, h))
1497 }
1498
1499 fn caret_rect(&self, field: &WidgetId) -> Option<Rect> {
1501 let s = self.coord.text_fields().field_state(field)?;
1502 let (x, y, _, h) = s.last_rect?;
1503 let cx = s.last_char_positions.get(s.cursor).copied().unwrap_or(x);
1504 Some(Rect::new(cx, y, 1.0, h))
1505 }
1506
1507 fn settle(&mut self, win: WindowId, now: Seconds, fx: &mut InputEffects) -> bool {
1510 let now_ms = millis(now);
1511 let key = self.caret_key();
1512 let key_changed = key != self.caret;
1513 if key_changed {
1514 if let Some(old) = &self.caret {
1515 if key.as_ref().map(|k| &k.field) != Some(&old.field) {
1516 fx.push(InputEffect::InvalidateField {
1517 win,
1518 rect: self.field_rect(&old.field),
1519 });
1520 }
1521 }
1522 self.caret = key;
1523 self.blink_anchor_ms = now_ms;
1524 }
1525 self.coord
1526 .text_fields_mut()
1527 .set_blink_time(self.blink_anchor_ms);
1528 let active = self.os_focused && self.caret.as_ref().is_some_and(|k| k.engaged);
1529 let visible = active && self.coord.text_fields().cursor_visible(now_ms);
1530 let visible_changed = visible != self.caret_visible;
1531 self.caret_visible = visible;
1532 if key_changed || visible_changed {
1533 if let Some(k) = &self.caret {
1534 fx.push(InputEffect::InvalidateField {
1535 win,
1536 rect: self.field_rect(&k.field),
1537 });
1538 }
1539 }
1540 let at = active.then(|| next_blink_edge(self.blink_anchor_ms, now_ms));
1541 if at != self.armed {
1542 self.armed = at;
1543 fx.push(InputEffect::CaretDeadline { win, at });
1544 }
1545 let field = self.caret.as_ref().map(|k| k.field.clone());
1546 let allowed = field.is_some();
1547 if allowed != self.ime_allowed {
1548 self.ime_allowed = allowed;
1549 fx.push(InputEffect::ImeAllowed { win, allowed });
1550 }
1551 let area = field.and_then(|f| self.caret_rect(&f));
1552 if area != self.ime_area {
1553 self.ime_area = area;
1554 if let Some(rect) = area {
1555 fx.push(InputEffect::ImeArea { win, rect });
1556 }
1557 }
1558 key_changed || visible_changed
1559 }
1560}
1561
1562fn millis(t: Seconds) -> u64 {
1565 (t.get() * 1000.0).round().max(0.0) as u64
1567}
1568
1569fn next_blink_edge(anchor_ms: u64, now_ms: u64) -> Seconds {
1572 let phases = now_ms.saturating_sub(anchor_ms) / CARET_BLINK_MS + 1;
1573 let edge = anchor_ms.saturating_add(phases.saturating_mul(CARET_BLINK_MS));
1574 Seconds(edge as f64 / 1000.0)
1575}
1576
1577#[derive(Clone, Debug, PartialEq, Eq)]
1579enum Edit {
1580 Key(KeyPress),
1581 Char(char),
1582 Text(String),
1583 Submit,
1584 Newline,
1586 Copy,
1587 Cut,
1588 Paste,
1589}
1590
1591fn editing_chord(input: &KeyInput) -> Option<Edit> {
1594 let m = input.mods;
1595 let cmd = m.ctrl || m.meta;
1596 let edit = match input.code {
1597 KeyCode::A if cmd => Edit::Key(KeyPress::SelectAll),
1598 KeyCode::Z if cmd && m.shift => Edit::Key(KeyPress::Redo),
1599 KeyCode::Z if cmd => Edit::Key(KeyPress::Undo),
1600 KeyCode::Y if m.ctrl && !m.alt => Edit::Key(KeyPress::Redo),
1601 KeyCode::C if cmd => Edit::Copy,
1602 KeyCode::X if cmd => Edit::Cut,
1603 KeyCode::V if cmd => Edit::Paste,
1604 KeyCode::ArrowLeft if cmd => Edit::Key(KeyPress::WordLeft),
1605 KeyCode::ArrowRight if cmd => Edit::Key(KeyPress::WordRight),
1606 KeyCode::Backspace if cmd => Edit::Key(KeyPress::DeleteWordBack),
1607 KeyCode::Delete if cmd => Edit::Key(KeyPress::DeleteWordForward),
1608 KeyCode::ArrowLeft if m.shift => Edit::Key(KeyPress::ShiftLeft),
1609 KeyCode::ArrowRight if m.shift => Edit::Key(KeyPress::ShiftRight),
1610 KeyCode::Home if m.shift => Edit::Key(KeyPress::ShiftHome),
1611 KeyCode::End if m.shift => Edit::Key(KeyPress::ShiftEnd),
1612 KeyCode::ArrowLeft => Edit::Key(KeyPress::ArrowLeft),
1613 KeyCode::ArrowRight => Edit::Key(KeyPress::ArrowRight),
1614 KeyCode::Home => Edit::Key(KeyPress::Home),
1615 KeyCode::End => Edit::Key(KeyPress::End),
1616 KeyCode::Backspace => Edit::Char('\x08'),
1617 KeyCode::Delete => Edit::Key(KeyPress::Delete),
1618 KeyCode::Enter if m.shift => Edit::Newline,
1619 KeyCode::Enter => Edit::Submit,
1620 _ if cmd && !(m.ctrl && m.alt) => return None,
1623 _ => {
1624 let text: String = input
1625 .text
1626 .as_deref()?
1627 .chars()
1628 .filter(|c| !c.is_control())
1629 .collect();
1630 if text.is_empty() {
1631 return None;
1632 }
1633 match text.chars().count() {
1634 1 => Edit::Char(text.chars().next()?),
1635 _ => Edit::Text(text),
1636 }
1637 }
1638 };
1639 Some(edit)
1640}
1641
1642#[derive(Default)]
1648pub struct InputEngine {
1649 windows: VecMap<WindowId, PerWindowInput>,
1650 next_scope: u64,
1651 next_ticket: u64,
1652 rev: Revision,
1653}
1654
1655impl fmt::Debug for InputEngine {
1656 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1657 f.debug_struct("InputEngine")
1658 .field("windows", &self.windows.keys().collect::<Vec<_>>())
1659 .field("rev", &self.rev)
1660 .finish()
1661 }
1662}
1663
1664impl InputEngine {
1665 pub fn new() -> Self {
1667 Self::default()
1668 }
1669
1670 pub fn apply(&mut self, op: InputOp) -> InputEffects {
1673 let mut fx = InputEffects::new();
1674 let Self {
1675 windows,
1676 next_scope,
1677 next_ticket,
1678 rev,
1679 } = self;
1680 let changed = match op {
1681 InputOp::Open(win) => match windows.entry(win) {
1682 crate::types::vecmap::Entry::Occupied(_) => false,
1683 crate::types::vecmap::Entry::Vacant(slot) => {
1684 slot.insert(PerWindowInput::new());
1685 true
1686 }
1687 },
1688 InputOp::Close(win) => windows.remove(&win).is_some(),
1689 InputOp::WindowFocus { win, focused, now } => match windows.get_mut(&win) {
1690 Some(w) => {
1691 w.os_focused = focused;
1692 w.settle(win, now, &mut fx)
1693 }
1694 None => false,
1695 },
1696 InputOp::Pointer { win, now, input } => match windows.get_mut(&win) {
1697 Some(w) => {
1698 let (changed, cooked) = w.cook(win, now, input);
1699 fx.push(InputEffect::Pointer(cooked));
1700 changed
1701 }
1702 None => false,
1703 },
1704 InputOp::Deliver { win, input } => match windows.get_mut(&win) {
1705 Some(w) => {
1706 let (changed, target) = w.deliver(win, input, &mut fx);
1707 fx.push(InputEffect::Content { win, target, changed });
1708 changed
1709 }
1710 None => false,
1711 },
1712 InputOp::Wheel { win, input } => {
1713 if let Some(w) = windows.get_mut(&win) {
1714 let target = w.wheel(input);
1715 let changed = target.is_some();
1716 fx.push(InputEffect::Content { win, target, changed });
1717 }
1718 false
1719 }
1720 InputOp::Key { win, now, input } => match windows.get_mut(&win) {
1721 Some(w) => {
1722 let changed = w.key(win, input, next_ticket, &mut fx);
1723 w.settle(win, now, &mut fx) | changed
1724 }
1725 None => false,
1726 },
1727 InputOp::Ime { win, now, input } => match windows.get_mut(&win) {
1728 Some(w) => {
1729 w.ime(win, input, &mut fx);
1730 w.settle(win, now, &mut fx)
1731 }
1732 None => false,
1733 },
1734 InputOp::Paste { win, now, text } => match windows.get_mut(&win) {
1735 Some(w) => {
1736 w.paste(win, text, &mut fx);
1737 w.settle(win, now, &mut fx)
1738 }
1739 None => false,
1740 },
1741 InputOp::Offer { win, text } => {
1742 if let Some(w) = windows.get_mut(&win) {
1743 w.offer = text;
1744 }
1745 false
1746 }
1747 InputOp::Clipboard { win, now, result } => match windows.get_mut(&win) {
1748 Some(w) => {
1749 w.clipboard(win, result, &mut fx);
1750 w.settle(win, now, &mut fx)
1751 }
1752 None => false,
1753 },
1754 InputOp::Focus { win, now, op } => match windows.get_mut(&win) {
1755 Some(w) => {
1756 let changed = w.focus_op(win, op, next_scope, &mut fx);
1757 w.settle(win, now, &mut fx) | changed
1758 }
1759 None => false,
1760 },
1761 InputOp::SetCapture { win, capture } => windows
1762 .get_mut(&win)
1763 .is_some_and(|w| w.set_capture(capture)),
1764 InputOp::BeginFrame { win, now } => {
1765 windows.get_mut(&win).is_some_and(|w| w.begin_frame(now))
1766 }
1767 InputOp::EndFrame { win, now } => match windows.get_mut(&win) {
1768 Some(w) => {
1769 let changed = w.end_frame(win, &mut fx);
1770 w.settle(win, now, &mut fx) | changed
1771 }
1772 None => false,
1773 },
1774 };
1775 if changed {
1776 rev.bump();
1777 }
1778 fx
1779 }
1780
1781 pub fn tick(&mut self, now: Seconds) -> InputEffects {
1786 let mut fx = InputEffects::new();
1787 let mut changed = false;
1788 for (win, w) in &mut self.windows {
1789 if w.armed.is_some_and(|at| at.get() <= now.get()) {
1790 changed |= w.settle(*win, now, &mut fx);
1791 }
1792 }
1793 if changed {
1794 self.rev.bump();
1795 }
1796 fx
1797 }
1798
1799 #[allow(dead_code)]
1806 pub fn registrar(&mut self, win: WindowId) -> Option<&mut InputCoordinator> {
1807 self.windows.get_mut(&win).map(|w| &mut w.coord)
1808 }
1809
1810 #[allow(dead_code)]
1815 pub fn states_mut(&mut self, win: WindowId) -> Option<&mut uzor::app_context::StateRegistry> {
1816 self.windows.get_mut(&win).map(|w| &mut w.states)
1817 }
1818
1819 pub fn compose_parts(
1823 &mut self,
1824 win: WindowId,
1825 ) -> Option<(&mut InputCoordinator, &mut uzor::app_context::StateRegistry, &mut Selectables)> {
1826 self.windows
1827 .get_mut(&win)
1828 .map(|w| (&mut w.coord, &mut w.states, &mut w.reported))
1829 }
1830
1831 #[allow(dead_code)]
1839 pub fn update_selectable(
1840 &mut self,
1841 win: WindowId,
1842 widget: WidgetId,
1843 text: impl Into<String>,
1844 lines: Vec<SelectionLine>,
1845 ) {
1846 if let Some(w) = self.windows.get_mut(&win) {
1847 w.reported.report(widget, text, lines);
1848 }
1849 }
1850
1851 #[allow(dead_code)]
1854 pub fn alias_selectable(&mut self, win: WindowId, member: WidgetId, owner: WidgetId) {
1855 if let Some(w) = self.windows.get_mut(&win) {
1856 w.reported.alias(member, owner);
1857 }
1858 }
1859
1860 pub fn revision(&self) -> Revision {
1862 self.rev
1863 }
1864
1865 pub fn view(&self) -> InputEngineView<'_> {
1867 InputEngineView { e: self }
1868 }
1869}
1870
1871#[derive(Clone, Copy, Debug)]
1873pub struct InputEngineView<'a> {
1874 e: &'a InputEngine,
1875}
1876
1877#[allow(dead_code)]
1879impl<'a> InputEngineView<'a> {
1880 fn w(&self, win: WindowId) -> Option<&'a PerWindowInput> {
1881 self.e.windows.get(&win)
1882 }
1883
1884 pub fn ids(&self) -> impl Iterator<Item = WindowId> + 'a {
1886 self.e.windows.keys().copied()
1887 }
1888
1889 pub fn window(&self, win: WindowId) -> Option<InputView> {
1891 self.w(win).map(|w| InputView {
1892 hovered: w.hover.clone(),
1893 pressed: w.pressed.clone(),
1894 focused: w.focused_id().cloned(),
1895 focus_visible: w.focus_visible,
1896 captured: w.capture.is_some(),
1897 scope_depth: w.scopes.len(),
1898 })
1899 }
1900
1901 pub fn focused(&self, win: WindowId) -> Option<&'a WidgetId> {
1903 self.w(win)?.focused_id()
1904 }
1905
1906 pub fn active_scope(&self, win: WindowId) -> Option<&'a ScopeOwner> {
1908 self.w(win)?.scopes.last().map(|s| &s.owner)
1909 }
1910
1911 pub fn capture(&self, win: WindowId) -> Option<&'a Capture> {
1913 self.w(win)?.capture.as_ref()
1914 }
1915
1916 pub fn cook(&self, win: WindowId) -> Option<&'a CookState> {
1918 self.w(win).map(|w| &w.cook)
1919 }
1920
1921 pub fn clicked(&self, win: WindowId) -> &'a [(WidgetId, u8)] {
1924 self.w(win).map_or(&[], |w| w.clicked.as_slice())
1925 }
1926
1927 pub fn caret_visible(&self, win: WindowId) -> bool {
1930 self.w(win).is_some_and(|w| w.caret_visible)
1931 }
1932
1933 pub fn caret_deadline(&self, win: WindowId) -> Option<Seconds> {
1935 self.w(win)?.armed
1936 }
1937
1938 pub fn text_fields(&self, win: WindowId) -> Option<&'a TextFieldStore> {
1940 self.w(win).map(|w| w.coord.text_fields())
1941 }
1942
1943 pub fn selections(&self, win: WindowId) -> Option<&'a [(WidgetId, TextSelection)]> {
1947 self.w(win).map(|w| w.selections.as_slice())
1948 }
1949
1950 pub fn coordinator(&self, win: WindowId) -> Option<&'a InputCoordinator> {
1952 self.w(win).map(|w| &w.coord)
1953 }
1954
1955 pub fn pending_scroll(&self, win: WindowId) -> (f64, f64) {
1959 self.w(win).map_or((0.0, 0.0), |w| w.pointer.scroll)
1960 }
1961
1962 pub fn pending_scroll_precise(&self, win: WindowId) -> bool {
1965 self.w(win).is_some_and(|w| w.pointer.scroll_precise)
1966 }
1967
1968 pub fn context_click(&self, win: WindowId) -> Option<(f64, f64)> {
1972 self.w(win).and_then(|w| w.pointer.context)
1973 }
1974
1975 pub fn pointer(&self, win: WindowId) -> (Option<(f64, f64)>, bool) {
1976 self.w(win).map_or((None, false), |w| (w.pointer.pos, w.pointer.button_down.is_some()))
1977 }
1978
1979 pub fn press_origin(&self, win: WindowId) -> Option<(f64, f64)> {
1983 let w = self.w(win)?;
1984 w.pointer.button_down?;
1985 w.cook.press_origin.map(|o| (o.x, o.y))
1986 }
1987}
1988
1989#[cfg(test)]
1990mod tests;