From 13dd1ca0a83cc95eea52e2106da9dc1ee1f37958 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Thu, 4 Aug 2022 03:55:41 +0200 Subject: Implement `scrollable::snap_to` operation --- native/src/widget/operation/focusable.rs | 149 +++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) create mode 100644 native/src/widget/operation/focusable.rs (limited to 'native/src/widget/operation/focusable.rs') diff --git a/native/src/widget/operation/focusable.rs b/native/src/widget/operation/focusable.rs new file mode 100644 index 00000000..20a73291 --- /dev/null +++ b/native/src/widget/operation/focusable.rs @@ -0,0 +1,149 @@ +use crate::widget::operation::{Operation, Outcome}; +use crate::widget::Id; + +pub trait Focusable { + fn is_focused(&self) -> bool; + fn focus(&mut self); + fn unfocus(&mut self); +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct Count { + focused: Option, + total: usize, +} + +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 } +} + +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, + } +} + +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 }) +} + +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 }) +} -- cgit From 66f7d43dc98df96c8b19cfd2aef6dcdd4187316c Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Fri, 5 Aug 2022 05:15:41 +0200 Subject: Write missing documentation in `iced_native` --- native/src/widget/operation/focusable.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'native/src/widget/operation/focusable.rs') diff --git a/native/src/widget/operation/focusable.rs b/native/src/widget/operation/focusable.rs index 20a73291..d20bfef9 100644 --- a/native/src/widget/operation/focusable.rs +++ b/native/src/widget/operation/focusable.rs @@ -1,18 +1,30 @@ +//! 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, @@ -42,6 +54,7 @@ pub fn focus(target: Id) -> impl Operation { Focus { target } } +/// Produces an [`Operation`] that generates a [`Count`]. pub fn count(f: fn(Count) -> O) -> impl Operation where O: Operation + 'static, @@ -82,6 +95,9 @@ where } } +/// Produces an [`Operation`] that searches for the current focuses 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, @@ -118,6 +134,9 @@ pub fn focus_previous() -> impl Operation { count(|count| FocusPrevious { count, current: 0 }) } +/// Produces an [`Operation`] that searches for the current focuses 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, -- cgit From ad5bd0970d7106a97d455a164a582ab1d0bff18b Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Fri, 5 Aug 2022 06:01:54 +0200 Subject: Fix documentation in `operation::focusable` --- native/src/widget/operation/focusable.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'native/src/widget/operation/focusable.rs') diff --git a/native/src/widget/operation/focusable.rs b/native/src/widget/operation/focusable.rs index d20bfef9..f17bf178 100644 --- a/native/src/widget/operation/focusable.rs +++ b/native/src/widget/operation/focusable.rs @@ -54,7 +54,8 @@ pub fn focus(target: Id) -> impl Operation { Focus { target } } -/// Produces an [`Operation`] that generates a [`Count`]. +/// 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, @@ -95,7 +96,7 @@ where } } -/// Produces an [`Operation`] that searches for the current focuses widget, and +/// 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 { @@ -134,7 +135,7 @@ pub fn focus_previous() -> impl Operation { count(|count| FocusPrevious { count, current: 0 }) } -/// Produces an [`Operation`] that searches for the current focuses widget, and +/// 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 { -- cgit