Select "paragraphs" rather than words for triple click (#381)

See discussion around [#parley > Sharing selection/editing code between
Blitz and Masonry @
💬](https://xi.zulipchat.com/#narrow/channel/205635-parley/topic/Sharing.20selection.2Fediting.20code.20between.20Blitz.20and.20Masonry/near/525065337)

Author: DJMcNab

examples/vello_editor/src/text.rs

@@ -265,7 +265,7 @@ impl Editor {
                 );
                 match state.count {
                     2 => drv.select_word_at_point(cursor_pos.0, cursor_pos.1),
-                    3 => drv.select_line_at_point(cursor_pos.0, cursor_pos.1),
+                    3 => drv.select_hard_line_at_point(cursor_pos.0, cursor_pos.1),
                     _ => drv.move_to_point(cursor_pos.0, cursor_pos.1),
                 }
             }

parley/src/layout/cursor.rs

@@ -487,6 +487,21 @@ impl Selection {
         }
     }
 
+    /// Creates a new selection bounding the "logical" line at the given coordinates.
+    ///
+    /// That is, the line as defined by line break characters, rather than due to soft-wrapping.
+    pub fn hard_line_from_point<B: Brush>(layout: &Layout<B>, x: f32, y: f32) -> Self {
+        let Self { anchor, focus, .. } = Self::from_point(layout, x, y)
+            .hard_line_start(layout, false)
+            .hard_line_end(layout, true);
+        Self {
+            anchor,
+            focus,
+            anchor_base: AnchorBase::Line(anchor, focus),
+            h_pos: None,
+        }
+    }
+
     #[cfg(feature = "accesskit")]
     pub fn from_access_selection<B: Brush>(
         selection: &accesskit::TextSelection,
@@ -719,6 +734,42 @@ impl Selection {
         }
     }
 
+    /// Returns a new selection with the focus moved to just after the previous hard line break.
+    ///
+    /// If `extend` is `true` then the current anchor will be retained,
+    /// otherwise the new selection will be collapsed.
+    #[must_use]
+    pub fn hard_line_start<B: Brush>(&self, layout: &Layout<B>, extend: bool) -> Self {
+        if let Some((mut hard_line_start_index, line)) = self.focus.line(layout) {
+            let mut result_byte_index = line.text_range().start;
+            loop {
+                if hard_line_start_index == 0 {
+                    break;
+                }
+                let prev_index = hard_line_start_index - 1;
+                let Some(line) = layout.get(prev_index) else {
+                    unreachable!(
+                        "{hard_line_start_index} is a valid line in the layout, but {prev_index} isn't, despite the latter being smaller.\n\
+                        The layout has {} lines.",
+                        layout.len()
+                    );
+                };
+                if matches!(line.break_reason(), BreakReason::Explicit) {
+                    // The start of the line 'hard_line_start_index' is the target point.
+                    break;
+                }
+                result_byte_index = line.text_range().start;
+                hard_line_start_index = prev_index;
+            }
+            self.maybe_extend(
+                Cursor::from_byte_index(layout, result_byte_index, Affinity::Downstream),
+                extend,
+            )
+        } else {
+            *self
+        }
+    }
+
     /// Returns a new selection with the focus moved to the end of the
     /// current line.
     ///
@@ -740,6 +791,46 @@ impl Selection {
         }
     }
 
+    /// Returns a new selection with the focus moved to just before the next hard line break.
+    ///
+    /// If `extend` is `true` then the current anchor will be retained,
+    /// otherwise the new selection will be collapsed.
+    #[must_use]
+    pub fn hard_line_end<B: Brush>(&self, layout: &Layout<B>, extend: bool) -> Self {
+        if let Some((mut hard_line_end_index, line)) = self.focus.line(layout) {
+            let mut result_byte_index = line.text_range().end;
+            // If we're already on the last line of the hard line, use that.
+            if !matches!(line.break_reason(), BreakReason::Explicit) {
+                // Otherwise, check if any of the following lines are the last line of the hard line.
+                loop {
+                    let next_index = hard_line_end_index + 1;
+                    if let Some(line) = layout.get(next_index) {
+                        result_byte_index = line.text_range().end;
+                        hard_line_end_index = next_index;
+                        if matches!(line.break_reason(), BreakReason::Explicit) {
+                            // result_byte_index is the last byte of the previous line, so is the value we need
+                            break;
+                        }
+                    } else {
+                        // We hit the end of text. Select to the end of the "final" line, which was not an EOF.
+                        return self.maybe_extend(
+                            Cursor::from_byte_index(layout, result_byte_index, Affinity::Upstream),
+                            extend,
+                        );
+                    }
+                }
+            }
+
+            // We want to select to "before" the newline character in the hard line, so we have downstream affinity on the boundary before it.
+            self.maybe_extend(
+                Cursor::from_byte_index(layout, result_byte_index - 1, Affinity::Downstream),
+                extend,
+            )
+        } else {
+            *self
+        }
+    }
+
     /// Returns a new selection with the focus extended to the given point.
     ///
     /// If the initial selection was created from a word or line, then the new

parley/src/layout/editor.rs

@@ -464,6 +464,16 @@ where
         ));
     }
 
+    /// Move the cursor to just after the previous hard line break (such as `\n`).
+    pub fn move_to_hard_line_start(&mut self) {
+        self.refresh_layout();
+        self.editor.set_selection(
+            self.editor
+                .selection
+                .hard_line_start(&self.editor.layout, false),
+        );
+    }
+
     /// Move the cursor to the start of the physical line.
     pub fn move_to_line_start(&mut self) {
         self.refresh_layout();
@@ -481,6 +491,16 @@ where
         ));
     }
 
+    /// Move the cursor to just before the next hard line break (such as `\n`).
+    pub fn move_to_hard_line_end(&mut self) {
+        self.refresh_layout();
+        self.editor.set_selection(
+            self.editor
+                .selection
+                .hard_line_end(&self.editor.layout, false),
+        );
+    }
+
     /// Move the cursor to the end of the physical line.
     pub fn move_to_line_end(&mut self) {
         self.refresh_layout();
@@ -569,6 +589,16 @@ where
         ));
     }
 
+    /// Move the selection focus point to just after the previous hard line break (such as `\n`).
+    pub fn select_to_hard_line_start(&mut self) {
+        self.refresh_layout();
+        self.editor.set_selection(
+            self.editor
+                .selection
+                .hard_line_start(&self.editor.layout, true),
+        );
+    }
+
     /// Move the selection focus point to the start of the physical line.
     pub fn select_to_line_start(&mut self) {
         self.refresh_layout();
@@ -586,6 +616,16 @@ where
         ));
     }
 
+    /// Move the selection focus point to just before the next hard line break (such as `\n`).
+    pub fn select_to_hard_line_end(&mut self) {
+        self.refresh_layout();
+        self.editor.set_selection(
+            self.editor
+                .selection
+                .hard_line_end(&self.editor.layout, true),
+        );
+    }
+
     /// Move the selection focus point to the end of the physical line.
     pub fn select_to_line_end(&mut self) {
         self.refresh_layout();
@@ -655,12 +695,25 @@ where
     }
 
     /// Select the physical line at the point.
+    ///
+    /// Note that this metehod determines line breaks for any reason, including due to word wrapping.
+    /// To select the text between explicit newlines, use [`select_hard_line_at_point`](Self::select_hard_line_at_point).
+    /// In most text editing cases, this is the preferred behaviour.
     pub fn select_line_at_point(&mut self, x: f32, y: f32) {
         self.refresh_layout();
         let line = Selection::line_from_point(&self.editor.layout, x, y);
         self.editor.set_selection(line);
     }
 
+    /// Select the "logical" line at the point.
+    ///
+    /// The logical line is defined by line break characters, such as `\n`, rather than due to soft-wrapping.
+    pub fn select_hard_line_at_point(&mut self, x: f32, y: f32) {
+        self.refresh_layout();
+        let hard_line = Selection::hard_line_from_point(&self.editor.layout, x, y);
+        self.editor.set_selection(hard_line);
+    }
+
     /// Move the selection focus point to the cluster boundary closest to point.
     pub fn extend_selection_to_point(&mut self, x: f32, y: f32) {
         self.refresh_layout();

parley/src/layout/mod.rs

@@ -121,6 +121,9 @@ impl<B: Brush> Layout<B> {
     }
 
     /// Returns the line at the specified index.
+    ///
+    /// Returns `None` if the index is out of bounds, i.e. if it's
+    /// not less than [`self.len()`](Self::len).
     pub fn get(&self, index: usize) -> Option<Line<'_, B>> {
         Some(Line {
             index: index as u32,

parley/src/tests/test_editor.rs

@@ -34,6 +34,36 @@ fn editor_select_all() {
     env.check_editor_snapshot(&mut editor);
 }
 
+#[test]
+fn editor_select_hard_line() {
+    let mut env = TestEnv::new(test_name!(), None);
+    let mut editor = env.editor("First\nNew Hard Line with soft break!\nLast");
+    editor.set_width(Some(40.));
+    env.driver(&mut editor).move_right();
+    // We can select the first line.
+    env.driver(&mut editor).select_to_hard_line_end();
+    env.check_editor_snapshot(&mut editor);
+    env.driver(&mut editor).move_to_hard_line_start();
+    env.check_editor_snapshot(&mut editor);
+    env.driver(&mut editor).move_down();
+    env.driver(&mut editor).move_to_hard_line_end();
+    env.check_editor_snapshot(&mut editor);
+    env.driver(&mut editor).select_to_hard_line_start();
+    env.check_editor_snapshot(&mut editor);
+    env.driver(&mut editor).move_right();
+    // Cursor is logically after the newline; there's not really any great answer here.
+    env.driver(&mut editor).select_to_hard_line_start();
+    env.check_editor_snapshot(&mut editor);
+
+    // We can select the last line.
+    env.driver(&mut editor).move_right();
+    env.driver(&mut editor).move_right();
+    env.driver(&mut editor).move_to_hard_line_end();
+    env.check_editor_snapshot(&mut editor);
+    env.driver(&mut editor).select_to_hard_line_start();
+    env.check_editor_snapshot(&mut editor);
+}
+
 #[test]
 fn editor_double_newline() {
     let mut env = TestEnv::new(test_name!(), None);