Merge pull request #2664 from Leonie-Theobald/findfocus_for_textinput

Implement find_focused() for text_input

examples/delineate/src/main.rs

@@ -28,8 +28,8 @@ enum Message {
     MouseMoved(Point),
     WindowResized,
     Scrolled,
-    OuterFound(Option<Rectangle>),
-    InnerFound(Option<Rectangle>),
+    OuterFound(Option<selector::Target>),
+    InnerFound(Option<selector::Target>),
 }
 
 impl Example {
@@ -41,16 +41,18 @@ impl Example {
                 Task::none()
             }
             Message::Scrolled | Message::WindowResized => Task::batch(vec![
-                selector::delineate(OUTER_CONTAINER).map(Message::OuterFound),
-                selector::delineate(INNER_CONTAINER).map(Message::InnerFound),
+                selector::find(OUTER_CONTAINER).map(Message::OuterFound),
+                selector::find(INNER_CONTAINER).map(Message::InnerFound),
             ]),
             Message::OuterFound(outer) => {
-                self.outer_bounds = outer;
+                self.outer_bounds =
+                    outer.as_ref().and_then(selector::Target::visible_bounds);
 
                 Task::none()
             }
             Message::InnerFound(inner) => {
-                self.inner_bounds = inner;
+                self.inner_bounds =
+                    inner.as_ref().and_then(selector::Target::visible_bounds);
 
                 Task::none()
             }

runtime/src/widget/selector.rs

@@ -1,28 +1,25 @@
 //! Find and query widgets in your applications.
-pub use iced_selector::{Bounded, Candidate, Selector, Target, Text};
-
-use crate::core::Rectangle;
+pub use iced_selector::{
+    Bounded, Candidate, Selector, Target, Text, id, is_focused,
+};
 
 use crate::Task;
-use crate::core::widget;
 use crate::task;
 
-/// Finds a widget by the given [`widget::Id`].
-pub fn find_by_id(id: impl Into<widget::Id>) -> Task<Option<Target>> {
-    task::widget(id.into().find())
-}
-
-/// Finds a widget that contains the given text.
-pub fn find_by_text(text: impl Into<String>) -> Task<Option<Text>> {
-    task::widget(Selector::find(text.into()))
-}
-
-/// Finds the visible bounds of the first [`Selector`] target.
-pub fn delineate<S>(selector: S) -> Task<Option<Rectangle>>
+/// Finds a widget matching the given [`Selector`].
+pub fn find<S>(selector: S) -> Task<Option<S::Output>>
 where
     S: Selector + Send + 'static,
-    S::Output: Bounded + Clone + Send + 'static,
+    S::Output: Send + Clone + 'static,
 {
     task::widget(selector.find())
-        .map(|target| target.as_ref().and_then(Bounded::visible_bounds))
+}
+
+/// Finds all widgets matching the given [`Selector`].
+pub fn find_all<S>(selector: S) -> Task<Vec<S::Output>>
+where
+    S: Selector + Send + 'static,
+    S::Output: Send + Clone + 'static,
+{
+    task::widget(selector.find_all())
 }

selector/src/lib.rs

@@ -146,3 +146,28 @@ where
 pub fn id(id: impl Into<widget::Id>) -> impl Selector<Output = Target> {
     id.into()
 }
+
+/// Returns a [`Selector`] that matches widgets that are currently focused.
+pub fn is_focused() -> impl Selector<Output = Target> {
+    struct IsFocused;
+
+    impl Selector for IsFocused {
+        type Output = Target;
+
+        fn select(&mut self, candidate: Candidate<'_>) -> Option<Self::Output> {
+            if let Candidate::Focusable { state, .. } = candidate
+                && state.is_focused()
+            {
+                Some(Target::from(candidate))
+            } else {
+                None
+            }
+        }
+
+        fn description(&self) -> String {
+            "is focused".to_owned()
+        }
+    }
+
+    IsFocused
+}

src/lib.rs

@@ -327,7 +327,7 @@
 //! Tasks can also be used to interact with the iced runtime. Some modules
 //! expose functions that create tasks for different purposes—like [changing
 //! window settings](window#functions), [focusing a widget](widget::operation::focus_next), or
-//! [querying its visible bounds](widget::selector::find_by_id).
+//! [querying its visible bounds](widget::selector::find).
 //!
 //! Like futures and streams, tasks expose [a monadic interface](Task::then)—but they can also be
 //! [mapped](Task::map), [chained](Task::chain), [batched](Task::batch), [canceled](Task::abortable),