iced-rs
diff --git a/‎core/src/text/paragraph.rs‎
Lines changed: 21 additions & 0 deletions b/‎core/src/text/paragraph.rs‎
Lines changed: 21 additions & 0 deletions
diff --git a/‎core/src/widget/operation.rs‎
Lines changed: 20 additions & 0 deletions b/‎core/src/widget/operation.rs‎
Lines changed: 20 additions & 0 deletions
diff --git a/‎core/src/widget/operation/selectable.rs‎
Lines changed: 92 additions & 0 deletions b/‎core/src/widget/operation/selectable.rs‎
Lines changed: 92 additions & 0 deletions
@@ -73,6 +73,27 @@ pub trait Paragraph: Sized + Default {
     /// Returns the distance to the given grapheme index in the [`Paragraph`].
     fn grapheme_position(&self, line: usize, index: usize) -> Option<Point>;
 
+    /// Returns the visual rectangles covering the byte range
+    /// `start..end` of the [`Paragraph`]'s source text. Used to paint
+    /// selection highlights.
+    fn selection_bounds(&self, _start: usize, _end: usize) -> Vec<Rectangle> {
+        Vec::new()
+    }
+
+    /// Returns the visual position of the given byte offset in the
+    /// [`Paragraph`]'s source text. Used by `Shift+Up`/`Down` and
+    /// `Shift+Home`/`End` to hit-test targets relative to the focus.
+    fn byte_position(&self, _byte: usize) -> Option<Point> {
+        None
+    }
+
+    /// The visual line height the [`Paragraph`] is rendered with —
+    /// the distance to step for `Shift+Up`/`Down`. Returns `None`
+    /// when the renderer doesn't track per-line geometry.
+    fn visual_line_height(&self) -> Option<f32> {
+        None
+    }
+
     /// Returns the minimum width that can fit the contents of the [`Paragraph`].
     fn min_width(&self) -> f32 {
         self.min_bounds().width
 
@@ -1,10 +1,12 @@
 //! Query or update internal widget state.
 pub mod focusable;
 pub mod scrollable;
+pub mod selectable;
 pub mod text_input;
 
 pub use focusable::Focusable;
 pub use scrollable::Scrollable;
+pub use selectable::Selectable;
 pub use text_input::TextInput;
 
 use crate::widget::Id;
@@ -46,6 +48,15 @@ pub trait Operation<T = ()>: Send {
     /// Operates on a widget that has text input.
     fn text_input(&mut self, _id: Option<&Id>, _bounds: Rectangle, _state: &mut dyn TextInput) {}
 
+    /// Operates on a widget that owns a text selection.
+    fn selectable(
+        &mut self,
+        _id: Option<&Id>,
+        _bounds: Rectangle,
+        _state: &mut dyn Selectable,
+    ) {
+    }
+
     /// Operates on a widget that contains some text.
     fn text(&mut self, _id: Option<&Id>, _bounds: Rectangle, _text: &str) {}
 
@@ -90,6 +101,15 @@ where
         self.as_mut().text_input(id, bounds, state);
     }
 
+    fn selectable(
+        &mut self,
+        id: Option<&Id>,
+        bounds: Rectangle,
+        state: &mut dyn Selectable,
+    ) {
+        self.as_mut().selectable(id, bounds, state);
+    }
+
     fn text(&mut self, id: Option<&Id>, bounds: Rectangle, text: &str) {
         self.as_mut().text(id, bounds, text);
     }
 
@@ -0,0 +1,92 @@
+//! Operate on widgets that can have a text selection.
+use crate::{Point, Rectangle};
+
+/// The internal state of a widget that owns a text selection.
+///
+/// Implemented by `rich_text`'s state. Coordinator widgets like
+/// `selectable_group` reach into selectables through this trait via
+/// the [`Operation::selectable`] hook, mirroring how `Focusable` and
+/// `Operation::focusable` cooperate.
+///
+/// [`Operation::selectable`]: super::Operation::selectable
+pub trait Selectable {
+    /// The current selection as a half-open byte range in the
+    /// widget's source text. `None` when nothing is selected.
+    fn selection(&self) -> Option<(usize, usize)>;
+
+    /// Sets the selection range. Pass `None` to clear.
+    fn set_selection(&mut self, range: Option<(usize, usize)>);
+
+    /// Total length, in bytes, of the widget's text.
+    fn text_len(&self) -> usize;
+
+    /// The substring covered by the byte range `[start, end)`.
+    fn selection_text(&self, start: usize, end: usize) -> String;
+
+    /// Steps `byte` to the next or previous UTF-8 char boundary.
+    /// `dir > 0` moves forward, `dir < 0` moves backward.
+    fn step_byte(&self, byte: usize, dir: i32) -> usize;
+
+    /// Steps `byte` to the next or previous word start.
+    fn step_byte_word(&self, byte: usize, dir: i32) -> usize;
+
+    /// Steps `byte` up or down one visual line. Returns `None` when
+    /// the target falls outside the widget's rendered area.
+    fn step_byte_line(&self, byte: usize, dir: i32) -> Option<usize>;
+
+    /// Byte at the start (`dir < 0`) or end (`dir > 0`) of the
+    /// visual line containing `byte`.
+    fn line_edge_byte(&self, byte: usize, dir: i32) -> Option<usize>;
+
+    /// Visual position of `byte` in widget-local coordinates.
+    fn byte_position(&self, byte: usize) -> Option<Point>;
+
+    /// Visual line height the widget renders with.
+    fn visual_line_height(&self) -> Option<f32>;
+
+    /// Hit-tests a widget-local point and returns the byte at that
+    /// position.
+    fn hit_test(&self, point: Point) -> Option<usize>;
+
+    /// Marks the widget as externally managed. While `true`, the
+    /// widget's own event handlers should skip drag-select and
+    /// `Ctrl+C`, leaving its `selection` for an external coordinator
+    /// to fill in.
+    fn set_externally_managed(&mut self, value: bool);
+}
+
+/// Visits every [`Selectable`] in the operated subtree, invoking a
+/// callback with each one's bounds and state. Used by
+/// `selectable_group` to drive coordinated selection without knowing
+/// concrete widget types.
+pub fn visit<F>(callback: F) -> Visit<F>
+where
+    F: FnMut(Rectangle, &mut dyn Selectable),
+{
+    Visit { callback }
+}
+
+/// An [`Operation`](super::Operation) that runs a callback on every
+/// [`Selectable`] it encounters during traversal.
+#[derive(Debug)]
+pub struct Visit<F> {
+    callback: F,
+}
+
+impl<F> super::Operation for Visit<F>
+where
+    F: FnMut(Rectangle, &mut dyn Selectable) + Send,
+{
+    fn selectable(
+        &mut self,
+        _id: Option<&crate::widget::Id>,
+        bounds: Rectangle,
+        state: &mut dyn Selectable,
+    ) {
+        (self.callback)(bounds, state);
+    }
+
+    fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn super::Operation)) {
+        operate(self);
+    }
+}