fixes

Author: sysint64

druid/src/text/editable_text.rs

@@ -58,11 +58,11 @@ pub trait EditableText: Sized {
     /// Get the next codepoint offset from the given offset, if it exists.
     fn next_codepoint_offset(&self, offset: usize) -> Option<usize>;
 
-    /// Get the line beginning offset from the given offset
-    fn left_end_of_line(&self, offset: usize) -> usize;
+    /// Get the preceding line break offset from the given offset
+    fn preceding_line_break(&self, offset: usize) -> usize;
 
-    /// Get the line ending offset from the given offset
-    fn right_end_of_line(&self, offset: usize) -> usize;
+    /// Get the next line break offset from the given offset
+    fn next_line_break(&self, offset: usize) -> usize;
 
     /// Returns `true` if this text has 0 length.
     fn is_empty(&self) -> bool;
@@ -163,7 +163,7 @@ impl EditableText for String {
         s.to_string()
     }
 
-    fn left_end_of_line(&self, from: usize) -> usize {
+    fn preceding_line_break(&self, from: usize) -> usize {
         let mut offset = from;
 
         for byte in self.get(0..from).unwrap_or("").bytes().rev() {
@@ -176,7 +176,7 @@ impl EditableText for String {
         0
     }
 
-    fn right_end_of_line(&self, from: usize) -> usize {
+    fn next_line_break(&self, from: usize) -> usize {
         let mut offset = from;
 
         for char in self.get(from..).unwrap_or("").bytes() {
@@ -444,36 +444,36 @@ mod tests {
     }
 
     #[test]
-    fn left_end_of_line() {
+    fn preceding_line_break() {
         let a = String::from("Technically\na word:\n ৬藏A\u{030a}\n\u{110b}\u{1161}");
-        assert_eq!(0, a.left_end_of_line(0));
-        assert_eq!(0, a.left_end_of_line(11));
-        assert_eq!(12, a.left_end_of_line(12));
-        assert_eq!(12, a.left_end_of_line(13));
-        assert_eq!(20, a.left_end_of_line(21));
-        assert_eq!(31, a.left_end_of_line(31));
-        assert_eq!(31, a.left_end_of_line(34));
+        assert_eq!(0, a.preceding_line_break(0));
+        assert_eq!(0, a.preceding_line_break(11));
+        assert_eq!(12, a.preceding_line_break(12));
+        assert_eq!(12, a.preceding_line_break(13));
+        assert_eq!(20, a.preceding_line_break(21));
+        assert_eq!(31, a.preceding_line_break(31));
+        assert_eq!(31, a.preceding_line_break(34));
 
         let b = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
-        assert_eq!(0, b.left_end_of_line(0));
-        assert_eq!(0, b.left_end_of_line(11));
-        assert_eq!(0, b.left_end_of_line(13));
-        assert_eq!(0, b.left_end_of_line(21));
+        assert_eq!(0, b.preceding_line_break(0));
+        assert_eq!(0, b.preceding_line_break(11));
+        assert_eq!(0, b.preceding_line_break(13));
+        assert_eq!(0, b.preceding_line_break(21));
     }
 
     #[test]
-    fn right_end_of_line() {
+    fn next_line_break() {
         let a = String::from("Technically\na word:\n ৬藏A\u{030a}\n\u{110b}\u{1161}");
-        assert_eq!(11, a.right_end_of_line(0));
-        assert_eq!(11, a.right_end_of_line(11));
-        assert_eq!(19, a.right_end_of_line(13));
-        assert_eq!(30, a.right_end_of_line(21));
-        assert_eq!(a.len(), a.right_end_of_line(31));
+        assert_eq!(11, a.next_line_break(0));
+        assert_eq!(11, a.next_line_break(11));
+        assert_eq!(19, a.next_line_break(13));
+        assert_eq!(30, a.next_line_break(21));
+        assert_eq!(a.len(), a.next_line_break(31));
 
         let b = String::from("Technically a word: ৬藏A\u{030a}\u{110b}\u{1161}");
-        assert_eq!(b.len(), b.right_end_of_line(0));
-        assert_eq!(b.len(), b.right_end_of_line(11));
-        assert_eq!(b.len(), b.right_end_of_line(13));
-        assert_eq!(b.len(), b.right_end_of_line(19));
+        assert_eq!(b.len(), b.next_line_break(0));
+        assert_eq!(b.len(), b.next_line_break(11));
+        assert_eq!(b.len(), b.next_line_break(13));
+        assert_eq!(b.len(), b.next_line_break(19));
     }
 }

druid/src/text/movement.rs

@@ -28,9 +28,9 @@ pub enum Movement {
     /// Move to the right by one word.
     RightWord,
     /// Move to left end of visible line.
-    LeftOfLine,
+    PrecedingLineBreak,
     /// Move to right end of visible line.
-    RightOfLine,
+    NextLineBreak,
     /// Move to the beginning of the document
     StartOfDocument,
     /// Move to the end of the document
@@ -55,8 +55,8 @@ pub fn movement(m: Movement, s: Selection, text: &impl EditableText, modify: boo
             }
         }
 
-        Movement::LeftOfLine => text.left_end_of_line(s.end),
-        Movement::RightOfLine => text.right_end_of_line(s.end),
+        Movement::PrecedingLineBreak => text.preceding_line_break(s.end),
+        Movement::NextLineBreak => text.next_line_break(s.end),
 
         Movement::StartOfDocument => 0,
         Movement::EndOfDocument => text.len(),

druid/src/text/text_input.rs

@@ -80,11 +80,11 @@ impl TextInput for BasicTextInput {
             }
             // Select to home (Shift+Home)
             k_e if (HotKey::new(SysMods::Shift, KbKey::Home)).matches(k_e) => {
-                EditAction::ModifySelection(Movement::LeftOfLine)
+                EditAction::ModifySelection(Movement::PrecedingLineBreak)
             }
             // Select to end (Shift+End)
             k_e if (HotKey::new(SysMods::Shift, KbKey::End)).matches(k_e) => {
-                EditAction::ModifySelection(Movement::RightOfLine)
+                EditAction::ModifySelection(Movement::NextLineBreak)
             }
             // Select left (Shift+ArrowLeft)
             k_e if (HotKey::new(SysMods::Shift, KbKey::ArrowLeft)).matches(k_e) => {
@@ -126,11 +126,11 @@ impl TextInput for BasicTextInput {
             k_e if (HotKey::new(None, KbKey::Delete)).matches(k_e) => EditAction::Delete,
             // Home
             k_e if (HotKey::new(None, KbKey::Home)).matches(k_e) => {
-                EditAction::Move(Movement::LeftOfLine)
+                EditAction::Move(Movement::PrecedingLineBreak)
             }
             // End
             k_e if (HotKey::new(None, KbKey::End)).matches(k_e) => {
-                EditAction::Move(Movement::RightOfLine)
+                EditAction::Move(Movement::NextLineBreak)
             }
             // Actual typing
             k_e if key_event_is_printable(k_e) => {