//! Operate on widgets that can be focused. use crate::widget::operation::{Operation, Outcome}; use crate::widget::Id; /// The internal state of a widget that can be focused. pub trait Focusable { /// Returns whether the widget is focused or not. fn is_focused(&self) -> bool; /// Focuses the widget. fn focus(&mut self); /// Unfocuses the widget. fn unfocus(&mut self); } /// A summary of the focusable widgets present on a widget tree. #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct Count { /// The index of the current focused widget, if any. focused: Option, /// The total amount of focusable widgets. total: usize, } /// Produces an [`Operation`] that focuses the widget with the given [`Id`]. pub fn focus(target: Id) -> impl Operation { struct Focus { target: Id, } impl Operation for Focus { fn focusable(&mut self, state: &mut dyn Focusable, id: Option<&Id>) { match id { Some(id) if id == &self.target => { state.focus(); } _ => { state.unfocus(); } } } fn container( &mut self, _id: Option<&Id>, operate_on_children: &mut dyn FnMut(&mut dyn Operation), ) { operate_on_children(self) } } Focus { target } } /// Produces an [`Operation`] that generates a [`Count`] and chains it with the /// provided function to build a new [`Operation`]. pub fn count(f: fn(Count) -> O) -> impl Operation where O: Operation + 'static, { struct CountFocusable { count: Count, next: fn(Count) -> O, } impl Operation for CountFocusable where O: Operation + 'static, { fn focusable(&mut self, state: &mut dyn Focusable, _id: Option<&Id>) { if state.is_focused() { self.count.focused = Some(self.count.total); } self.count.total += 1; } fn container( &mut self, _id: Option<&Id>, operate_on_children: &mut dyn FnMut(&mut dyn Operation), ) { operate_on_children(self) } fn finish(&self) -> Outcome { Outcome::Chain(Box::new((self.next)(self.count))) } } CountFocusable { count: Count::default(), next: f, } } /// Produces an [`Operation`] that searches for the current focused widget, and /// - if found, focuses the previous focusable widget. /// - if not found, focuses the last focusable widget. pub fn focus_previous() -> impl Operation { struct FocusPrevious { count: Count, current: usize, } impl Operation for FocusPrevious { fn focusable(&mut self, state: &mut dyn Focusable, _id: Option<&Id>) { if self.count.total == 0 { return; } match self.count.focused { None if self.current == self.count.total - 1 => state.focus(), Some(0) if self.current == 0 => state.unfocus(), Some(0) => {} Some(focused) if focused == self.current => state.unfocus(), Some(focused) if focused - 1 == self.current => state.focus(), _ => {} } self.current += 1; } fn container( &mut self, _id: Option<&Id>, operate_on_children: &mut dyn FnMut(&mut dyn Operation), ) { operate_on_children(self) } } count(|count| FocusPrevious { count, current: 0 }) } /// Produces an [`Operation`] that searches for the current focused widget, and /// - if found, focuses the next focusable widget. /// - if not found, focuses the first focusable widget. pub fn focus_next() -> impl Operation { struct FocusNext { count: Count, current: usize, } impl Operation for FocusNext { fn focusable(&mut self, state: &mut dyn Focusable, _id: Option<&Id>) { match self.count.focused { None if self.current == 0 => state.focus(), Some(focused) if focused == self.current => state.unfocus(), Some(focused) if focused + 1 == self.current => state.focus(), _ => {} } self.current += 1; } fn container( &mut self, _id: Option<&Id>, operate_on_children: &mut dyn FnMut(&mut dyn Operation), ) { operate_on_children(self) } } count(|count| FocusNext { count, current: 0 }) }