Unify druid & druid-shell selection types

This lets us delete druid/src/text/selection.rs

Author: cmyr

druid-shell/examples/edit_text.rs

@@ -102,7 +102,7 @@ impl WinHandler for AppState {
             }
         }
         if !doc.selection.is_caret() {
-            for rect in layout.rects_for_range(doc.selection.to_range()) {
+            for rect in layout.rects_for_range(doc.selection.range()) {
                 piet.fill(rect, &SELECTION_BG_COLOR);
             }
         }
@@ -132,7 +132,7 @@ impl WinHandler for AppState {
             println!("user pressed c! wow! setting selection to 0");
 
             // update internal selection state
-            self.document.borrow_mut().selection = Selection::new_caret(0);
+            self.document.borrow_mut().selection = Selection::caret(0);
 
             // notify the OS that we've updated the selection
             self.handle
@@ -189,7 +189,7 @@ struct AppInputHandler {
 
 impl InputHandler for AppInputHandler {
     fn selection(&self) -> Selection {
-        self.state.borrow().selection.clone()
+        self.state.borrow().selection
     }
     fn composition_range(&self) -> Option<Range<usize>> {
         self.state.borrow().composition.clone()
@@ -282,7 +282,7 @@ fn apply_default_behavior(handler: &mut AppInputHandler, action: Action) -> bool
                     None => return false,
                 }
             };
-            handler.set_selection(Selection::new_caret(updated_index));
+            handler.set_selection(Selection::caret(updated_index));
         }
         Action::MoveSelecting(movement) => {
             let mut selection = handler.selection();
@@ -294,24 +294,21 @@ fn apply_default_behavior(handler: &mut AppInputHandler, action: Action) -> bool
         }
         Action::SelectAll => {
             let len = handler.len();
-            let selection = Selection {
-                anchor: 0,
-                active: len,
-            };
+            let selection = Selection::new(0, len);
             handler.set_selection(selection);
         }
         Action::Delete(_) if !is_caret => {
             // movement is ignored for non-caret selections
             let selection = handler.selection();
-            handler.replace_range(selection.to_range(), "");
+            handler.replace_range(selection.range(), "");
         }
         Action::Delete(movement) => {
             let mut selection = handler.selection();
             selection.active = match apply_movement(handler, movement, selection.active) {
                 Some(v) => v,
                 None => return false,
             };
-            handler.replace_range(selection.to_range(), "");
+            handler.replace_range(selection.range(), "");
         }
         _ => return false,
     }

druid-shell/src/platform/mac/text_input.rs

@@ -85,7 +85,7 @@ pub extern "C" fn marked_range(this: &mut Object, _: Sel) -> NSRange {
 
 pub extern "C" fn selected_range(this: &mut Object, _: Sel) -> NSRange {
     with_edit_lock_from_window(this, false, |mut edit_lock| {
-        let range = edit_lock.selection().to_range();
+        let range = edit_lock.selection().range();
         encode_nsrange(&mut edit_lock, range)
     })
     .unwrap_or(NSRange::NONE)
@@ -105,7 +105,7 @@ pub extern "C" fn set_marked_text(
             // https://github.com/yvt/Stella2/blob/076fb6ee2294fcd1c56ed04dd2f4644bf456e947/tcw3/pal/src/macos/window.rs#L1144-L1146
             decode_nsrange(&*edit_lock, &replacement_range, 0).unwrap_or_else(|| {
                 // no replacement range either? apparently we default to the selection in this case
-                edit_lock.selection().to_range()
+                edit_lock.selection().range()
             })
         });
 
@@ -141,15 +141,9 @@ pub extern "C" fn set_marked_text(
             // preserve ordering of anchor and active
             let existing_selection = edit_lock.selection();
             let new_selection = if existing_selection.anchor < existing_selection.active {
-                Selection {
-                    anchor: selection_range.start,
-                    active: selection_range.end,
-                }
+                Selection::new(selection_range.start, selection_range.end)
             } else {
-                Selection {
-                    active: selection_range.start,
-                    anchor: selection_range.end,
-                }
+                Selection::new(selection_range.end, selection_range.start)
             };
             edit_lock.set_selection(new_selection);
         }
@@ -206,13 +200,13 @@ pub extern "C" fn insert_text(this: &mut Object, _: Sel, text: id, replacement_r
         // https://github.com/yvt/Stella2/blob/076fb6ee2294fcd1c56ed04dd2f4644bf456e947/tcw3/pal/src/macos/window.rs#L1041-L1043
         let converted_range = decode_nsrange(&*edit_lock, &replacement_range, 0)
             .or_else(|| edit_lock.composition_range())
-            .unwrap_or_else(|| edit_lock.selection().to_range());
+            .unwrap_or_else(|| edit_lock.selection().range());
 
         edit_lock.replace_range(converted_range.clone(), text_string);
         edit_lock.set_composition_range(None);
         // move the caret next to the inserted text
         let caret_index = converted_range.start + text_string.len();
-        edit_lock.set_selection(Selection::new_caret(caret_index));
+        edit_lock.set_selection(Selection::caret(caret_index));
     });
 }
 
@@ -385,7 +379,7 @@ fn do_command_by_selector_impl(mut edit_lock: Box<dyn InputHandler>, cmd: Sel) {
                 // textedit testing showed that this operation never fully inverts a selection; if this action
                 // would cause a selection's active and anchor to swap order, it makes a caret instead. applying
                 // the operation a second time (on the selection that is now a caret) is required to invert.
-                edit_lock.set_selection(Selection::new_caret(selection.anchor));
+                edit_lock.set_selection(Selection::caret(selection.anchor));
             }
         }
         "moveParagraphForwardAndModifySelection:" => {
@@ -399,7 +393,7 @@ fn do_command_by_selector_impl(mut edit_lock: Box<dyn InputHandler>, cmd: Sel) {
                 // textedit testing showed that this operation never fully inverts a selection; if this action
                 // would cause a selection's active and anchor to swap order, it makes a caret instead. applying
                 // the operation a second time (on the selection that is now a caret) is required to invert.
-                edit_lock.set_selection(Selection::new_caret(selection.anchor));
+                edit_lock.set_selection(Selection::caret(selection.anchor));
             }
         }
         "moveRight:" => edit_lock.handle_action(Action::Move(Movement::Grapheme(Direction::Right))),
@@ -531,7 +525,7 @@ fn do_command_by_selector_impl(mut edit_lock: Box<dyn InputHandler>, cmd: Sel) {
                 edit_lock.handle_action(Action::MoveSelecting(Movement::Grapheme(
                     Direction::Downstream,
                 )));
-                let new_selection = edit_lock.selection().to_range();
+                let new_selection = edit_lock.selection().range();
                 let next_grapheme = edit_lock.slice(new_selection.clone());
                 let next_char = next_grapheme.chars().next();
 
@@ -545,7 +539,7 @@ fn do_command_by_selector_impl(mut edit_lock: Box<dyn InputHandler>, cmd: Sel) {
                     edit_lock.set_selection(old_selection);
                 } else {
                     // normally, end of transpose range will be next grapheme
-                    edit_lock.set_selection(Selection::new_caret(new_selection.end));
+                    edit_lock.set_selection(Selection::caret(new_selection.end));
                 }
             }
 
@@ -562,7 +556,7 @@ fn do_command_by_selector_impl(mut edit_lock: Box<dyn InputHandler>, cmd: Sel) {
             let second_grapheme = edit_lock.slice(middle_idx..selection.max());
             let new_string = format!("{}{}", second_grapheme, first_grapheme);
             // replace_range should automatically set selection to end of inserted range
-            edit_lock.replace_range(selection.to_range(), &new_string);
+            edit_lock.replace_range(selection.range(), &new_string);
         }
         "capitalizeWord:" => {
             // this command expands the selection to words, and then applies titlecase to that selection

druid-shell/src/text.rs

@@ -143,7 +143,8 @@ pub enum Event {
 /// holds shift and presses the right arrow key five times, we would expect the
 /// word `hello` to be selected, the `anchor` to still be `0`, and the `active`
 /// to now be `5`.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[non_exhaustive]
 pub struct Selection {
     /// The 'anchor' end of the selection.
     ///
@@ -155,18 +156,72 @@ pub struct Selection {
     /// This is the end of the selection that moves while holding shift and
     /// pressing the arrow keys.
     pub active: usize,
+    /// The saved horizontal position, during vertical movement.
+    ///
+    /// This should not be set by the IME; it will be tracked and handled by
+    /// the text field.
+    pub h_pos: Option<f64>,
 }
 
 #[allow(clippy::len_without_is_empty)]
 impl Selection {
-    /// Create a new caret (zero-length selection ) at the provided UTF-8 byte index.
+    /// Create a new `Selection` with the provided `anchor` and `active` positions.
+    ///
+    /// Both positions refer to UTF-8 byte indices in some text.
+    ///
+    /// If your selection is a caret, you can use [`Selection::caret`] instead.
+    pub fn new(anchor: usize, active: usize) -> Selection {
+        Selection {
+            anchor,
+            active,
+            h_pos: None,
+        }
+    }
+
+    /// Create a new caret (zero-length selection) at the provided UTF-8 byte index.
     ///
     /// `index` must be a grapheme cluster boundary.
-    pub fn new_caret(index: usize) -> Selection {
+    pub fn caret(index: usize) -> Selection {
         Selection {
             anchor: index,
             active: index,
+            h_pos: None,
+        }
+    }
+
+    /// Construct a new selection from this selection, with the provided h_pos.
+    ///
+    /// # Note
+    ///
+    /// `h_pos` is used to track the *pixel* location of the cursor when moving
+    /// vertically; lines may have available cursor positions at different
+    /// positions, and arrowing down and then back up should always result
+    /// in a cursor at the original starting location; doing this correctly
+    /// requires tracking this state.
+    ///
+    /// You *probably* don't need to use this, unless you are implementing a new
+    /// text field, or otherwise implementing vertical cursor motion, in which
+    /// case you will want to set this during vertical motion if it is not
+    /// already set.
+    pub fn with_h_pos(mut self, h_pos: Option<f64>) -> Self {
+        self.h_pos = h_pos;
+        self
+    }
+
+    /// Create a new selection that is guaranteed to be valid for the provided
+    /// text.
+    #[must_use = "constrained constructs a new Selection"]
+    pub fn constrained(mut self, s: &str) -> Self {
+        let s_len = s.len();
+        self.anchor = self.anchor.min(s_len);
+        self.active = self.active.min(s_len);
+        while !s.is_char_boundary(self.anchor) {
+            self.anchor += 1;
         }
+        while !s.is_char_boundary(self.active) {
+            self.active += 1;
+        }
+        self
     }
 
     /// Return the position of the upstream end of the selection.
@@ -191,7 +246,7 @@ impl Selection {
     ///
     /// This is the range that would be replaced if text were inserted at this
     /// selection.
-    pub fn to_range(&self) -> Range<usize> {
+    pub fn range(&self) -> Range<usize> {
         self.min()..self.max()
     }
 
@@ -241,6 +296,9 @@ pub trait InputHandler {
     /// Both `selection.anchor` and `selection.active` must be less
     /// than or equal to the value returned from `InputHandler::len()`.
     ///
+    /// Properties of the `Selection` *other* than `anchor` and `active` may
+    /// be ignored by the handler.
+    ///
     /// The `set_selection` implementation should round up (downstream) both
     /// `selection.anchor` and `selection.active` to the nearest extended
     /// grapheme cluster boundary.
@@ -414,9 +472,9 @@ pub fn simulate_input<H: WinHandler + ?Sized>(
     match event.key {
         KbKey::Character(c) if !event.mods.ctrl() && !event.mods.meta() && !event.mods.alt() => {
             let selection = input_handler.selection();
-            input_handler.replace_range(selection.to_range(), &c);
+            input_handler.replace_range(selection.range(), &c);
             let new_caret_index = selection.min() + c.len();
-            input_handler.set_selection(Selection::new_caret(new_caret_index));
+            input_handler.set_selection(Selection::caret(new_caret_index));
         }
         KbKey::ArrowLeft => {
             let movement = Movement::Grapheme(Direction::Left);

druid/src/text/backspace.rs

@@ -198,6 +198,6 @@ pub fn offset_for_delete_backwards(region: &Selection, text: &impl EditableText)
     if !region.is_caret() {
         region.min()
     } else {
-        backspace_offset(text, region.end)
+        backspace_offset(text, region.active)
     }
 }

druid/src/text/input_component.rs

@@ -415,7 +415,7 @@ impl<T: TextStorage + EditableText> Widget<T> for TextComponent<T> {
         let sel_rects = self.borrow().layout.rects_for_range(selection.range());
         if let Some(composition) = composition {
             // I believe selection should always be contained in composition range while composing?
-            assert!(composition.start <= selection.start && composition.end >= selection.end);
+            assert!(composition.start <= selection.anchor && composition.end >= selection.active);
             let comp_rects = self.borrow().layout.rects_for_range(composition);
             for region in comp_rects {
                 let y = region.max_y().floor();
@@ -647,7 +647,7 @@ impl<T: TextStorage + EditableText> EditSession<T> {
     fn backspace(&mut self, buffer: &mut T) {
         let to_del = if self.selection.is_caret() {
             let del_start = crate::text::offset_for_delete_backwards(&self.selection, buffer);
-            del_start..self.selection.start
+            del_start..self.selection.anchor
         } else {
             self.selection.range()
         };
@@ -660,19 +660,19 @@ impl<T: TextStorage + EditableText> EditSession<T> {
         let point = point + Vec2::new(self.alignment_offset, 0.0);
         let pos = self.layout.text_position_for_point(point);
         if mods.shift() {
-            self.selection.end = pos;
+            self.selection.active = pos;
         } else {
             let sel = self.sel_region_for_pos(pos, count);
-            self.selection.start = sel.start;
-            self.selection.end = sel.end;
+            self.selection.anchor = sel.start;
+            self.selection.active = sel.end;
         }
     }
 
     fn do_drag(&mut self, point: Point) {
         let point = point + Vec2::new(self.alignment_offset, 0.0);
         //FIXME: this should behave differently if we were double or triple clicked
         let pos = self.layout.text_position_for_point(point);
-        self.selection.end = pos;
+        self.selection.active = pos;
         self.scroll_to_selection_end(false);
     }
 
@@ -717,7 +717,7 @@ impl<T: TextStorage + EditableText> EditSession<T> {
         if self.layout.needs_rebuild_after_update(ctx) {
             ctx.request_layout();
         }
-        let new_sel = self.selection.constrained(new_data);
+        let new_sel = self.selection.constrained(new_data.as_str());
         if new_sel != self.selection {
             self.selection = new_sel;
             self.update_pending_invalidation(ImeUpdate::SelectionChanged);
@@ -734,12 +734,12 @@ impl<T: TextStorage> EditSessionHandle<T> {
 }
 
 impl<T: TextStorage + EditableText> InputHandler for EditSessionHandle<T> {
-    fn selection(&self) -> crate::shell::text::Selection {
-        self.inner.borrow().selection.into()
+    fn selection(&self) -> Selection {
+        self.inner.borrow().selection
     }
 
-    fn set_selection(&mut self, selection: crate::shell::text::Selection) {
-        self.inner.borrow_mut().external_selection_change = Some(selection.into());
+    fn set_selection(&mut self, selection: Selection) {
+        self.inner.borrow_mut().external_selection_change = Some(selection);
         self.inner.borrow_mut().external_scroll_to = Some(true);
     }
 

druid/src/text/mod.rs

@@ -24,16 +24,16 @@ mod input_methods;
 mod layout;
 pub mod movement;
 mod rich_text;
-pub mod selection;
 mod storage;
 
+pub use druid_shell::text::Selection;
+
 pub use self::attribute::{Attribute, AttributeSpans, Link};
 pub use self::backspace::offset_for_delete_backwards;
 pub use self::editable_text::{EditableText, EditableTextCursor, StringCursor};
 pub use self::font_descriptor::FontDescriptor;
 pub use self::layout::{LayoutMetrics, TextLayout};
 pub use self::movement::{movement, Movement};
-pub use self::selection::Selection;
 pub use input_component::{EditSession, TextComponent};
 pub use input_methods::ImeHandlerRef;
 pub use rich_text::{AttributesAdder, RichText, RichTextBuilder};